tests/carservice_unit_test/src/com/android/car/CarOccupantZoneServiceTest.java

/*
 * Copyright (C) 2019 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 com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;

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

import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
import static org.testng.Assert.assertThrows;
import static org.testng.Assert.expectThrows;

import android.annotation.UserIdInt;
import android.car.Car;
import android.car.CarOccupantZoneManager;
import android.car.CarOccupantZoneManager.OccupantZoneInfo;
import android.car.VehicleAreaSeat;
import android.car.media.CarAudioManager;
import android.car.user.CarUserManager;
import android.car.user.CarUserManager.UserLifecycleEvent;
import android.content.ComponentName;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.UserInfo;
import android.content.res.Resources;
import android.hardware.display.DisplayManager;
import android.os.Looper;
import android.os.RemoteException;
import android.os.UserHandle;
import android.os.UserManager;
import android.util.SparseArray;
import android.util.SparseIntArray;
import android.view.Display;
import android.view.DisplayAddress;

import com.android.car.CarOccupantZoneService.DisplayConfig;
import com.android.car.CarOccupantZoneService.DisplayInfo;
import com.android.car.CarOccupantZoneService.OccupantConfig;
import com.android.car.internal.ICarServiceHelper;
import com.android.car.user.CarUserService;

import org.junit.After;
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.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@RunWith(MockitoJUnitRunner.class)
public class CarOccupantZoneServiceTest {

    private static final String TAG = CarOccupantZoneServiceTest.class.getSimpleName();

    private CarOccupantZoneService mService;
    private CarOccupantZoneManager mManager;

    @Mock
    private CarPropertyService mCarPropertyService;

    @Mock
    private CarUserService mCarUserService;

    @Mock
    private Context mContext;

    @Mock
    private DisplayManager mDisplayManager;

    @Mock
    private UserManager mUserManager;

    @Mock
    private Resources mResources;

    @Mock
    private Display mDisplay0;

    @Mock
    private Display mDisplay1;

    @Mock
    private Display mDisplay2;

    @Mock
    private Display mDisplay3; // not listed by default

    @Mock
    private Display mDisplay4;

    @Mock
    private Display mDisplay5; // outside display config and become unknown display

    private static final int CURRENT_USER = 100;
    private static final int PROFILE_USER1 = 1001;
    private static final int PROFILE_USER2 = 1002;

    private static final String[] DEFAULT_OCCUPANT_ZONES = {
            "occupantZoneId=0,occupantType=DRIVER,seatRow=1,seatSide=driver",
            "occupantZoneId=1,occupantType=FRONT_PASSENGER,seatRow=1,seatSide=oppositeDriver",
            "occupantZoneId=2,occupantType=REAR_PASSENGER,seatRow=2,seatSide=left",
            "occupantZoneId=3,occupantType=REAR_PASSENGER,seatRow=2,seatSide=right"
    };

    private static final int PRIMARY_AUDIO_ZONE_ID = 0;
    private static final int PRIMARY_AUDIO_ZONE_ID_OCCUPANT = 0;
    private static final int SECONDARY_AUDIO_ZONE_ID = 1;
    private static final int SECONDARY_AUDIO_ZONE_ID_OCCUPANT = 3;
    private static final int UNMAPPED_AUDIO_ZONE_ID_OCCUPANT = 2;
    private static final int INVALID_AUDIO_ZONE_ID_OCCUPANT = 100;

    // LHD : Left Hand Drive
    private final OccupantZoneInfo mZoneDriverLHD = new OccupantZoneInfo(0,
            CarOccupantZoneManager.OCCUPANT_TYPE_DRIVER,
            VehicleAreaSeat.SEAT_ROW_1_LEFT);
    private final OccupantZoneInfo mZoneFrontPassengerLHD = new OccupantZoneInfo(1,
            CarOccupantZoneManager.OCCUPANT_TYPE_FRONT_PASSENGER,
            VehicleAreaSeat.SEAT_ROW_1_RIGHT);
    private final OccupantZoneInfo mZoneRearLeft = new OccupantZoneInfo(2,
            CarOccupantZoneManager.OCCUPANT_TYPE_REAR_PASSENGER,
            VehicleAreaSeat.SEAT_ROW_2_LEFT);
    private final OccupantZoneInfo mZoneRearRight = new OccupantZoneInfo(3,
            CarOccupantZoneManager.OCCUPANT_TYPE_REAR_PASSENGER,
            VehicleAreaSeat.SEAT_ROW_2_RIGHT);

    // port address set to mocked displayid + 10 so that any possible mix of port address and
    // display id can be detected.
    private static final String[] DEFAULT_OCCUPANT_DISPLAY_MAPPING = {
            "displayPort=10,displayType=MAIN,occupantZoneId=0",
            "displayPort=11,displayType=INSTRUMENT_CLUSTER,occupantZoneId=0",
            "displayPort=12,displayType=MAIN,occupantZoneId=1",
            "displayPort=13,displayType=MAIN,occupantZoneId=2",
            "displayPort=14,displayType=MAIN,occupantZoneId=3"
    };

    // Stores last changeFlags from onOccupantZoneConfigChanged call.
    private int mLastChangeFlags;
    private final Semaphore mChangeEventSignal = new Semaphore(0);

    private final ICarServiceHelperImpl mICarServiceHelper = new ICarServiceHelperImpl();

    private final CarOccupantZoneManager.OccupantZoneConfigChangeListener mChangeListener =
            new CarOccupantZoneManager.OccupantZoneConfigChangeListener() {
                @Override
                public void onOccupantZoneConfigChanged(int changeFlags) {
                    // should be dispatched to main thread.
                    assertThat(Looper.getMainLooper()).isEqualTo(Looper.myLooper());
                    mLastChangeFlags = changeFlags;
                    mChangeEventSignal.release();
                }
            };

    private void resetConfigChangeEventWait() {
        mLastChangeFlags = 0;
        mChangeEventSignal.drainPermits();
    }

    private boolean waitForConfigChangeEventAndAssertFlag(long timeoutMs, int expectedFlag) {
        boolean acquired = false;
        try {
            acquired = mChangeEventSignal.tryAcquire(timeoutMs, TimeUnit.MILLISECONDS);
        } catch (Exception ignored) {

        }
        if (acquired) {
            assertThat(expectedFlag).isEqualTo(mLastChangeFlags);
        }
        return acquired;
    }

    private void mockDisplay(DisplayManager displayManager, Display display, int displayId,
            int portAddress) {
        when(displayManager.getDisplay(displayId)).thenReturn(display);
        when(display.getDisplayId()).thenReturn(displayId);
        when(display.getAddress()).thenReturn(DisplayAddress.fromPhysicalDisplayId(portAddress));
    }

    @Before
    public void setUp() {
        when(mContext.getResources()).thenReturn(mResources);
        when(mContext.getSystemService(DisplayManager.class)).thenReturn(mDisplayManager);
        when(mResources.getStringArray(R.array.config_occupant_zones))
                .thenReturn(DEFAULT_OCCUPANT_ZONES);
        when(mResources.getStringArray(R.array.config_occupant_display_mapping))
                .thenReturn(DEFAULT_OCCUPANT_DISPLAY_MAPPING);
        when(mContext.getApplicationInfo()).thenReturn(new ApplicationInfo());
        // Stored as static: Other tests can leave things behind and fail this test in add call.
        // So just remove as safety guard.
        CarLocalServices.removeServiceForTest(CarPropertyService.class);
        CarLocalServices.addService(CarPropertyService.class, mCarPropertyService);
        CarLocalServices.removeServiceForTest(CarUserService.class);
        CarLocalServices.addService(CarUserService.class, mCarUserService);
        mockDisplay(mDisplayManager, mDisplay0, 0, 10);
        mockDisplay(mDisplayManager, mDisplay1, 1, 11);
        mockDisplay(mDisplayManager, mDisplay2, 2, 12);
        mockDisplay(mDisplayManager, mDisplay4, 4, 14);
        mockDisplay(mDisplayManager, mDisplay5, 5, 15);
        when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
                mDisplay0,
                mDisplay1,
                mDisplay2,
                mDisplay4,
                mDisplay5
        });

        mService = new CarOccupantZoneService(mContext, mDisplayManager, mUserManager,
                /* enableProfileUserAssignmentForMultiDisplay= */ false);
        spyOn(mService);
        doReturn(VehicleAreaSeat.SEAT_ROW_1_LEFT).when(mService).getDriverSeat();
        doReturn(CURRENT_USER).when(mService).getCurrentUser();

        Car car = new Car(mContext, /* service= */ null, /* handler= */ null);
        mManager = new CarOccupantZoneManager(car, mService);
    }

    @After
    public void tearDown() {
        CarLocalServices.removeServiceForTest(CarUserService.class);
        CarLocalServices.removeServiceForTest(CarPropertyService.class);
    }

    @Test
    public void testDefaultOccupantConfig() {
        mService.init();

        // key : zone id
        SparseArray<OccupantZoneInfo> configs = mService.getOccupantsConfig();
        assertThat(configs.size()).isEqualTo(DEFAULT_OCCUPANT_ZONES.length);
        assertThat(mZoneDriverLHD).isEqualTo(configs.get(0));
        assertThat(mZoneFrontPassengerLHD).isEqualTo(configs.get(1));
        assertThat(mZoneRearLeft).isEqualTo(configs.get(2));
        assertThat(mZoneRearRight).isEqualTo(configs.get(3));
    }

    @Test
    public void testDefaultAudioZoneConfig() {
        mService.init();
        SparseIntArray audioConfigs = mService.getAudioConfigs();
        assertThat(audioConfigs.size()).isEqualTo(0);
    }

    /** RHD: Right Hand Drive */
    @Test
    public void testDefaultOccupantConfigForRHD() {
        // driver is right side and opposite should be left.
        doReturn(VehicleAreaSeat.SEAT_ROW_1_RIGHT).when(mService).getDriverSeat();

        mService.init();

        // key : zone id
        SparseArray<OccupantZoneInfo> configs = mService.getOccupantsConfig();
        assertThat(configs.size()).isEqualTo(DEFAULT_OCCUPANT_ZONES.length);
        assertThat(new OccupantZoneInfo(0, CarOccupantZoneManager.OCCUPANT_TYPE_DRIVER,
                VehicleAreaSeat.SEAT_ROW_1_RIGHT)).isEqualTo(configs.get(0));
        assertThat(new OccupantZoneInfo(1, CarOccupantZoneManager.OCCUPANT_TYPE_FRONT_PASSENGER,
                VehicleAreaSeat.SEAT_ROW_1_LEFT)).isEqualTo(configs.get(1));
        assertThat(mZoneRearLeft).isEqualTo(configs.get(2));
        assertThat(mZoneRearRight).isEqualTo(configs.get(3));
    }

    private void assertDisplayConfig(DisplayConfig c, int displayType, int occupantZoneId) {
        assertThat(displayType).isEqualTo(c.displayType);
        assertThat(occupantZoneId).isEqualTo(c.occupantZoneId);
    }

    @Test
    public void testDefaultOccupantDisplayMapping() {
        mService.init();

        // key: display port address
        SparseArray<DisplayConfig> configs = mService.getDisplayConfigs();
        assertThat(configs.size()).isEqualTo(DEFAULT_OCCUPANT_DISPLAY_MAPPING.length);
        assertDisplayConfig(configs.get(10), CarOccupantZoneManager.DISPLAY_TYPE_MAIN, 0);
        assertDisplayConfig(configs.get(11), CarOccupantZoneManager.DISPLAY_TYPE_INSTRUMENT_CLUSTER,
                0);
        assertDisplayConfig(configs.get(12), CarOccupantZoneManager.DISPLAY_TYPE_MAIN, 1);
        assertDisplayConfig(configs.get(13), CarOccupantZoneManager.DISPLAY_TYPE_MAIN, 2);
        assertDisplayConfig(configs.get(14), CarOccupantZoneManager.DISPLAY_TYPE_MAIN, 3);
    }

    private void setUpServiceWithProfileSupportEnabled() {
        mService = new CarOccupantZoneService(mContext, mDisplayManager, mUserManager,
                /* enableProfileUserAssignmentForMultiDisplay= */ true);
        spyOn(mService);
        doReturn(VehicleAreaSeat.SEAT_ROW_1_LEFT).when(mService).getDriverSeat();
        doReturn(CURRENT_USER).when(mService).getCurrentUser();
        LinkedList<UserInfo> profileUsers = new LinkedList<>();
        profileUsers.add(new UserInfo(PROFILE_USER1, "1", 0));
        profileUsers.add(new UserInfo(PROFILE_USER2, "1", 0));
        doReturn(profileUsers).when(mUserManager).getEnabledProfiles(CURRENT_USER);
        doReturn(true).when(mUserManager).isUserRunning(anyInt());

        Car car = new Car(mContext, /* service= */ null, /* handler= */ null);
        mManager = new CarOccupantZoneManager(car, mService);
    }

    @Test
    public void testAssignProfileUserFailForNonProfileUser() throws Exception {
        setUpServiceWithProfileSupportEnabled();
        mService.init();

        int invalidProfileUser = 2000;
        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                invalidProfileUser)).isFalse();
    }

    private void assertDisplayAllowlist(int userId, int[] displays) {
        assertThat(mICarServiceHelper.mAllowlists).containsKey(userId);
        assertThat(mICarServiceHelper.mAllowlists.get(userId)).hasSize(displays.length);
        for (int display : displays) {
            assertThat(mICarServiceHelper.mAllowlists.get(userId)).contains(display);
        }
    }

    private void assertPassengerDisplaysFromDefaultConfig() throws Exception {
        assertThat(mICarServiceHelper.mPassengerDisplayIds).hasSize(2);
        assertThat(mICarServiceHelper.mPassengerDisplayIds).contains(
                mDisplay2.getDisplayId());
        assertThat(mICarServiceHelper.mPassengerDisplayIds).contains(
                mDisplay4.getDisplayId());
    }

    @Test
    public void testAssignProfileUserOnce() throws Exception {
        setUpServiceWithProfileSupportEnabled();
        mService.init();
        mService.setCarServiceHelper(mICarServiceHelper);

        assertPassengerDisplaysFromDefaultConfig();

        mICarServiceHelper.mAllowlists.clear();
        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                PROFILE_USER1)).isTrue();
        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(CURRENT_USER, new int[] {mDisplay4.getDisplayId()});
        assertDisplayAllowlist(PROFILE_USER1, new int[] {mDisplay2.getDisplayId()});
    }

    @Test
    public void testAssignProfileUserFailForStoppedUser() throws Exception {
        setUpServiceWithProfileSupportEnabled();
        mService.init();
        mService.setCarServiceHelper(mICarServiceHelper);

        assertPassengerDisplaysFromDefaultConfig();

        mICarServiceHelper.mAllowlists.clear();
        doReturn(false).when(mUserManager).isUserRunning(PROFILE_USER1);
        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                PROFILE_USER1)).isFalse();
    }

    @Test
    public void testAssignProfileUserSwitch() throws Exception {
        setUpServiceWithProfileSupportEnabled();
        mService.init();
        mService.setCarServiceHelper(mICarServiceHelper);

        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                PROFILE_USER1)).isTrue();

        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(CURRENT_USER, new int[] {mDisplay4.getDisplayId()});
        assertDisplayAllowlist(PROFILE_USER1, new int[] {mDisplay2.getDisplayId()});

        mICarServiceHelper.mAllowlists.clear();
        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                PROFILE_USER2)).isTrue();
        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(CURRENT_USER, new int[] {mDisplay4.getDisplayId()});
        assertDisplayAllowlist(PROFILE_USER2, new int[] {mDisplay2.getDisplayId()});
    }

    @Test
    public void testAssignProfileFollowedByUserSwitch() throws Exception {
        setUpServiceWithProfileSupportEnabled();
        mService.init();
        mService.setCarServiceHelper(mICarServiceHelper);

        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                PROFILE_USER1)).isTrue();

        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(CURRENT_USER, new int[] {mDisplay4.getDisplayId()});
        assertDisplayAllowlist(PROFILE_USER1, new int[] {mDisplay2.getDisplayId()});

        mICarServiceHelper.mAllowlists.clear();
        int newUserId = 200;
        doReturn(newUserId).when(mService).getCurrentUser();
        mService.mUserLifecycleListener.onEvent(new UserLifecycleEvent(
                CarUserManager.USER_LIFECYCLE_EVENT_TYPE_SWITCHING, newUserId));

        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(newUserId, new int[] {mDisplay2.getDisplayId(),
                mDisplay4.getDisplayId()});
        assertThat(mICarServiceHelper.mAllowlists).hasSize(1);
    }

    @Test
    public void testAssignProfileFollowedByNullUserAssignment() throws Exception {
        setUpServiceWithProfileSupportEnabled();
        mService.init();
        mService.setCarServiceHelper(mICarServiceHelper);

        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                PROFILE_USER1)).isTrue();

        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(CURRENT_USER, new int[] {mDisplay4.getDisplayId()});
        assertDisplayAllowlist(PROFILE_USER1, new int[] {mDisplay2.getDisplayId()});

        mICarServiceHelper.mAllowlists.clear();
        assertThat(mManager.assignProfileUserToOccupantZone(mZoneFrontPassengerLHD,
                UserHandle.USER_NULL)).isTrue();
        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(CURRENT_USER, new int[] {mDisplay2.getDisplayId(),
                mDisplay4.getDisplayId()});
        assertThat(mICarServiceHelper.mAllowlists).hasSize(1);
    }

    @Test
    public void testCarServiceHelperInitialUpdate() throws Exception {
        setUpServiceWithProfileSupportEnabled();
        mService.init();
        mService.setCarServiceHelper(mICarServiceHelper);

        assertPassengerDisplaysFromDefaultConfig();
        assertDisplayAllowlist(CURRENT_USER, new int[] {mDisplay2.getDisplayId(),
                mDisplay4.getDisplayId()});
        assertThat(mICarServiceHelper.mAllowlists).hasSize(1);
    }

    private void assertDisplayInfoIncluded(
            ArrayList<DisplayInfo> displayInfos, Display display, int displayType) {
        for (DisplayInfo info : displayInfos) {
            if (info.display == display && info.displayType == displayType) {
                return;
            }
        }
        fail("Cannot find display:" + display + " type:" + displayType);
    }

    private void assertOccupantConfig(OccupantConfig c, int userId, Display[] displays,
            int[] displayTypes) {
        assertThat(userId).isEqualTo(c.userId);
        assertThat(c.displayInfos).hasSize(displays.length);
        assertThat(c.displayInfos).hasSize(displayTypes.length);
        for (int i = 0; i < displays.length; i++) {
            assertDisplayInfoIncluded(c.displayInfos, displays[i], displayTypes[i]);
        }
    }

    @Test
    public void testSetAudioConfigMapping() {
        mService.init();

        SparseIntArray audioZoneIdToOccupantZoneMapping =
                getDefaultAudioZoneToOccupantZoneMapping();

        mService.setAudioZoneIdsForOccupantZoneIds(audioZoneIdToOccupantZoneMapping);

        assertThat(mService.getAudioZoneIdForOccupant(PRIMARY_AUDIO_ZONE_ID_OCCUPANT))
                .isEqualTo(PRIMARY_AUDIO_ZONE_ID);

        assertThat(mService.getAudioZoneIdForOccupant(SECONDARY_AUDIO_ZONE_ID_OCCUPANT))
                .isEqualTo(SECONDARY_AUDIO_ZONE_ID);
    }

    private SparseIntArray getDefaultAudioZoneToOccupantZoneMapping() {
        SparseIntArray audioZoneIdToOccupantZoneMapping = new SparseIntArray(2);
        audioZoneIdToOccupantZoneMapping.put(PRIMARY_AUDIO_ZONE_ID,
                PRIMARY_AUDIO_ZONE_ID_OCCUPANT);
        audioZoneIdToOccupantZoneMapping.put(SECONDARY_AUDIO_ZONE_ID,
                SECONDARY_AUDIO_ZONE_ID_OCCUPANT);
        return audioZoneIdToOccupantZoneMapping;
    }

    @Test
    public void testOccupantZoneConfigInfoForAudio() {
        mService.init();
        SparseIntArray audioZoneIdToOccupantZoneMapping =
                getDefaultAudioZoneToOccupantZoneMapping();

        SparseArray<CarOccupantZoneManager.OccupantZoneInfo> occupantZoneConfigs =
                mService.getOccupantsConfig();

        mService.setAudioZoneIdsForOccupantZoneIds(audioZoneIdToOccupantZoneMapping);

        CarOccupantZoneManager.OccupantZoneInfo primaryOccupantInfo =
                mService.getOccupantForAudioZoneId(PRIMARY_AUDIO_ZONE_ID);
        assertThat(primaryOccupantInfo).isEqualTo(
                occupantZoneConfigs.get(PRIMARY_AUDIO_ZONE_ID_OCCUPANT));

        CarOccupantZoneManager.OccupantZoneInfo secondaryOccupantInfo =
                mService.getOccupantForAudioZoneId(SECONDARY_AUDIO_ZONE_ID);
        assertThat(secondaryOccupantInfo).isEqualTo(
                occupantZoneConfigs.get(SECONDARY_AUDIO_ZONE_ID_OCCUPANT));

        CarOccupantZoneManager.OccupantZoneInfo nullOccupantInfo =
                mService.getOccupantForAudioZoneId(UNMAPPED_AUDIO_ZONE_ID_OCCUPANT);
        assertThat(nullOccupantInfo).isNull();
    }

    @Test
    public void testMissingAudioConfigMapping() {
        mService.init();
        SparseIntArray audioZoneIdToOccupantZoneMapping =
                getDefaultAudioZoneToOccupantZoneMapping();

        mService.setAudioZoneIdsForOccupantZoneIds(audioZoneIdToOccupantZoneMapping);

        assertThat(mService.getAudioZoneIdForOccupant(UNMAPPED_AUDIO_ZONE_ID_OCCUPANT))
                .isEqualTo(CarAudioManager.INVALID_AUDIO_ZONE);
    }

    @Test
    public void testSetInvalidAudioConfigMapping() {
        mService.init();
        SparseIntArray audioZoneIdToOccupantZoneMapping = new SparseIntArray(2);
        audioZoneIdToOccupantZoneMapping.put(PRIMARY_AUDIO_ZONE_ID,
                PRIMARY_AUDIO_ZONE_ID_OCCUPANT);
        audioZoneIdToOccupantZoneMapping.put(SECONDARY_AUDIO_ZONE_ID,
                INVALID_AUDIO_ZONE_ID_OCCUPANT);
        IllegalArgumentException thrown =
                expectThrows(IllegalArgumentException.class,
                        () -> mService.setAudioZoneIdsForOccupantZoneIds(
                                audioZoneIdToOccupantZoneMapping));
        thrown.getMessage().contains("does not exist");
    }

    @Test
    public void testActiveOccupantConfigs() {
        mService.init();

        // key : zone id
        SparseArray<OccupantConfig> configs = mService.getActiveOccupantConfigs();
        assertThat(configs.size()).isEqualTo(3); // driver, front passenger, one rear
        assertOccupantConfig(configs.get(0), CURRENT_USER, new Display[]{mDisplay0, mDisplay1},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN,
                        CarOccupantZoneManager.DISPLAY_TYPE_INSTRUMENT_CLUSTER});
        assertOccupantConfig(configs.get(1), CURRENT_USER, new Display[]{mDisplay2},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
        assertOccupantConfig(configs.get(3), CURRENT_USER, new Display[]{mDisplay4},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
    }

    @Test
    public void testActiveOccupantConfigsAfterDisplayAdd() {
        mService.init();

        mockDisplay(mDisplayManager, mDisplay3, 3, 13);
        when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
                mDisplay0,
                mDisplay1,
                mDisplay2,
                mDisplay3,
                mDisplay4,
                mDisplay5
        });
        mService.mDisplayListener.onDisplayAdded(3);

        // key : zone id
        SparseArray<OccupantConfig> configs = mService.getActiveOccupantConfigs();
        assertThat(configs.size()).isEqualTo(4); // driver, front passenger, two rear
        assertOccupantConfig(configs.get(0), CURRENT_USER, new Display[]{mDisplay0, mDisplay1},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN,
                        CarOccupantZoneManager.DISPLAY_TYPE_INSTRUMENT_CLUSTER});
        assertOccupantConfig(configs.get(1), CURRENT_USER, new Display[]{mDisplay2},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
        assertOccupantConfig(configs.get(2), CURRENT_USER, new Display[]{mDisplay3},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
        assertOccupantConfig(configs.get(3), CURRENT_USER, new Display[]{mDisplay4},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
    }

    @Test
    public void testActiveOccupantConfigsAfterDisplayRemoval() {
        mService.init();

        when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
                mDisplay0,
                mDisplay1,
                mDisplay2,
        });
        mService.mDisplayListener.onDisplayRemoved(4);

        // key : zone id
        SparseArray<OccupantConfig> configs = mService.getActiveOccupantConfigs();
        assertThat(configs.size()).isEqualTo(2); // driver, front passenger
        assertOccupantConfig(configs.get(0), CURRENT_USER, new Display[]{mDisplay0, mDisplay1},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN,
                        CarOccupantZoneManager.DISPLAY_TYPE_INSTRUMENT_CLUSTER});
        assertOccupantConfig(configs.get(1), CURRENT_USER, new Display[]{mDisplay2},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
    }

    @Test
    public void testActiveUserAfterUserSwitching() {
        mService.init();

        final int newUserId = 200;
        doReturn(newUserId).when(mService).getCurrentUser();
        mService.mUserLifecycleListener.onEvent(new UserLifecycleEvent(
                CarUserManager.USER_LIFECYCLE_EVENT_TYPE_SWITCHING, newUserId));

        // key : zone id
        SparseArray<OccupantConfig> configs = mService.getActiveOccupantConfigs();
        assertThat(configs.size()).isEqualTo(3); // driver, front passenger, one rear
        assertOccupantConfig(configs.get(0), newUserId, new Display[]{mDisplay0, mDisplay1},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN,
                        CarOccupantZoneManager.DISPLAY_TYPE_INSTRUMENT_CLUSTER});
        assertOccupantConfig(configs.get(1), newUserId, new Display[]{mDisplay2},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
        assertOccupantConfig(configs.get(3), newUserId, new Display[]{mDisplay4},
                new int[]{CarOccupantZoneManager.DISPLAY_TYPE_MAIN});
    }

    private void assertParsingFailure() {
        assertThrows(Exception.class, () -> mService.init());
        // call release to return it to clean state.
        mService.release();
    }

    @Test
    public void testWrongZoneConfigs() {
        final String[] wrongZoneConfigs = {
                "unknownKeyword",
                "unknownKey=0",
                "occupantZoneId=0,occupantType=Unknown,seatRow=1,seatSide=driver",
                "occupantZoneId=0,occupantType=DRIVER,seatRow=0,seatSide=driver", // wrong row
                "occupantZoneId=0,occupantType=DRIVER,seatRow=1,seatSide=wrongSide"
        };

        String[] zoneConfig = new String[1];
        when(mResources.getStringArray(R.array.config_occupant_zones))
                .thenReturn(zoneConfig);
        for (int i = 0; i < wrongZoneConfigs.length; i++) {
            zoneConfig[0] = wrongZoneConfigs[i];
            assertParsingFailure();
        }
    }

    @Test
    public void testWrongDisplayConfigs() {
        final String[] wrongDisplayConfigs = {
                "unknownKeyword",
                "unknownKey=0",
                "displayPort=10,displayType=Unknown,occupantZoneId=0",
                "displayPort=10,displayType=MAIN,occupantZoneId=100" // wrong zone id
        };

        String[] displayConfig = new String[1];
        when(mResources.getStringArray(R.array.config_occupant_display_mapping))
                .thenReturn(displayConfig);
        for (int i = 0; i < wrongDisplayConfigs.length; i++) {
            displayConfig[0] = wrongDisplayConfigs[i];
            assertParsingFailure();
        }
    }

    @Test
    public void testManagerGetAllOccupantZones() {
        mService.init();

        List<OccupantZoneInfo> infos = mManager.getAllOccupantZones();
        assertThat(infos).hasSize(3);
        assertThat(infos).contains(mZoneDriverLHD);
        assertThat(infos).contains(mZoneFrontPassengerLHD);
        assertThat(infos).contains(mZoneRearRight);
    }

    @Test
    public void testManagerGetAllDisplaysForOccupant() {
        mService.init();

        List<Display> displaysForDriver = mManager.getAllDisplaysForOccupant(mZoneDriverLHD);
        assertThat(displaysForDriver).hasSize(2);
        assertThat(displaysForDriver).contains(mDisplay0);
        assertThat(displaysForDriver).contains(mDisplay1);

        List<Display> displaysForFrontPassenger = mManager.getAllDisplaysForOccupant(
                mZoneFrontPassengerLHD);
        assertThat(displaysForFrontPassenger).hasSize(1);
        assertThat(displaysForFrontPassenger).contains(mDisplay2);

        List<Display> displaysForRearLeft = mManager.getAllDisplaysForOccupant(
                mZoneRearLeft);
        assertThat(displaysForRearLeft).hasSize(0);

        List<Display> displaysForRearRight = mManager.getAllDisplaysForOccupant(
                mZoneRearRight);
        assertThat(displaysForRearRight).hasSize(1);
        assertThat(displaysForRearRight).contains(mDisplay4);
    }

    @Test
    public void testManagerGetAllDisplaysForOccupantAfterDisplayAdd() {
        mService.init();

        mockDisplay(mDisplayManager, mDisplay3, 3, 13);
        when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
                mDisplay0,
                mDisplay1,
                mDisplay2,
                mDisplay3,
                mDisplay4,
                mDisplay5
        });
        mService.mDisplayListener.onDisplayAdded(3);

        List<Display> displaysForDriver = mManager.getAllDisplaysForOccupant(mZoneDriverLHD);
        assertThat(displaysForDriver).hasSize(2);
        assertThat(displaysForDriver).contains(mDisplay0);
        assertThat(displaysForDriver).contains(mDisplay1);

        List<Display> displaysForFrontPassenger = mManager.getAllDisplaysForOccupant(
                mZoneFrontPassengerLHD);
        assertThat(displaysForFrontPassenger).hasSize(1);
        assertThat(displaysForFrontPassenger).contains(mDisplay2);

        List<Display> displaysForRearLeft = mManager.getAllDisplaysForOccupant(
                mZoneRearLeft);
        assertThat(displaysForRearLeft).hasSize(1);
        assertThat(displaysForRearLeft).contains(mDisplay3);

        List<Display> displaysForRearRight = mManager.getAllDisplaysForOccupant(
                mZoneRearRight);
        assertThat(displaysForRearRight).hasSize(1);
        assertThat(displaysForRearRight).contains(mDisplay4);
    }

    @Test
    public void testManagerGetAllDisplaysForOccupantAfterDisplayRemoval() {
        mService.init();

        when(mDisplayManager.getDisplays()).thenReturn(new Display[]{
                mDisplay0,
                mDisplay1,
                mDisplay2,
        });
        mService.mDisplayListener.onDisplayRemoved(4);

        List<Display> displaysForDriver = mManager.getAllDisplaysForOccupant(mZoneDriverLHD);
        assertThat(displaysForDriver).hasSize(2);
        assertThat(displaysForDriver).contains(mDisplay0);
        assertThat(displaysForDriver).contains(mDisplay1);

        List<Display> displaysForFrontPassenger = mManager.getAllDisplaysForOccupant(
                mZoneFrontPassengerLHD);
        assertThat(displaysForFrontPassenger).hasSize(1);
        assertThat(displaysForFrontPassenger).contains(mDisplay2);

        List<Display> displaysForRearLeft = mManager.getAllDisplaysForOccupant(
                mZoneRearLeft);
        assertThat(displaysForRearLeft).hasSize(0);

        List<Display> displaysForRearRight = mManager.getAllDisplaysForOccupant(
                mZoneRearRight);
        assertThat(displaysForRearRight).hasSize(0);
    }

    @Test
    public void testManagerGetDisplayForOccupant() {
        mService.init();

        assertThat(mDisplay0).isEqualTo(mManager.getDisplayForOccupant(mZoneDriverLHD,
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN));
        assertThat(mDisplay1).isEqualTo(mManager.getDisplayForOccupant(mZoneDriverLHD,
                CarOccupantZoneManager.DISPLAY_TYPE_INSTRUMENT_CLUSTER));
        assertThat(mManager.getDisplayForOccupant(mZoneDriverLHD,
                CarOccupantZoneManager.DISPLAY_TYPE_HUD)).isNull();

        assertThat(mDisplay2).isEqualTo(mManager.getDisplayForOccupant(mZoneFrontPassengerLHD,
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN));

        assertThat(mManager.getDisplayForOccupant(mZoneRearLeft,
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN)).isNull();

        assertThat(mDisplay4).isEqualTo(mManager.getDisplayForOccupant(mZoneRearRight,
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN));
    }

    @Test
    public void testManagerGetDisplayType() {
        mService.init();

        assertThat(mManager.getDisplayType(mDisplay0)).isEqualTo(
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN);
        assertThat(mManager.getDisplayType(mDisplay1)).isEqualTo(
                CarOccupantZoneManager.DISPLAY_TYPE_INSTRUMENT_CLUSTER);
        assertThat(mManager.getDisplayType(mDisplay2)).isEqualTo(
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN);
        assertThat(mManager.getDisplayType(mDisplay4)).isEqualTo(
                CarOccupantZoneManager.DISPLAY_TYPE_MAIN);
        assertThat(mManager.getDisplayType(mDisplay5)).isEqualTo(
                CarOccupantZoneManager.DISPLAY_TYPE_UNKNOWN);
    }

    @Test
    public void testManagerGetUserForOccupant() {
        mService.init();

        int driverUser = mManager.getUserForOccupant(mZoneDriverLHD);
        assertThat(CURRENT_USER).isEqualTo(driverUser);

        //TODO update this after secondary user handling
        assertThat(mManager.getUserForOccupant(mZoneFrontPassengerLHD)).isEqualTo(driverUser);
        assertThat(mManager.getUserForOccupant(mZoneRearLeft)).isEqualTo(UserHandle.USER_NULL);
        assertThat(mManager.getUserForOccupant(mZoneRearRight)).isEqualTo(driverUser);
    }

    @Test
    public void testManagerGetUserForOccupantAfterUserSwitch() {
        mService.init();

        final int newUserId = 200;
        doReturn(newUserId).when(mService).getCurrentUser();
        mService.mUserLifecycleListener.onEvent(new UserLifecycleEvent(
                CarUserManager.USER_LIFECYCLE_EVENT_TYPE_SWITCHING, newUserId));

        assertThat(newUserId).isEqualTo(mManager.getUserForOccupant(mZoneDriverLHD));
        //TODO update this after secondary user handling
        assertThat(mManager.getUserForOccupant(mZoneFrontPassengerLHD)).isEqualTo(newUserId);
        assertThat(mManager.getUserForOccupant(mZoneRearLeft)).isEqualTo(UserHandle.USER_NULL);
        assertThat(mManager.getUserForOccupant(mZoneRearRight)).isEqualTo(newUserId);
    }

    @Test
    public void testManagerRegisterUnregister() {
        mService.init();

        final long eventWaitTimeMs = 300;

        mManager.registerOccupantZoneConfigChangeListener(mChangeListener);

        resetConfigChangeEventWait();
        mService.mUserLifecycleListener.onEvent(new UserLifecycleEvent(
                CarUserManager.USER_LIFECYCLE_EVENT_TYPE_SWITCHING, 0)); // user id does not matter.

        assertThat(waitForConfigChangeEventAndAssertFlag(eventWaitTimeMs,
                CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_USER)).isTrue();

        resetConfigChangeEventWait();
        mService.mDisplayListener.onDisplayAdded(0); // displayid ignored
        assertThat(waitForConfigChangeEventAndAssertFlag(eventWaitTimeMs,
                CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_DISPLAY)).isTrue();

        resetConfigChangeEventWait();
        mManager.unregisterOccupantZoneConfigChangeListener(mChangeListener);
        mService.mUserLifecycleListener.onEvent(new UserLifecycleEvent(
                CarUserManager.USER_LIFECYCLE_EVENT_TYPE_SWITCHING, 0));
        assertThat(waitForConfigChangeEventAndAssertFlag(eventWaitTimeMs, 0)).isFalse();
    }

    @Test
    public void testManagerRegisterUnregisterForAudioConfigs() {
        mService.init();

        long eventWaitTimeMs = 300;

        mManager.registerOccupantZoneConfigChangeListener(mChangeListener);

        resetConfigChangeEventWait();

        SparseIntArray audioZoneIdToOccupantZoneMapping =
                getDefaultAudioZoneToOccupantZoneMapping();

        mService.setAudioZoneIdsForOccupantZoneIds(audioZoneIdToOccupantZoneMapping);

        assertThat(waitForConfigChangeEventAndAssertFlag(eventWaitTimeMs,
                CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_AUDIO)).isTrue();

        resetConfigChangeEventWait();
        mManager.unregisterOccupantZoneConfigChangeListener(mChangeListener);
        mService.setAudioZoneIdsForOccupantZoneIds(audioZoneIdToOccupantZoneMapping);
        assertThat(waitForConfigChangeEventAndAssertFlag(eventWaitTimeMs,
                CarOccupantZoneManager.ZONE_CONFIG_CHANGE_FLAG_AUDIO)).isFalse();
    }

    private static class ICarServiceHelperImpl extends ICarServiceHelper.Stub {
        private List<Integer> mPassengerDisplayIds;

        /** key: user id, value: display allowlists */
        private HashMap<Integer, List<Integer>> mAllowlists = new HashMap<>();

        @Override
        public int forceSuspend(int timeoutMs) {
            return 0;
        }

        @Override
        public void setDisplayAllowlistForUser(@UserIdInt int userId, int[] displayIds) {
            mAllowlists.put(userId, Arrays.stream(displayIds).boxed().collect(Collectors.toList()));
        }

        @Override
        public void setPassengerDisplays(int[] displayIdsForPassenger) {
            mPassengerDisplayIds = Arrays.stream(displayIdsForPassenger).boxed().collect(
                    Collectors.toList());
        }

        @Override
        public void setSourcePreferredComponents(boolean enableSourcePreferred,
                List<ComponentName> sourcePreferredComponents) throws RemoteException {
        }
    }
}