tests/carservice_unit_test/src/com/android/car/CarOccupantConnectionManagerUnitTest.java - platform/packages/services/Car - Git at Google

 /*
  * Copyright (C) 2023 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.car;

 import static android.car.CarOccupantZoneManager.OCCUPANT_TYPE_DRIVER;
 import static android.car.VehicleAreaSeat.SEAT_ROW_1_LEFT;
 import static android.car.occupantconnection.CarOccupantConnectionManager.CONNECTION_ERROR_USER_REJECTED;

 import static com.google.common.truth.Truth.assertThat;

 import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

 import android.car.Car;
 import android.car.CarOccupantZoneManager.OccupantZoneInfo;
 import android.car.occupantconnection.CarOccupantConnectionManager;
 import android.car.occupantconnection.CarOccupantConnectionManager.ConnectionRequestCallback;
 import android.car.occupantconnection.CarOccupantConnectionManager.PayloadCallback;
 import android.car.occupantconnection.CarOccupantConnectionManager.PayloadTransferException;
 import android.car.occupantconnection.ICarOccupantConnection;
 import android.car.occupantconnection.IConnectionRequestCallback;
 import android.car.occupantconnection.IPayloadCallback;
 import android.car.occupantconnection.Payload;
 import android.content.Context;
 import android.os.IBinder;
 import android.os.RemoteException;

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;

 import java.util.concurrent.Executor;

 @RunWith(MockitoJUnitRunner.class)
 public final class CarOccupantConnectionManagerUnitTest {

     private static final String PACKAGE_NAME = "my_package_name";
     private static final String RECEIVER_ENDPOINT_ID = "test_receiver_endpointId";
     private static final int TIMEOUT_MS = 1000;

     @Mock
     private Car mCar;
     @Mock
     private Context mContext;
     @Mock
     private IBinder mBinder;
     @Mock
     private ICarOccupantConnection mService;
     @Mock
     private Executor mCallbackExecutor;
     @Mock
     private ConnectionRequestCallback mConnectionRequestCallback;
     @Mock
     private PayloadCallback mPayloadCallback;

     private final OccupantZoneInfo mReceiverZone =
             new OccupantZoneInfo(/* zoneId= */ 0, OCCUPANT_TYPE_DRIVER, SEAT_ROW_1_LEFT);

     private CarOccupantConnectionManager mOccupantConnectionManager;

     @Before
     public void setUp() {
         when(mBinder.queryLocalInterface(anyString())).thenReturn(mService);
         when(mCar.getContext()).thenReturn(mContext);
         when(mContext.getPackageName()).thenReturn(PACKAGE_NAME);
         mOccupantConnectionManager = new CarOccupantConnectionManager(mCar, mBinder);
     }

     @Test
     public void testRequestConnectionWithNullParameters_throwsException() {
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.requestConnection(
                         /* receiverZone= */ null, mCallbackExecutor, mConnectionRequestCallback));
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.requestConnection(
                         mReceiverZone, /* executor= */ null, mConnectionRequestCallback));
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.requestConnection(
                         mReceiverZone, mCallbackExecutor, /* callback= */ null));
     }

     @Test
     public void testRequestConnectionWithPendingConnection_throwsException() {
         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mock(ConnectionRequestCallback.class));

         // The client shouldn't request another connection to the same occupant zone because there
         // is a pending connection request to that occupant zone.
         assertThrows(IllegalStateException.class,
                 () -> mOccupantConnectionManager.requestConnection(
                         mReceiverZone, mCallbackExecutor, mConnectionRequestCallback));
     }

     @Test
     public void testRequestConnectionWithEstablishedConnection_throwsException()
             throws RemoteException {
         IConnectionRequestCallback[] binderCallback = new IConnectionRequestCallback[1];
         doAnswer((invocation) -> {
             Object[] args = invocation.getArguments();
             binderCallback[0] = (IConnectionRequestCallback) args[2];
             return null;
         }).when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());

         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mock(ConnectionRequestCallback.class));
         binderCallback[0].onConnected(mReceiverZone);

         // The client shouldn't request another connection to the same occupant zone because there
         // is an established connection to that occupant zone.
         assertThrows(IllegalStateException.class,
                 () -> mOccupantConnectionManager.requestConnection(
                         mReceiverZone, mCallbackExecutor, mConnectionRequestCallback));
     }

     @Test
     public void testRequestConnectionWithRejectedConnection() throws RemoteException {
         IConnectionRequestCallback[] binderCallback = new IConnectionRequestCallback[1];
         doAnswer((invocation) -> {
             Object[] args = invocation.getArguments();
             binderCallback[0] = (IConnectionRequestCallback) args[2];
             return null;
         }).when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());

         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mock(ConnectionRequestCallback.class));
         binderCallback[0].onFailed(mReceiverZone, CONNECTION_ERROR_USER_REJECTED);

         // The client can request another connection to the same occupant zone since the previous
         // request was rejected.
         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mConnectionRequestCallback);
     }

     @Test
     public void testRequestConnectionWithRemoteException() throws RemoteException {
         // The first call fails due to a RemoteException.
         doThrow(new RemoteException())
                 .when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());
         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mConnectionRequestCallback);

         // The second call succeeds. It should not trigger IllegalStateException because
         // mConnectionRequestCallback was not added previously.
         doNothing()
                 .when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());
         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mConnectionRequestCallback);
     }

     @Test
     public void testRequestConnectionCallbackInvoked() throws RemoteException {
         IConnectionRequestCallback[] binderCallback = new IConnectionRequestCallback[1];
         doAnswer((invocation) -> {
             Object[] args = invocation.getArguments();
             String packageName = (String) args[0];
             assertThat(packageName).isEqualTo(PACKAGE_NAME);
             OccupantZoneInfo receiverZone = (OccupantZoneInfo) args[1];
             assertThat(receiverZone).isEqualTo(mReceiverZone);
             binderCallback[0] = (IConnectionRequestCallback) args[2];
             // Don't call binderCallback[0].onConnected() here, because mConnectionRequestCallback
             // is added AFTER this method returns. So if we call binderCallback.onConnected() here,
             // mConnectionRequestCallback will not be invoked.
             return null;
         }).when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());

         mOccupantConnectionManager.requestConnection(mReceiverZone, command -> {
             command.run();
             // Verify that mConnectionRequestCallback is invoked on the Executor.
             verify(mConnectionRequestCallback, timeout(1000)).onConnected(mReceiverZone);
         }, mConnectionRequestCallback);
         binderCallback[0].onConnected(mReceiverZone);
     }

     @Test
     public void testCancelConnectionWithNullParameter_throwsException() {
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.cancelConnection(/* receiverZone= */ null));

     }

     @Test
     public void testCancelConnectionWithoutConnectionRequest_throwsException() {
         assertThrows(IllegalStateException.class,
                 () -> mOccupantConnectionManager.cancelConnection(mReceiverZone));
     }

     @Test
     public void testCancelConnection() throws RemoteException {
         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mConnectionRequestCallback);
         mOccupantConnectionManager.cancelConnection(mReceiverZone);
         mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
                 mConnectionRequestCallback);
         mOccupantConnectionManager.cancelConnection(mReceiverZone);

         verify(mService, times(2)).cancelConnection(PACKAGE_NAME, mReceiverZone);
     }

     @Test
     public void testRegisterReceiverWithNullParameters_throwsException() {
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.registerReceiver(
                         /* receiverEndpointId= */ null, mCallbackExecutor, mPayloadCallback));
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.registerReceiver(
                         RECEIVER_ENDPOINT_ID, /* executor= */ null, mPayloadCallback));
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.registerReceiver(
                         RECEIVER_ENDPOINT_ID, mCallbackExecutor, /* callback= */ null));
     }

     @Test
     public void testRegisterReceiverWithDuplicateReceiverId_throwsException()
             throws RemoteException {
         // The first registerReceiver() call should run normally, while the second
         // registerReceiver() call should throw an exception because the same ID has been
         // registered.
         doNothing().doThrow(IllegalStateException.class)
                 .when(mService).registerReceiver(eq(PACKAGE_NAME), eq(RECEIVER_ENDPOINT_ID), any());
         mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, mCallbackExecutor,
                 mPayloadCallback);

         assertThrows(IllegalStateException.class,
                 () -> mOccupantConnectionManager.registerReceiver(
                         RECEIVER_ENDPOINT_ID, mCallbackExecutor, mPayloadCallback));
     }

     @Test
     public void testRegisterReceiverWithRemoteException() throws RemoteException {
         // The first call fails due to a RemoteException.
         doThrow(new RemoteException())
                 .when(mService).registerReceiver(anyString(), anyString(), any());
         mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, mCallbackExecutor,
                 mPayloadCallback);

         // The second call succeeds. It should not trigger IllegalStateException because
         // mPayloadCallback was not added previously.
         doNothing().when(mService).registerReceiver(anyString(), anyString(), any());
         mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, mCallbackExecutor,
                 mPayloadCallback);
     }

     @Test
     public void testRegisterReceiverCallbackInvoked() throws RemoteException {
         OccupantZoneInfo senderZone = mock(OccupantZoneInfo.class);
         Payload payload = mock(Payload.class);
         IPayloadCallback[] binderCallback = new IPayloadCallback[1];
         doAnswer((invocation) -> {
             Object[] args = invocation.getArguments();
             String packageName = (String) args[0];
             assertThat(packageName).isEqualTo(PACKAGE_NAME);
             String receiverEndpointId = (String) args[1];
             assertThat(receiverEndpointId).isEqualTo(RECEIVER_ENDPOINT_ID);
             binderCallback[0] = (IPayloadCallback) args[2];
             // Don't call binderCallback[0].onPayloadReceived() here, because mPayloadCallback
             // is added AFTER this method returns. So if we call binderCallback.onPayloadReceived()
             // here, mPayloadCallback will not be invoked.
             return null;
         }).when(mService).registerReceiver(anyString(), anyString(), any());

         mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, command -> {
             command.run();
             // Verify that mPayloadCallback is invoked on the Executor.
             verify(mPayloadCallback, timeout(TIMEOUT_MS)).onPayloadReceived(senderZone, payload);
         }, mPayloadCallback);
         binderCallback[0].onPayloadReceived(senderZone, RECEIVER_ENDPOINT_ID, payload);
     }

     @Test
     public void testUnregisterReceiverWithNullParameter_throwsException() throws RemoteException {
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.unregisterReceiver(
                         /* receiverEndpointId= */ null));

     }

     @Test
     public void testUnregisterReceiver() throws RemoteException {
         mOccupantConnectionManager.unregisterReceiver(RECEIVER_ENDPOINT_ID);

         verify(mService).unregisterReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID);
     }

     @Test
     public void testSendPayloadNullParameters_throwsException() {
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager
                         .sendPayload(/* receiverZone= */ null, mock(Payload.class)));
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.sendPayload(
                         mReceiverZone, /* payload= */ null));
     }

     @Test
     public void testSendPayloadWithoutConnection_throwsException() throws RemoteException {
         doThrow(IllegalStateException.class)
                 .when(mService).sendPayload(eq(PACKAGE_NAME), any(), any());

         assertThrows(PayloadTransferException.class,
                 () -> mOccupantConnectionManager.sendPayload(mReceiverZone, mock(Payload.class)));
     }

     @Test
     public void testSendPayload() throws PayloadTransferException, RemoteException {
         Payload payload = mock(Payload.class);
         mOccupantConnectionManager.sendPayload(mReceiverZone, payload);

         verify(mService).sendPayload(PACKAGE_NAME, mReceiverZone, payload);
     }

     @Test
     public void testIsConnectedWithNullParameters_throwsException() {
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.isConnected(/* receiverZone= */ null));
     }

     @Test
     public void testIsConnected() throws RemoteException {
         when(mService.isConnected(PACKAGE_NAME, mReceiverZone)).thenReturn(true);
         boolean isConnected = mOccupantConnectionManager.isConnected(mReceiverZone);

         verify(mService).isConnected(PACKAGE_NAME, mReceiverZone);
         assertThat(isConnected).isTrue();
     }

     @Test
     public void testDisconnectWithNullParameters_throwsException() {
         assertThrows(NullPointerException.class,
                 () -> mOccupantConnectionManager.disconnect(/* receiverZone= */ null));
     }

     @Test
     public void testDisconnect() throws RemoteException {
         mOccupantConnectionManager.disconnect(mReceiverZone);

         verify(mService).disconnect(PACKAGE_NAME, mReceiverZone);
     }
 }
	/*
	* Copyright (C) 2023 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.car;

	import static android.car.CarOccupantZoneManager.OCCUPANT_TYPE_DRIVER;
	import static android.car.VehicleAreaSeat.SEAT_ROW_1_LEFT;
	import static android.car.occupantconnection.CarOccupantConnectionManager.CONNECTION_ERROR_USER_REJECTED;

	import static com.google.common.truth.Truth.assertThat;

	import static org.junit.Assert.assertThrows;
	import static org.mockito.Mockito.any;
	import static org.mockito.Mockito.anyString;
	import static org.mockito.Mockito.doAnswer;
	import static org.mockito.Mockito.doNothing;
	import static org.mockito.Mockito.doThrow;
	import static org.mockito.Mockito.eq;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.timeout;
	import static org.mockito.Mockito.times;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.when;

	import android.car.Car;
	import android.car.CarOccupantZoneManager.OccupantZoneInfo;
	import android.car.occupantconnection.CarOccupantConnectionManager;
	import android.car.occupantconnection.CarOccupantConnectionManager.ConnectionRequestCallback;
	import android.car.occupantconnection.CarOccupantConnectionManager.PayloadCallback;
	import android.car.occupantconnection.CarOccupantConnectionManager.PayloadTransferException;
	import android.car.occupantconnection.ICarOccupantConnection;
	import android.car.occupantconnection.IConnectionRequestCallback;
	import android.car.occupantconnection.IPayloadCallback;
	import android.car.occupantconnection.Payload;
	import android.content.Context;
	import android.os.IBinder;
	import android.os.RemoteException;

	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.Mock;
	import org.mockito.junit.MockitoJUnitRunner;

	import java.util.concurrent.Executor;

	@RunWith(MockitoJUnitRunner.class)
	public final class CarOccupantConnectionManagerUnitTest {

	private static final String PACKAGE_NAME = "my_package_name";
	private static final String RECEIVER_ENDPOINT_ID = "test_receiver_endpointId";
	private static final int TIMEOUT_MS = 1000;

	@Mock
	private Car mCar;
	@Mock
	private Context mContext;
	@Mock
	private IBinder mBinder;
	@Mock
	private ICarOccupantConnection mService;
	@Mock
	private Executor mCallbackExecutor;
	@Mock
	private ConnectionRequestCallback mConnectionRequestCallback;
	@Mock
	private PayloadCallback mPayloadCallback;

	private final OccupantZoneInfo mReceiverZone =
	new OccupantZoneInfo(/* zoneId= */ 0, OCCUPANT_TYPE_DRIVER, SEAT_ROW_1_LEFT);

	private CarOccupantConnectionManager mOccupantConnectionManager;

	@Before
	public void setUp() {
	when(mBinder.queryLocalInterface(anyString())).thenReturn(mService);
	when(mCar.getContext()).thenReturn(mContext);
	when(mContext.getPackageName()).thenReturn(PACKAGE_NAME);
	mOccupantConnectionManager = new CarOccupantConnectionManager(mCar, mBinder);
	}

	@Test
	public void testRequestConnectionWithNullParameters_throwsException() {
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.requestConnection(
	/* receiverZone= */ null, mCallbackExecutor, mConnectionRequestCallback));
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.requestConnection(
	mReceiverZone, /* executor= */ null, mConnectionRequestCallback));
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.requestConnection(
	mReceiverZone, mCallbackExecutor, /* callback= */ null));
	}

	@Test
	public void testRequestConnectionWithPendingConnection_throwsException() {
	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mock(ConnectionRequestCallback.class));

	// The client shouldn't request another connection to the same occupant zone because there
	// is a pending connection request to that occupant zone.
	assertThrows(IllegalStateException.class,
	() -> mOccupantConnectionManager.requestConnection(
	mReceiverZone, mCallbackExecutor, mConnectionRequestCallback));
	}

	@Test
	public void testRequestConnectionWithEstablishedConnection_throwsException()
	throws RemoteException {
	IConnectionRequestCallback[] binderCallback = new IConnectionRequestCallback[1];
	doAnswer((invocation) -> {
	Object[] args = invocation.getArguments();
	binderCallback[0] = (IConnectionRequestCallback) args[2];
	return null;
	}).when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());

	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mock(ConnectionRequestCallback.class));
	binderCallback[0].onConnected(mReceiverZone);

	// The client shouldn't request another connection to the same occupant zone because there
	// is an established connection to that occupant zone.
	assertThrows(IllegalStateException.class,
	() -> mOccupantConnectionManager.requestConnection(
	mReceiverZone, mCallbackExecutor, mConnectionRequestCallback));
	}

	@Test
	public void testRequestConnectionWithRejectedConnection() throws RemoteException {
	IConnectionRequestCallback[] binderCallback = new IConnectionRequestCallback[1];
	doAnswer((invocation) -> {
	Object[] args = invocation.getArguments();
	binderCallback[0] = (IConnectionRequestCallback) args[2];
	return null;
	}).when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());

	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mock(ConnectionRequestCallback.class));
	binderCallback[0].onFailed(mReceiverZone, CONNECTION_ERROR_USER_REJECTED);

	// The client can request another connection to the same occupant zone since the previous
	// request was rejected.
	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mConnectionRequestCallback);
	}

	@Test
	public void testRequestConnectionWithRemoteException() throws RemoteException {
	// The first call fails due to a RemoteException.
	doThrow(new RemoteException())
	.when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());
	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mConnectionRequestCallback);

	// The second call succeeds. It should not trigger IllegalStateException because
	// mConnectionRequestCallback was not added previously.
	doNothing()
	.when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());
	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mConnectionRequestCallback);
	}

	@Test
	public void testRequestConnectionCallbackInvoked() throws RemoteException {
	IConnectionRequestCallback[] binderCallback = new IConnectionRequestCallback[1];
	doAnswer((invocation) -> {
	Object[] args = invocation.getArguments();
	String packageName = (String) args[0];
	assertThat(packageName).isEqualTo(PACKAGE_NAME);
	OccupantZoneInfo receiverZone = (OccupantZoneInfo) args[1];
	assertThat(receiverZone).isEqualTo(mReceiverZone);
	binderCallback[0] = (IConnectionRequestCallback) args[2];
	// Don't call binderCallback[0].onConnected() here, because mConnectionRequestCallback
	// is added AFTER this method returns. So if we call binderCallback.onConnected() here,
	// mConnectionRequestCallback will not be invoked.
	return null;
	}).when(mService).requestConnection(anyString(), any(OccupantZoneInfo.class), any());

	mOccupantConnectionManager.requestConnection(mReceiverZone, command -> {
	command.run();
	// Verify that mConnectionRequestCallback is invoked on the Executor.
	verify(mConnectionRequestCallback, timeout(1000)).onConnected(mReceiverZone);
	}, mConnectionRequestCallback);
	binderCallback[0].onConnected(mReceiverZone);
	}

	@Test
	public void testCancelConnectionWithNullParameter_throwsException() {
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.cancelConnection(/* receiverZone= */ null));

	}

	@Test
	public void testCancelConnectionWithoutConnectionRequest_throwsException() {
	assertThrows(IllegalStateException.class,
	() -> mOccupantConnectionManager.cancelConnection(mReceiverZone));
	}

	@Test
	public void testCancelConnection() throws RemoteException {
	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mConnectionRequestCallback);
	mOccupantConnectionManager.cancelConnection(mReceiverZone);
	mOccupantConnectionManager.requestConnection(mReceiverZone, mCallbackExecutor,
	mConnectionRequestCallback);
	mOccupantConnectionManager.cancelConnection(mReceiverZone);

	verify(mService, times(2)).cancelConnection(PACKAGE_NAME, mReceiverZone);
	}

	@Test
	public void testRegisterReceiverWithNullParameters_throwsException() {
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.registerReceiver(
	/* receiverEndpointId= */ null, mCallbackExecutor, mPayloadCallback));
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.registerReceiver(
	RECEIVER_ENDPOINT_ID, /* executor= */ null, mPayloadCallback));
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.registerReceiver(
	RECEIVER_ENDPOINT_ID, mCallbackExecutor, /* callback= */ null));
	}

	@Test
	public void testRegisterReceiverWithDuplicateReceiverId_throwsException()
	throws RemoteException {
	// The first registerReceiver() call should run normally, while the second
	// registerReceiver() call should throw an exception because the same ID has been
	// registered.
	doNothing().doThrow(IllegalStateException.class)
	.when(mService).registerReceiver(eq(PACKAGE_NAME), eq(RECEIVER_ENDPOINT_ID), any());
	mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, mCallbackExecutor,
	mPayloadCallback);

	assertThrows(IllegalStateException.class,
	() -> mOccupantConnectionManager.registerReceiver(
	RECEIVER_ENDPOINT_ID, mCallbackExecutor, mPayloadCallback));
	}

	@Test
	public void testRegisterReceiverWithRemoteException() throws RemoteException {
	// The first call fails due to a RemoteException.
	doThrow(new RemoteException())
	.when(mService).registerReceiver(anyString(), anyString(), any());
	mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, mCallbackExecutor,
	mPayloadCallback);

	// The second call succeeds. It should not trigger IllegalStateException because
	// mPayloadCallback was not added previously.
	doNothing().when(mService).registerReceiver(anyString(), anyString(), any());
	mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, mCallbackExecutor,
	mPayloadCallback);
	}

	@Test
	public void testRegisterReceiverCallbackInvoked() throws RemoteException {
	OccupantZoneInfo senderZone = mock(OccupantZoneInfo.class);
	Payload payload = mock(Payload.class);
	IPayloadCallback[] binderCallback = new IPayloadCallback[1];
	doAnswer((invocation) -> {
	Object[] args = invocation.getArguments();
	String packageName = (String) args[0];
	assertThat(packageName).isEqualTo(PACKAGE_NAME);
	String receiverEndpointId = (String) args[1];
	assertThat(receiverEndpointId).isEqualTo(RECEIVER_ENDPOINT_ID);
	binderCallback[0] = (IPayloadCallback) args[2];
	// Don't call binderCallback[0].onPayloadReceived() here, because mPayloadCallback
	// is added AFTER this method returns. So if we call binderCallback.onPayloadReceived()
	// here, mPayloadCallback will not be invoked.
	return null;
	}).when(mService).registerReceiver(anyString(), anyString(), any());

	mOccupantConnectionManager.registerReceiver(RECEIVER_ENDPOINT_ID, command -> {
	command.run();
	// Verify that mPayloadCallback is invoked on the Executor.
	verify(mPayloadCallback, timeout(TIMEOUT_MS)).onPayloadReceived(senderZone, payload);
	}, mPayloadCallback);
	binderCallback[0].onPayloadReceived(senderZone, RECEIVER_ENDPOINT_ID, payload);
	}

	@Test
	public void testUnregisterReceiverWithNullParameter_throwsException() throws RemoteException {
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.unregisterReceiver(
	/* receiverEndpointId= */ null));

	}

	@Test
	public void testUnregisterReceiver() throws RemoteException {
	mOccupantConnectionManager.unregisterReceiver(RECEIVER_ENDPOINT_ID);

	verify(mService).unregisterReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID);
	}

	@Test
	public void testSendPayloadNullParameters_throwsException() {
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager
	.sendPayload(/* receiverZone= */ null, mock(Payload.class)));
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.sendPayload(
	mReceiverZone, /* payload= */ null));
	}

	@Test
	public void testSendPayloadWithoutConnection_throwsException() throws RemoteException {
	doThrow(IllegalStateException.class)
	.when(mService).sendPayload(eq(PACKAGE_NAME), any(), any());

	assertThrows(PayloadTransferException.class,
	() -> mOccupantConnectionManager.sendPayload(mReceiverZone, mock(Payload.class)));
	}

	@Test
	public void testSendPayload() throws PayloadTransferException, RemoteException {
	Payload payload = mock(Payload.class);
	mOccupantConnectionManager.sendPayload(mReceiverZone, payload);

	verify(mService).sendPayload(PACKAGE_NAME, mReceiverZone, payload);
	}

	@Test
	public void testIsConnectedWithNullParameters_throwsException() {
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.isConnected(/* receiverZone= */ null));
	}

	@Test
	public void testIsConnected() throws RemoteException {
	when(mService.isConnected(PACKAGE_NAME, mReceiverZone)).thenReturn(true);
	boolean isConnected = mOccupantConnectionManager.isConnected(mReceiverZone);

	verify(mService).isConnected(PACKAGE_NAME, mReceiverZone);
	assertThat(isConnected).isTrue();
	}

	@Test
	public void testDisconnectWithNullParameters_throwsException() {
	assertThrows(NullPointerException.class,
	() -> mOccupantConnectionManager.disconnect(/* receiverZone= */ null));
	}

	@Test
	public void testDisconnect() throws RemoteException {
	mOccupantConnectionManager.disconnect(mReceiverZone);

	verify(mService).disconnect(PACKAGE_NAME, mReceiverZone);
	}
	}