| /* |
| * Copyright (C) 2020 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.hal; |
| |
| import static android.car.VehiclePropertyIds.CURRENT_GEAR; |
| import static android.car.VehiclePropertyIds.INITIAL_USER_INFO; |
| import static android.car.VehiclePropertyIds.SWITCH_USER; |
| import static android.car.VehiclePropertyIds.USER_IDENTIFICATION_ASSOCIATION; |
| import static android.car.test.mocks.CarArgumentMatchers.isProperty; |
| import static android.car.test.mocks.CarArgumentMatchers.isPropertyWithValues; |
| import static android.car.test.util.VehicleHalTestingHelper.newConfig; |
| import static android.car.test.util.VehicleHalTestingHelper.newSubscribableConfig; |
| import static android.hardware.automotive.vehicle.V2_0.InitialUserInfoRequestType.COLD_BOOT; |
| import static android.hardware.automotive.vehicle.V2_0.UserIdentificationAssociationType.CUSTOM_1; |
| import static android.hardware.automotive.vehicle.V2_0.UserIdentificationAssociationType.KEY_FOB; |
| import static android.hardware.automotive.vehicle.V2_0.UserIdentificationAssociationValue.ASSOCIATED_CURRENT_USER; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static com.google.common.truth.Truth.assertWithMessage; |
| |
| import static org.junit.Assert.fail; |
| import static org.mockito.Mockito.doAnswer; |
| import static org.mockito.Mockito.doThrow; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.when; |
| import static org.testng.Assert.assertThrows; |
| |
| import android.car.hardware.property.VehicleHalStatusCode; |
| import android.car.userlib.HalCallback; |
| import android.car.userlib.UserHalHelper; |
| import android.hardware.automotive.vehicle.V2_0.InitialUserInfoResponse; |
| import android.hardware.automotive.vehicle.V2_0.InitialUserInfoResponseAction; |
| import android.hardware.automotive.vehicle.V2_0.SwitchUserMessageType; |
| import android.hardware.automotive.vehicle.V2_0.SwitchUserResponse; |
| import android.hardware.automotive.vehicle.V2_0.SwitchUserStatus; |
| import android.hardware.automotive.vehicle.V2_0.UserFlags; |
| import android.hardware.automotive.vehicle.V2_0.UserIdentificationAssociation; |
| import android.hardware.automotive.vehicle.V2_0.UserIdentificationGetRequest; |
| import android.hardware.automotive.vehicle.V2_0.UserIdentificationResponse; |
| import android.hardware.automotive.vehicle.V2_0.UserInfo; |
| import android.hardware.automotive.vehicle.V2_0.UsersInfo; |
| import android.hardware.automotive.vehicle.V2_0.VehiclePropConfig; |
| import android.hardware.automotive.vehicle.V2_0.VehiclePropValue; |
| import android.os.ServiceSpecificException; |
| import android.os.SystemClock; |
| import android.os.UserHandle; |
| import android.util.Log; |
| import android.util.Pair; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.mockito.ArgumentCaptor; |
| import org.mockito.Mock; |
| import org.mockito.junit.MockitoJUnitRunner; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.atomic.AtomicReference; |
| |
| @RunWith(MockitoJUnitRunner.class) |
| public final class UserHalServiceTest { |
| |
| private static final String TAG = UserHalServiceTest.class.getSimpleName(); |
| |
| /** |
| * Timeout passed to {@link UserHalService} methods |
| */ |
| private static final int TIMEOUT_MS = 50; |
| |
| /** |
| * Timeout for {@link GenericHalCallback#assertCalled()} for tests where the HAL is supposed to |
| * return something - it's a short time so it doesn't impact the test duration. |
| */ |
| private static final int CALLBACK_TIMEOUT_SUCCESS = TIMEOUT_MS + 50; |
| |
| /** |
| * Timeout for {@link GenericHalCallback#assertCalled()} for tests where the HAL is not supposed |
| * to return anything - it's a slightly longer to make sure the test doesn't fail prematurely. |
| */ |
| private static final int CALLBACK_TIMEOUT_TIMEOUT = TIMEOUT_MS + 450; |
| |
| // Used when crafting a request property - the real value will be set by the mock. |
| private static final int REQUEST_ID_PLACE_HOLDER = 42; |
| |
| private static final int INITIAL_USER_INFO_RESPONSE_ACTION = 108; |
| |
| @Mock |
| private VehicleHal mVehicleHal; |
| |
| private final UserInfo mUser0 = new UserInfo(); |
| private final UserInfo mUser10 = new UserInfo(); |
| |
| private final UsersInfo mUsersInfo = new UsersInfo(); |
| |
| private UserHalService mUserHalService; |
| |
| @Before |
| public void setFixtures() { |
| mUserHalService = new UserHalService(mVehicleHal); |
| mUserHalService.takeProperties(Arrays.asList( |
| newSubscribableConfig(INITIAL_USER_INFO), |
| newSubscribableConfig(SWITCH_USER))); |
| |
| mUser0.userId = 0; |
| mUser0.flags = 100; |
| mUser10.userId = 10; |
| mUser10.flags = 110; |
| |
| mUsersInfo.currentUser = mUser0; |
| mUsersInfo.numberUsers = 2; |
| mUsersInfo.existingUsers = new ArrayList<>(2); |
| mUsersInfo.existingUsers.add(mUser0); |
| mUsersInfo.existingUsers.add(mUser10); |
| } |
| |
| @Test |
| public void testTakeSupportedProperties_unsupportedOnly() { |
| // Cannot use mUserHalService because it's already set with supported properties |
| UserHalService myHalService = new UserHalService(mVehicleHal); |
| |
| myHalService.takeProperties(Collections.EMPTY_LIST); |
| assertThat(myHalService.isSupported()).isFalse(); |
| } |
| |
| @Test |
| public void testTakeSupportedPropertiesAndInit() { |
| // Cannot use mUserHalService because it's already set with supported properties |
| UserHalService myHalService = new UserHalService(mVehicleHal); |
| |
| VehiclePropConfig unsupportedConfig = newConfig(CURRENT_GEAR); |
| VehiclePropConfig userInfoConfig = newSubscribableConfig(INITIAL_USER_INFO); |
| List<VehiclePropConfig> input = Arrays.asList(unsupportedConfig, userInfoConfig); |
| myHalService.takeProperties(input); |
| assertThat(mUserHalService.isSupported()).isTrue(); |
| |
| // Ideally there should be 2 test methods (one for takeSupportedProperties() and one for |
| // init()), but on "real life" VehicleHal calls these 2 methods in sequence, and the latter |
| // depends on the properties set by the former, so it's ok to test both here... |
| myHalService.init(); |
| verify(mVehicleHal).subscribeProperty(myHalService, INITIAL_USER_INFO); |
| } |
| |
| @Test |
| public void testSupportedProperties() { |
| assertThat(mUserHalService.getAllSupportedProperties()).asList().containsAllOf( |
| INITIAL_USER_INFO, |
| SWITCH_USER, |
| USER_IDENTIFICATION_ASSOCIATION); |
| } |
| |
| @Test |
| public void testGetUserInfo_invalidTimeout() { |
| assertThrows(IllegalArgumentException.class, |
| () -> mUserHalService.getInitialUserInfo(COLD_BOOT, 0, mUsersInfo, (i, r) -> { |
| })); |
| assertThrows(IllegalArgumentException.class, |
| () -> mUserHalService.getInitialUserInfo(COLD_BOOT, -1, mUsersInfo, (i, r) -> { |
| })); |
| } |
| |
| @Test |
| public void testGetUserInfo_noUsersInfo() { |
| assertThrows(NullPointerException.class, |
| () -> mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, null, |
| (i, r) -> { |
| })); |
| } |
| |
| @Test |
| public void testGetUserInfo_noCallback() { |
| assertThrows(NullPointerException.class, |
| () -> mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, |
| mUsersInfo, null)); |
| } |
| |
| @Test |
| public void testGetUserInfo_halSetTimedOut() throws Exception { |
| replySetPropertyWithTimeoutException(INITIAL_USER_INFO); |
| |
| GenericHalCallback<InitialUserInfoResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback); |
| |
| callback.assertCalled(); |
| assertCallbackStatus(callback, HalCallback.STATUS_HAL_SET_TIMEOUT); |
| assertThat(callback.response).isNull(); |
| |
| // Make sure the pending request was removed |
| SystemClock.sleep(CALLBACK_TIMEOUT_TIMEOUT); |
| callback.assertNotCalledAgain(); |
| } |
| |
| @Test |
| public void testGetUserInfo_halDidNotReply() throws Exception { |
| GenericHalCallback<InitialUserInfoResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback); |
| |
| callback.assertCalled(); |
| assertCallbackStatus(callback, HalCallback.STATUS_HAL_RESPONSE_TIMEOUT); |
| assertThat(callback.response).isNull(); |
| } |
| |
| @Test |
| public void testGetUserInfo_secondCallFailWhilePending() throws Exception { |
| GenericHalCallback<InitialUserInfoResponse> callback1 = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| GenericHalCallback<InitialUserInfoResponse> callback2 = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback1); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback2); |
| |
| callback1.assertCalled(); |
| assertCallbackStatus(callback1, HalCallback.STATUS_HAL_RESPONSE_TIMEOUT); |
| assertThat(callback1.response).isNull(); |
| |
| callback2.assertCalled(); |
| assertCallbackStatus(callback2, HalCallback.STATUS_CONCURRENT_OPERATION); |
| assertThat(callback1.response).isNull(); |
| } |
| |
| @Test |
| public void testGetUserInfo_halReplyWithWrongRequestId() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| INITIAL_USER_INFO_RESPONSE_ACTION, INITIAL_USER_INFO); |
| |
| replySetPropertyWithOnChangeEvent(INITIAL_USER_INFO, propResponse, |
| /* rightRequestId= */ false); |
| |
| GenericHalCallback<InitialUserInfoResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback); |
| |
| callback.assertCalled(); |
| assertCallbackStatus(callback, HalCallback.STATUS_HAL_RESPONSE_TIMEOUT); |
| assertThat(callback.response).isNull(); |
| } |
| |
| @Test |
| public void testGetUserInfo_halReturnedInvalidAction() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| INITIAL_USER_INFO_RESPONSE_ACTION, INITIAL_USER_INFO); |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| INITIAL_USER_INFO, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<InitialUserInfoResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertInitialUserInfoSetRequest(reqCaptor.get(), COLD_BOOT); |
| |
| // Assert response |
| assertCallbackStatus(callback, HalCallback.STATUS_WRONG_HAL_RESPONSE); |
| assertThat(callback.response).isNull(); |
| } |
| |
| @Test |
| public void testGetUserInfo_successDefault() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| InitialUserInfoResponseAction.DEFAULT, INITIAL_USER_INFO); |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| INITIAL_USER_INFO, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<InitialUserInfoResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertInitialUserInfoSetRequest(reqCaptor.get(), COLD_BOOT); |
| |
| // Assert response |
| assertCallbackStatus(callback, HalCallback.STATUS_OK); |
| InitialUserInfoResponse actualResponse = callback.response; |
| assertThat(actualResponse.action).isEqualTo(InitialUserInfoResponseAction.DEFAULT); |
| assertThat(actualResponse.userNameToCreate).isEmpty(); |
| assertThat(actualResponse.userToSwitchOrCreate).isNotNull(); |
| assertThat(actualResponse.userToSwitchOrCreate.userId).isEqualTo(UserHandle.USER_NULL); |
| assertThat(actualResponse.userToSwitchOrCreate.flags).isEqualTo(UserFlags.NONE); |
| } |
| |
| @Test |
| public void testGetUserInfo_successSwitchUser() throws Exception { |
| int userIdToSwitch = 42; |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| InitialUserInfoResponseAction.SWITCH, INITIAL_USER_INFO); |
| propResponse.value.int32Values.add(userIdToSwitch); |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| INITIAL_USER_INFO, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<InitialUserInfoResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertInitialUserInfoSetRequest(reqCaptor.get(), COLD_BOOT); |
| |
| assertCallbackStatus(callback, HalCallback.STATUS_OK); |
| InitialUserInfoResponse actualResponse = callback.response; |
| assertThat(actualResponse.action).isEqualTo(InitialUserInfoResponseAction.SWITCH); |
| assertThat(actualResponse.userNameToCreate).isEmpty(); |
| UserInfo userToSwitch = actualResponse.userToSwitchOrCreate; |
| assertThat(userToSwitch).isNotNull(); |
| assertThat(userToSwitch.userId).isEqualTo(userIdToSwitch); |
| assertThat(userToSwitch.flags).isEqualTo(UserFlags.NONE); |
| } |
| |
| @Test |
| public void testGetUserInfo_successCreateUser() throws Exception { |
| int newUserFlags = 108; |
| String newUserName = "Groot"; |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| InitialUserInfoResponseAction.CREATE, INITIAL_USER_INFO); |
| propResponse.value.int32Values.add(newUserFlags); |
| propResponse.value.stringValue = newUserName; |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| INITIAL_USER_INFO, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<InitialUserInfoResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.getInitialUserInfo(COLD_BOOT, TIMEOUT_MS, mUsersInfo, |
| callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertInitialUserInfoSetRequest(reqCaptor.get(), COLD_BOOT); |
| |
| assertCallbackStatus(callback, HalCallback.STATUS_OK); |
| assertThat(callback.status).isEqualTo(HalCallback.STATUS_OK); |
| InitialUserInfoResponse actualResponse = callback.response; |
| assertThat(actualResponse.action).isEqualTo(InitialUserInfoResponseAction.CREATE); |
| assertThat(actualResponse.userNameToCreate).isEqualTo(newUserName); |
| UserInfo newUser = actualResponse.userToSwitchOrCreate; |
| assertThat(newUser).isNotNull(); |
| assertThat(newUser.userId).isEqualTo(UserHandle.USER_NULL); |
| assertThat(newUser.flags).isEqualTo(newUserFlags); |
| } |
| |
| @Test |
| public void testGetUserInfo_twoSuccessfulCalls() throws Exception { |
| testGetUserInfo_successDefault(); |
| testGetUserInfo_successDefault(); |
| } |
| |
| @Test |
| public void testSwitchUser_invalidTimeout() { |
| assertThrows(IllegalArgumentException.class, |
| () -> mUserHalService.switchUser(mUser10, 0, mUsersInfo, (i, r) -> { |
| })); |
| assertThrows(IllegalArgumentException.class, |
| () -> mUserHalService.switchUser(mUser10, -1, mUsersInfo, (i, r) -> { |
| })); |
| } |
| |
| @Test |
| public void testSwitchUser_noUsersInfo() { |
| assertThrows(NullPointerException.class, |
| () -> mUserHalService.switchUser(mUser10, TIMEOUT_MS, null, |
| (i, r) -> { |
| })); |
| } |
| |
| @Test |
| public void testSwitchUser_noCallback() { |
| assertThrows(NullPointerException.class, |
| () -> mUserHalService.switchUser(mUser10, TIMEOUT_MS, |
| mUsersInfo, null)); |
| } |
| |
| @Test |
| public void testSwitchUser_halSetTimedOut() throws Exception { |
| replySetPropertyWithTimeoutException(SWITCH_USER); |
| |
| GenericHalCallback<SwitchUserResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback); |
| |
| callback.assertCalled(); |
| assertCallbackStatus(callback, HalCallback.STATUS_HAL_SET_TIMEOUT); |
| assertThat(callback.response).isNull(); |
| |
| // Make sure the pending request was removed |
| SystemClock.sleep(CALLBACK_TIMEOUT_TIMEOUT); |
| callback.assertNotCalledAgain(); |
| } |
| |
| @Test |
| public void testSwitchUser_halDidNotReply() throws Exception { |
| GenericHalCallback<SwitchUserResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback); |
| |
| callback.assertCalled(); |
| assertCallbackStatus(callback, HalCallback.STATUS_HAL_RESPONSE_TIMEOUT); |
| assertThat(callback.response).isNull(); |
| } |
| |
| @Test |
| public void testSwitchUser_halReplyWithWrongRequestId() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| InitialUserInfoResponseAction.SWITCH, SWITCH_USER); |
| |
| replySetPropertyWithOnChangeEvent(SWITCH_USER, propResponse, |
| /* rightRequestId= */ false); |
| |
| GenericHalCallback<SwitchUserResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback); |
| |
| callback.assertCalled(); |
| assertCallbackStatus(callback, HalCallback.STATUS_HAL_RESPONSE_TIMEOUT); |
| assertThat(callback.response).isNull(); |
| } |
| |
| @Test |
| public void testSwitchUser_halReturnedInvalidMessageType() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| SwitchUserMessageType.VEHICLE_REQUEST, SWITCH_USER); |
| propResponse.value.int32Values.add(SwitchUserStatus.SUCCESS); |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| SWITCH_USER, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<SwitchUserResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertSwitchUserSetRequest(reqCaptor.get(), SwitchUserMessageType.ANDROID_SWITCH, mUser10); |
| |
| // Assert response |
| assertCallbackStatus(callback, HalCallback.STATUS_WRONG_HAL_RESPONSE); |
| assertThat(callback.response).isNull(); |
| } |
| |
| @Test |
| public void testUserSwitch_success() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| SwitchUserMessageType.VEHICLE_RESPONSE, SWITCH_USER); |
| propResponse.value.int32Values.add(SwitchUserStatus.SUCCESS); |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| SWITCH_USER, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<SwitchUserResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertSwitchUserSetRequest(reqCaptor.get(), SwitchUserMessageType.ANDROID_SWITCH, mUser10); |
| |
| // Assert response |
| assertCallbackStatus(callback, HalCallback.STATUS_OK); |
| SwitchUserResponse actualResponse = callback.response; |
| assertThat(actualResponse.status).isEqualTo(SwitchUserStatus.SUCCESS); |
| assertThat(actualResponse.messageType).isEqualTo(SwitchUserMessageType.VEHICLE_RESPONSE); |
| } |
| |
| @Test |
| public void testUserSwitch_failure() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| SwitchUserMessageType.VEHICLE_RESPONSE, SWITCH_USER); |
| propResponse.value.int32Values.add(SwitchUserStatus.FAILURE); |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| SWITCH_USER, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<SwitchUserResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertSwitchUserSetRequest(reqCaptor.get(), SwitchUserMessageType.ANDROID_SWITCH, mUser10); |
| |
| // Assert response |
| assertCallbackStatus(callback, HalCallback.STATUS_OK); |
| SwitchUserResponse actualResponse = callback.response; |
| assertThat(actualResponse.status).isEqualTo(SwitchUserStatus.FAILURE); |
| assertThat(actualResponse.messageType).isEqualTo(SwitchUserMessageType.VEHICLE_RESPONSE); |
| } |
| |
| @Test |
| public void testSwitchUser_secondCallFailWhilePending() throws Exception { |
| GenericHalCallback<SwitchUserResponse> callback1 = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| GenericHalCallback<SwitchUserResponse> callback2 = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_TIMEOUT); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback1); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback2); |
| |
| callback1.assertCalled(); |
| assertCallbackStatus(callback1, HalCallback.STATUS_HAL_RESPONSE_TIMEOUT); |
| assertThat(callback1.response).isNull(); |
| |
| callback2.assertCalled(); |
| assertCallbackStatus(callback2, HalCallback.STATUS_CONCURRENT_OPERATION); |
| assertThat(callback1.response).isNull(); |
| } |
| |
| @Test |
| public void testSwitchUser_halReturnedInvalidStatus() throws Exception { |
| VehiclePropValue propResponse = UserHalHelper.createPropRequest(REQUEST_ID_PLACE_HOLDER, |
| SwitchUserMessageType.VEHICLE_RESPONSE, SWITCH_USER); |
| propResponse.value.int32Values.add(/*status =*/ 110); // an invalid status |
| |
| AtomicReference<VehiclePropValue> reqCaptor = replySetPropertyWithOnChangeEvent( |
| SWITCH_USER, propResponse, /* rightRequestId= */ true); |
| |
| GenericHalCallback<SwitchUserResponse> callback = new GenericHalCallback<>( |
| CALLBACK_TIMEOUT_SUCCESS); |
| mUserHalService.switchUser(mUser10, TIMEOUT_MS, mUsersInfo, callback); |
| |
| callback.assertCalled(); |
| |
| // Make sure the arguments were properly converted |
| assertSwitchUserSetRequest(reqCaptor.get(), SwitchUserMessageType.ANDROID_SWITCH, mUser10); |
| |
| // Assert response |
| assertCallbackStatus(callback, HalCallback.STATUS_WRONG_HAL_RESPONSE); |
| assertThat(callback.response).isNull(); |
| } |
| |
| @Test |
| public void testPostSwitchResponse_noUsersInfo() { |
| assertThrows(NullPointerException.class, |
| () -> mUserHalService.postSwitchResponse(42, mUser10, null)); |
| } |
| |
| @Test |
| public void testPostSwitchResponse_HalCalledWithCorrectProp() { |
| mUserHalService.postSwitchResponse(42, mUser10, mUsersInfo); |
| ArgumentCaptor<VehiclePropValue> propCaptor = |
| ArgumentCaptor.forClass(VehiclePropValue.class); |
| verify(mVehicleHal).set(propCaptor.capture()); |
| VehiclePropValue prop = propCaptor.getValue(); |
| assertPostSwitchResponseSetRequest(prop, SwitchUserMessageType.ANDROID_POST_SWITCH, |
| mUser10); |
| } |
| |
| @Test |
| public void testGetUserAssociation_nullRequest() { |
| assertThrows(NullPointerException.class, () -> mUserHalService.getUserAssociation(null)); |
| } |
| |
| @Test |
| public void testGetUserAssociation_requestWithDuplicatedTypes() { |
| UserIdentificationGetRequest request = new UserIdentificationGetRequest(); |
| request.numberAssociationTypes = 2; |
| request.associationTypes.add(KEY_FOB); |
| request.associationTypes.add(KEY_FOB); |
| |
| assertThrows(IllegalArgumentException.class, |
| () -> mUserHalService.getUserAssociation(request)); |
| } |
| |
| @Test |
| public void testGetUserAssociation_invalidResponse() { |
| VehiclePropValue mockedResponse = new VehiclePropValue(); |
| mockedResponse.prop = USER_IDENTIFICATION_ASSOCIATION; |
| mockedResponse.value.int32Values.add(1); // 1 associations |
| mockedResponse.value.int32Values.add(KEY_FOB); // type only, it's missing value |
| when(mVehicleHal.get( |
| isPropertyWithValues(USER_IDENTIFICATION_ASSOCIATION, 42, 108, 1, KEY_FOB))) |
| .thenReturn(mockedResponse); |
| |
| UserIdentificationGetRequest request = new UserIdentificationGetRequest(); |
| request.userInfo.userId = 42; |
| request.userInfo.flags = 108; |
| request.numberAssociationTypes = 1; |
| request.associationTypes.add(KEY_FOB); |
| |
| assertThat(mUserHalService.getUserAssociation(request)).isNull(); |
| } |
| |
| @Test |
| public void testGetUserAssociation_nullResponse() { |
| VehiclePropValue mockedResponse = new VehiclePropValue(); |
| mockedResponse.prop = USER_IDENTIFICATION_ASSOCIATION; |
| mockedResponse.value.int32Values.add(1); // 1 association |
| mockedResponse.value.int32Values.add(KEY_FOB); |
| mockedResponse.value.int32Values.add(ASSOCIATED_CURRENT_USER); |
| when(mVehicleHal.get( |
| isPropertyWithValues(USER_IDENTIFICATION_ASSOCIATION, 42, 108, 1, KEY_FOB))) |
| .thenReturn(null); |
| |
| UserIdentificationGetRequest request = new UserIdentificationGetRequest(); |
| request.userInfo.userId = 42; |
| request.userInfo.flags = 108; |
| request.numberAssociationTypes = 1; |
| request.associationTypes.add(KEY_FOB); |
| |
| assertThat(mUserHalService.getUserAssociation(request)).isNull(); |
| } |
| |
| @Test |
| public void testGetUserAssociation_wrongNumberOfAssociationsOnResponse() { |
| VehiclePropValue mockedResponse = new VehiclePropValue(); |
| mockedResponse.prop = USER_IDENTIFICATION_ASSOCIATION; |
| mockedResponse.value.int32Values.add(2); // 2 associations |
| mockedResponse.value.int32Values.add(KEY_FOB); |
| mockedResponse.value.int32Values.add(ASSOCIATED_CURRENT_USER); |
| mockedResponse.value.int32Values.add(CUSTOM_1); |
| mockedResponse.value.int32Values.add(ASSOCIATED_CURRENT_USER); |
| when(mVehicleHal.get( |
| isPropertyWithValues(USER_IDENTIFICATION_ASSOCIATION, 42, 108, 1, KEY_FOB))) |
| .thenReturn(mockedResponse); |
| |
| UserIdentificationGetRequest request = new UserIdentificationGetRequest(); |
| request.userInfo.userId = 42; |
| request.userInfo.flags = 108; |
| request.numberAssociationTypes = 1; |
| request.associationTypes.add(KEY_FOB); |
| |
| assertThat(mUserHalService.getUserAssociation(request)).isNull(); |
| } |
| |
| @Test |
| public void testGetUserAssociation_typesOnResponseMismatchTypesOnRequest() { |
| VehiclePropValue mockedResponse = new VehiclePropValue(); |
| mockedResponse.prop = USER_IDENTIFICATION_ASSOCIATION; |
| mockedResponse.value.int32Values.add(1); |
| mockedResponse.value.int32Values.add(CUSTOM_1); |
| mockedResponse.value.int32Values.add(ASSOCIATED_CURRENT_USER); |
| when(mVehicleHal.get( |
| isPropertyWithValues(USER_IDENTIFICATION_ASSOCIATION, 42, 108, 1, KEY_FOB))) |
| .thenReturn(mockedResponse); |
| |
| UserIdentificationGetRequest request = new UserIdentificationGetRequest(); |
| request.userInfo.userId = 42; |
| request.userInfo.flags = 108; |
| request.numberAssociationTypes = 1; |
| request.associationTypes.add(KEY_FOB); |
| |
| assertThat(mUserHalService.getUserAssociation(request)).isNull(); |
| } |
| |
| @Test |
| public void testGetUserAssociation_ok() { |
| VehiclePropValue mockedResponse = new VehiclePropValue(); |
| mockedResponse.prop = USER_IDENTIFICATION_ASSOCIATION; |
| mockedResponse.value.int32Values.add(1); // 1 association |
| mockedResponse.value.int32Values.add(KEY_FOB); |
| mockedResponse.value.int32Values.add(ASSOCIATED_CURRENT_USER); |
| when(mVehicleHal.get( |
| isPropertyWithValues(USER_IDENTIFICATION_ASSOCIATION, 42, 108, 1, KEY_FOB))) |
| .thenReturn(mockedResponse); |
| |
| UserIdentificationGetRequest request = new UserIdentificationGetRequest(); |
| request.userInfo.userId = 42; |
| request.userInfo.flags = 108; |
| request.numberAssociationTypes = 1; |
| request.associationTypes.add(KEY_FOB); |
| |
| UserIdentificationResponse actualResponse = mUserHalService.getUserAssociation(request); |
| |
| assertThat(actualResponse.numberAssociation).isEqualTo(1); |
| assertThat(actualResponse.associations).hasSize(1); |
| UserIdentificationAssociation actualAssociation = actualResponse.associations.get(0); |
| assertThat(actualAssociation.type).isEqualTo(KEY_FOB); |
| assertThat(actualAssociation.value).isEqualTo(ASSOCIATED_CURRENT_USER); |
| } |
| |
| /** |
| * Asserts the given {@link UsersInfo} is properly represented in the {@link VehiclePropValue}. |
| * |
| * @param value property containing the info |
| * @param info info to be checked |
| * @param initialIndex first index of the info values in the property's {@code int32Values} |
| */ |
| private void assertUsersInfo(VehiclePropValue value, UsersInfo info, int initialIndex) { |
| // TODO: consider using UserHalHelper to convert the property into a specific request, |
| // and compare the request's UsersInfo. |
| // But such method is not needed in production code yet. |
| ArrayList<Integer> values = value.value.int32Values; |
| assertWithMessage("wrong values size").that(values) |
| .hasSize(initialIndex + 3 + info.numberUsers * 2); |
| |
| int i = initialIndex; |
| assertWithMessage("currentUser.id mismatch at index %s", i).that(values.get(i)) |
| .isEqualTo(info.currentUser.userId); |
| i++; |
| assertWithMessage("currentUser.flags mismatch at index %s", i).that(values.get(i)) |
| .isEqualTo(info.currentUser.flags); |
| i++; |
| assertWithMessage("numberUsers mismatch at index %s", i).that(values.get(i)) |
| .isEqualTo(info.numberUsers); |
| i++; |
| |
| for (int j = 0; j < info.numberUsers; j++) { |
| int actualUserId = values.get(i++); |
| int actualUserFlags = values.get(i++); |
| UserInfo expectedUser = info.existingUsers.get(j); |
| assertWithMessage("wrong id for existing user#%s at index %s", j, i) |
| .that(actualUserId).isEqualTo(expectedUser.userId); |
| assertWithMessage("wrong flags for existing user#%s at index %s", j, i) |
| .that(actualUserFlags).isEqualTo(expectedUser.flags); |
| } |
| } |
| |
| /** |
| * Sets the VHAL mock to emulate a property change event upon a call to set a property. |
| * |
| * @param prop prop to be set |
| * @param response response to be set on event |
| * @param rightRequestId whether the response id should match the request |
| * @return |
| * |
| * @return reference to the value passed to {@code set()}. |
| */ |
| private AtomicReference<VehiclePropValue> replySetPropertyWithOnChangeEvent(int prop, |
| VehiclePropValue response, boolean rightRequestId) throws Exception { |
| AtomicReference<VehiclePropValue> ref = new AtomicReference<>(); |
| doAnswer((inv) -> { |
| VehiclePropValue request = inv.getArgument(0); |
| ref.set(request); |
| int requestId = request.value.int32Values.get(0); |
| int responseId = rightRequestId ? requestId : requestId + 1000; |
| response.value.int32Values.set(0, responseId); |
| Log.d(TAG, "mockSetPropertyWithOnChange(): resp=" + response + " for req=" + request); |
| mUserHalService.onHalEvents(Arrays.asList(response)); |
| return null; |
| }).when(mVehicleHal).set(isProperty(prop)); |
| return ref; |
| } |
| |
| /** |
| * Sets the VHAL mock to emulate a property timeout exception upon a call to set a property. |
| */ |
| private void replySetPropertyWithTimeoutException(int prop) throws Exception { |
| doThrow(new ServiceSpecificException(VehicleHalStatusCode.STATUS_TRY_AGAIN, |
| "PropId: 0x" + Integer.toHexString(prop))).when(mVehicleHal).set(isProperty(prop)); |
| } |
| |
| private void assertInitialUserInfoSetRequest(VehiclePropValue req, int requestType) { |
| assertThat(req.value.int32Values.get(1)).isEqualTo(requestType); |
| assertUsersInfo(req, mUsersInfo, 2); |
| } |
| |
| private void assertSwitchUserSetRequest(VehiclePropValue req, int messageType, |
| UserInfo targetUserInfo) { |
| assertThat(req.value.int32Values.get(1)).isEqualTo(messageType); |
| assertWithMessage("targetuser.id mismatch").that(req.value.int32Values.get(2)) |
| .isEqualTo(targetUserInfo.userId); |
| assertWithMessage("targetuser.flags mismatch").that(req.value.int32Values.get(3)) |
| .isEqualTo(targetUserInfo.flags); |
| assertUsersInfo(req, mUsersInfo, 4); |
| } |
| |
| private void assertPostSwitchResponseSetRequest(VehiclePropValue req, int messageType, |
| UserInfo targetUserInfo) { |
| assertThat(req.value.int32Values.get(1)).isEqualTo(messageType); |
| assertWithMessage("targetuser.id mismatch").that(req.value.int32Values.get(2)) |
| .isEqualTo(targetUserInfo.userId); |
| assertWithMessage("targetuser.flags mismatch").that(req.value.int32Values.get(3)) |
| .isEqualTo(targetUserInfo.flags); |
| assertUsersInfo(req, mUsersInfo, 4); |
| } |
| |
| private void assertCallbackStatus(GenericHalCallback callback, |
| int expectedStatus) { |
| int actualStatus = callback.status; |
| if (actualStatus == expectedStatus) return; |
| |
| fail("Wrong callback status; expected " |
| + UserHalHelper.halCallbackStatusToString(expectedStatus) + ", got " |
| + UserHalHelper.halCallbackStatusToString(actualStatus)); |
| } |
| |
| private final class GenericHalCallback<R> implements HalCallback<R> { |
| |
| private final CountDownLatch mLatch = new CountDownLatch(1); |
| private final int mTimeout; |
| private final List<Pair<Integer, R>> mExtraCalls = new ArrayList<>(); |
| |
| public int status; |
| public R response; |
| |
| GenericHalCallback(int timeout) { |
| this.mTimeout = timeout; |
| } |
| |
| @Override |
| public void onResponse(int status, R response) { |
| Log.d(TAG, "onResponse(): status=" + status + ", response=" + response); |
| this.status = status; |
| this.response = response; |
| if (mLatch.getCount() == 0) { |
| Log.e(TAG, "Already responded"); |
| mExtraCalls.add(new Pair<>(status, response)); |
| return; |
| } |
| mLatch.countDown(); |
| } |
| |
| /** |
| * Asserts that the callback was called, or fail if it timed out. |
| */ |
| public void assertCalled() throws InterruptedException { |
| Log.d(TAG, "assertCalled(): waiting " + mTimeout + "ms"); |
| if (!mLatch.await(mTimeout, TimeUnit.MILLISECONDS)) { |
| throw new AssertionError("callback not called in " + mTimeout + "ms"); |
| } |
| } |
| |
| /** |
| * Asserts that the callback was not called more than once. |
| */ |
| public void assertNotCalledAgain() { |
| if (mExtraCalls.isEmpty()) return; |
| throw new AssertionError("Called " + mExtraCalls.size() + " times more than expected: " |
| + mExtraCalls); |
| } |
| } |
| } |