xref: /packages/services/Car/tests/carservice_test/src/com/android/car/CarPropertyManagerTest.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 android.car.hardware.property.CarPropertyManager.STATUS_ERROR_INTERNAL_ERROR;
import static android.car.hardware.property.CarPropertyManager.STATUS_ERROR_NOT_AVAILABLE;
import static android.car.hardware.property.CarPropertyManager.STATUS_ERROR_TIMEOUT;

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

import static org.junit.Assert.assertThrows;

import android.car.Car;
import android.car.VehicleAreaType;
import android.car.VehicleAreaWheel;
import android.car.VehiclePropertyIds;
import android.car.hardware.CarPropertyConfig;
import android.car.hardware.CarPropertyValue;
import android.car.hardware.property.CarInternalErrorException;
import android.car.hardware.property.CarPropertyManager;
import android.car.hardware.property.CarPropertyManager.GetPropertyRequest;
import android.car.hardware.property.CarPropertyManager.GetPropertyResult;
import android.car.hardware.property.CarPropertyManager.PropertyAsyncError;
import android.car.hardware.property.CarPropertyManager.SetPropertyRequest;
import android.car.hardware.property.CarPropertyManager.SetPropertyResult;
import android.car.hardware.property.PropertyAccessDeniedSecurityException;
import android.car.hardware.property.PropertyNotAvailableAndRetryException;
import android.car.hardware.property.PropertyNotAvailableException;
import android.car.hardware.property.VehicleHalStatusCode;
import android.hardware.automotive.vehicle.RawPropValues;
import android.hardware.automotive.vehicle.VehicleArea;
import android.hardware.automotive.vehicle.VehicleAreaSeat;
import android.hardware.automotive.vehicle.VehiclePropValue;
import android.hardware.automotive.vehicle.VehicleProperty;
import android.hardware.automotive.vehicle.VehiclePropertyGroup;
import android.hardware.automotive.vehicle.VehiclePropertyStatus;
import android.hardware.automotive.vehicle.VehiclePropertyType;
import android.hardware.automotive.vehicle.VehicleVendorPermission;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.ServiceSpecificException;
import android.os.SystemClock;
import android.util.ArraySet;
import android.util.Log;
import android.util.SparseArray;

import androidx.annotation.NonNull;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.filters.MediumTest;

import com.android.car.hal.test.AidlMockedVehicleHal.VehicleHalPropertyHandler;
import com.android.car.test.TestPropertyAsyncCallback;

import com.google.common.truth.Truth;

import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName;
import org.junit.runner.RunWith;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;

/**
 * Test for {@link android.car.hardware.property.CarPropertyManager}
 *
 * Tests {@link android.car.hardware.property.CarPropertyManager} and the related car service
 * logic. Uses {@link com.android.car.hal.test.AidlMockedVehicleHal} as the mocked vehicle HAL
 * implementation.
 *
 * Caller should uses {@code addAidlProperty} in {@link #configureMockedHal} to configure the
 * supported proeprties.
 *
 * Caller could also use {@link MockedCarTestBase#getAidlMockedVehicleHal} to further configure
 * the vehicle HAL.
 */
@RunWith(AndroidJUnit4.class)
@MediumTest
public class CarPropertyManagerTest extends MockedCarTestBase {

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

    private static final String TEST_VIN = "test_vin";

    /**
     * configArray[0], 1 indicates the property has a String value
     * configArray[1], 1 indicates the property has a Boolean value .
     * configArray[2], 1 indicates the property has an Integer value
     * configArray[3], the number indicates the size of Integer[]  in the property.
     * configArray[4], 1 indicates the property has a Long value .
     * configArray[5], the number indicates the size of Long[]  in the property.
     * configArray[6], 1 indicates the property has a Float value .
     * configArray[7], the number indicates the size of Float[] in the property.
     * configArray[8], the number indicates the size of byte[] in the property.
     */
    private static final java.util.Collection<Integer> CONFIG_ARRAY_1 =
            Arrays.asList(1, 0, 1, 0, 1, 0, 0, 0, 0);
    private static final java.util.Collection<Integer> CONFIG_ARRAY_2 =
            Arrays.asList(1, 1, 1, 0, 0, 0, 0, 2, 0);
    private static final java.util.Collection<Integer> CONFIG_ARRAY_3 =
            Arrays.asList(0, 1, 1, 0, 0, 0, 1, 0, 0);
    private static final Object[] EXPECTED_VALUE_1 = {"android", 1, 1L};
    private static final Object[] EXPECTED_VALUE_2 = {"android", true, 3, 1.1f, 2f};
    private static final Object[] EXPECTED_VALUE_3 = {true, 1, 2.2f};

    private static final int CUSTOM_SEAT_INT_PROP_1 =
            0x1201 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.SEAT;
    private static final int CUSTOM_SEAT_INT_PROP_2 =
            0x1202 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.SEAT;

    private static final int CUSTOM_SEAT_MIXED_PROP_ID_1 =
            0x1101 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.MIXED | VehicleArea.SEAT;
    private static final int CUSTOM_GLOBAL_MIXED_PROP_ID_2 =
            0x1102 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.MIXED | VehicleArea.GLOBAL;
    private static final int CUSTOM_GLOBAL_MIXED_PROP_ID_3 =
            0x1110 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.MIXED | VehicleArea.GLOBAL;

    private static final int CUSTOM_GLOBAL_INT_ARRAY_PROP =
            0x1103 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32_VEC
                    | VehicleArea.GLOBAL;
    private static final Integer[] FAKE_INT_ARRAY_VALUE = {1, 2};
    private static final boolean FAKE_BOOLEAN_PROPERTY_VALUE = true;
    private static final float FAKE_FLOAT_PROPERTY_VALUE = 3f;
    private static final int FAKE_INT_PROPERTY_VALUE = 3;

    // A property that always returns null to simulate an unavailable property.
    private static final int NULL_VALUE_PROP =
            0x1108 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32
                    | VehicleArea.GLOBAL;

    // Vendor properties for testing exceptions.
    private static final int PROP_VALUE_STATUS_ERROR_INT_ARRAY =
            0x1104 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32_VEC
                    | VehicleArea.GLOBAL;
    private static final int PROP_VALUE_STATUS_ERROR_BOOLEAN =
            0x1105 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.BOOLEAN
                    | VehicleArea.GLOBAL;
    private static final int PROP_VALUE_STATUS_UNAVAILABLE_FLOAT =
            0x1106 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.FLOAT
                    | VehicleArea.GLOBAL;
    private static final int PROP_VALUE_STATUS_UNAVAILABLE_INT =
            0x1107 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32
                    | VehicleArea.GLOBAL;
    private static final int PROP_VALUE_STATUS_UNKNOWN_INT_ARRAY =
            0x1108 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32_VEC
                    | VehicleArea.GLOBAL;
    private static final int PROP_VALUE_STATUS_UNAVAILABLE_SEAT =
            0x1109 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32
                    | VehicleArea.SEAT;

    private static final int PROP_CAUSE_STATUS_CODE_TRY_AGAIN =
            0x1201 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_CAUSE_STATUS_CODE_INVALID_ARG =
            0x1202 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE =
            0x1203 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR =
            0x1204 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_CAUSE_STATUS_CODE_ACCESS_DENIED =
            0x1205 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_CAUSE_STATUS_CODE_UNKNOWN =
            0x1206 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE =
            0x1207 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE =
            0x1208 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;

    // Vendor properties for testing permissions
    private static final int PROP_WITH_READ_ONLY_PERMISSION =
            0x1301 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int PROP_WITH_WRITE_ONLY_PERMISSION =
            0x1302 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;
    private static final int SUPPORT_CUSTOM_PERMISSION = 287313669;
    private static final java.util.Collection<Integer> VENDOR_PERMISSION_CONFIG =
            Collections.unmodifiableList(
                    Arrays.asList(PROP_WITH_READ_ONLY_PERMISSION,
                            VehicleVendorPermission.PERMISSION_GET_VENDOR_CATEGORY_1,
                            VehicleVendorPermission.PERMISSION_NOT_ACCESSIBLE,
                            PROP_WITH_WRITE_ONLY_PERMISSION,
                            VehicleVendorPermission.PERMISSION_NOT_ACCESSIBLE,
                            VehicleVendorPermission.PERMISSION_SET_VENDOR_CATEGORY_1));

    private static final int PROP_ERROR_EVENT_NOT_AVAILABLE_DISABLED =
            0x1401 | VehiclePropertyGroup.VENDOR | VehiclePropertyType.INT32 |  VehicleArea.GLOBAL;


    // Use FAKE_PROPERTY_ID to test api return null or throw exception.
    private static final int FAKE_PROPERTY_ID = 0x111;

    // This is a property returned by VHAL, but is unsupported in car service.
    // It must be filtered out at car service layer.
    private static final int PROP_UNSUPPORTED =
            0x0100 | VehiclePropertyGroup.SYSTEM | VehiclePropertyType.INT32 | VehicleArea.GLOBAL;

    private static final int DRIVER_SIDE_AREA_ID = VehicleAreaSeat.ROW_1_LEFT
            | VehicleAreaSeat.ROW_2_LEFT;
    private static final int PASSENGER_SIDE_AREA_ID = VehicleAreaSeat.ROW_1_RIGHT
            | VehicleAreaSeat.ROW_2_CENTER
            | VehicleAreaSeat.ROW_2_RIGHT;
    private static final float INIT_TEMP_VALUE = 16f;
    private static final float CHANGED_TEMP_VALUE = 20f;
    private static final int CALLBACK_SHORT_TIMEOUT_MS = 350; // ms
    // Wait for CarPropertyManager register/unregister listener
    private static final long WAIT_FOR_NO_EVENTS = 50;
    private static final int VENDOR_CODE_FOR_NOT_AVAILABLE = 0x00ab;
    private static final int VENDOR_CODE_FOR_INTERNAL_ERROR = 0x0abc;
    private static final int NOT_AVAILABLE_WITH_VENDOR_CODE = VENDOR_CODE_FOR_NOT_AVAILABLE << 16
            | VehicleHalStatusCode.STATUS_NOT_AVAILABLE;
    private static final int INTERNAL_ERROR_WITH_VENDOR_CODE = VENDOR_CODE_FOR_INTERNAL_ERROR << 16
            | VehicleHalStatusCode.STATUS_INTERNAL_ERROR;

    private static final List<Integer> USER_HAL_PROPERTIES = Arrays.asList(
            VehiclePropertyIds.INITIAL_USER_INFO,
            VehiclePropertyIds.SWITCH_USER,
            VehiclePropertyIds.CREATE_USER,
            VehiclePropertyIds.REMOVE_USER,
            VehiclePropertyIds.USER_IDENTIFICATION_ASSOCIATION
    );

    private CarPropertyManager mManager;

    private final HandlerThread mHandlerThread = new HandlerThread(getClass().getSimpleName());
    private Handler mHandler;

    @Rule
    public TestName mTestName = new TestName();

    @Override
    public void setUp() throws Exception {
        super.setUp();
        setUpTargetSdk();
        mHandlerThread.start();
        mHandler = new Handler(mHandlerThread.getLooper());
        mManager = (CarPropertyManager) getCar().getCarManager(Car.PROPERTY_SERVICE);
        assertThat(mManager).isNotNull();
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
        mHandlerThread.quitSafely();
    }

    private void setUpTargetSdk() {
        getContext().getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.CUR_DEVELOPMENT;
        if (mTestName.getMethodName().endsWith("BeforeR")) {
            getContext().getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.Q;
        } else if (mTestName.getMethodName().endsWith("BeforeS")
                || mTestName.getMethodName().endsWith("AfterR")) {
            getContext().getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.R;
        } else if (mTestName.getMethodName().endsWith("AfterS")) {
            getContext().getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.S;
        }
    }

    @Test
    public void testMixedPropertyConfigs() {
        List<CarPropertyConfig> configs = mManager.getPropertyList();
        for (CarPropertyConfig cfg : configs) {
            switch (cfg.getPropertyId()) {
                case CUSTOM_SEAT_MIXED_PROP_ID_1:
                    assertThat(cfg.getConfigArray()).containsExactlyElementsIn(CONFIG_ARRAY_1)
                            .inOrder();
                    break;
                case CUSTOM_GLOBAL_MIXED_PROP_ID_2:
                    assertThat(cfg.getConfigArray()).containsExactlyElementsIn(CONFIG_ARRAY_2)
                            .inOrder();
                    break;
                case CUSTOM_GLOBAL_MIXED_PROP_ID_3:
                    assertThat(cfg.getConfigArray()).containsExactlyElementsIn(CONFIG_ARRAY_3)
                            .inOrder();
                    break;
                case VehiclePropertyIds.HVAC_TEMPERATURE_SET:
                case PROP_CAUSE_STATUS_CODE_ACCESS_DENIED:
                case PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR:
                case PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE:
                case PROP_CAUSE_STATUS_CODE_TRY_AGAIN:
                case PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE:
                case PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE:
                case PROP_CAUSE_STATUS_CODE_INVALID_ARG:
                case PROP_CAUSE_STATUS_CODE_UNKNOWN:
                case CUSTOM_SEAT_INT_PROP_1:
                case CUSTOM_SEAT_INT_PROP_2:
                case CUSTOM_GLOBAL_INT_ARRAY_PROP:
                case PROP_VALUE_STATUS_ERROR_INT_ARRAY:
                case PROP_VALUE_STATUS_UNKNOWN_INT_ARRAY:
                case PROP_VALUE_STATUS_ERROR_BOOLEAN:
                case PROP_VALUE_STATUS_UNAVAILABLE_INT:
                case PROP_VALUE_STATUS_UNAVAILABLE_FLOAT:
                case PROP_VALUE_STATUS_UNAVAILABLE_SEAT:
                case NULL_VALUE_PROP:
                case SUPPORT_CUSTOM_PERMISSION:
                case PROP_WITH_READ_ONLY_PERMISSION:
                case PROP_WITH_WRITE_ONLY_PERMISSION:
                case VehiclePropertyIds.INFO_VIN:
                case VehiclePropertyIds.TIRE_PRESSURE:
                case VehiclePropertyIds.FUEL_DOOR_OPEN:
                case VehiclePropertyIds.EPOCH_TIME:
                case PROP_ERROR_EVENT_NOT_AVAILABLE_DISABLED:
                    break;
                default:
                    Assert.fail("Unexpected CarPropertyConfig: " + cfg);
            }
        }
    }

    @Test
    public void testGetMixTypeProperty() {
        mManager.setProperty(Object[].class, CUSTOM_SEAT_MIXED_PROP_ID_1,
                DRIVER_SIDE_AREA_ID, EXPECTED_VALUE_1);
        CarPropertyValue<Object[]> result = mManager.getProperty(
                CUSTOM_SEAT_MIXED_PROP_ID_1, DRIVER_SIDE_AREA_ID);
        assertThat(result.getValue()).isEqualTo(EXPECTED_VALUE_1);

        mManager.setProperty(Object[].class, CUSTOM_GLOBAL_MIXED_PROP_ID_2,
                0, EXPECTED_VALUE_2);
        result = mManager.getProperty(
                CUSTOM_GLOBAL_MIXED_PROP_ID_2, 0);
        assertThat(result.getValue()).isEqualTo(EXPECTED_VALUE_2);

        mManager.setProperty(Object[].class, CUSTOM_GLOBAL_MIXED_PROP_ID_3,
                0, EXPECTED_VALUE_3);
        result = mManager.getProperty(
                CUSTOM_GLOBAL_MIXED_PROP_ID_3, 0);
        assertThat(result.getValue()).isEqualTo(EXPECTED_VALUE_3);
    }

    /**
     * Test {@link android.car.hardware.property.CarPropertyManager#getIntArrayProperty(int, int)}
     */
    @Test
    public void testGetIntArrayProperty() {
        mManager.setProperty(Integer[].class, CUSTOM_GLOBAL_INT_ARRAY_PROP, 0,
                FAKE_INT_ARRAY_VALUE);

        int[] result = mManager.getIntArrayProperty(CUSTOM_GLOBAL_INT_ARRAY_PROP, 0);
        assertThat(result).asList().containsExactlyElementsIn(FAKE_INT_ARRAY_VALUE);
    }

    /**
     * Test {@link CarPropertyManager#getIntArrayProperty(int, int)} when vhal returns a value with
     * error status before S.
     */
    @Test
    public void testGetIntArrayPropertyWithErrorStatusBeforeS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isLessThan(Build.VERSION_CODES.S);
        assertThat(mManager.getIntArrayProperty(PROP_VALUE_STATUS_ERROR_INT_ARRAY, 0)).isEqualTo(
                new int[0]);
    }

    /**
     * Test {@link CarPropertyManager#getIntArrayProperty(int, int)} when vhal returns a value with
     * error status equal or after S.
     */
    @Test
    public void testGetIntArrayPropertyWithErrorStatusEqualAfterS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.S);
        assertThrows(CarInternalErrorException.class,
                () -> mManager.getIntArrayProperty(PROP_VALUE_STATUS_ERROR_INT_ARRAY, 0));
    }

    /**
     * Test {@link CarPropertyManager#getIntArrayProperty(int, int)} when vhal returns a value with
     * unknown status before S.
     */
    @Test
    public void testGetIntArrayPropertyWithUnknownStatusBeforeS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isLessThan(Build.VERSION_CODES.S);
        assertThat(mManager.getIntArrayProperty(PROP_VALUE_STATUS_UNKNOWN_INT_ARRAY, 0)).isEqualTo(
                new int[0]);
    }

    /**
     * Test {@link CarPropertyManager#getIntArrayProperty(int, int)} when vhal returns a value with
     * unknown status equal or after S.
     */
    @Test
    public void testGetIntArrayPropertyWithUnknownStatusEqualAfterS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.S);
        assertThrows(CarInternalErrorException.class,
                () -> mManager.getIntArrayProperty(PROP_VALUE_STATUS_UNKNOWN_INT_ARRAY, 0));
    }

    /**
     * Test {@link CarPropertyManager#getIntProperty(int, int)} when vhal returns a value with
     * unavailable status before S.
     */
    @Test
    public void testGetIntPropertyWithUnavailableStatusBeforeS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isLessThan(Build.VERSION_CODES.S);
        assertThat(
                mManager.getIntProperty(PROP_VALUE_STATUS_UNAVAILABLE_INT, 0)).isEqualTo(0);
    }

    /**
     * Test {@link CarPropertyManager#getIntProperty(int, int)} when vhal returns a value with
     * unavailable status equal or after R.
     */
    @Test
    public void testGetIntPropertyWithUnavailableStatusEqualAfterS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);
        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getIntProperty(PROP_VALUE_STATUS_UNAVAILABLE_INT, 0));
    }

    /**
     * Test {@link CarPropertyManager#getBooleanProperty(int, int)} when vhal returns a value with
     * error status before R.
     */
    @Test
    public void testGetBooleanPropertyWithErrorStatusBeforeS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isLessThan(Build.VERSION_CODES.S);
        assertThat(mManager.getBooleanProperty(PROP_VALUE_STATUS_ERROR_BOOLEAN, 0)).isEqualTo(
                false);
    }

    /**
     * Test {@link CarPropertyManager#getBooleanProperty(int, int)} when vhal returns a value with
     * error status equal or after R.
     */
    @Test
    public void testGetBooleanPropertyWithErrorStatusEqualAfterS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);
        assertThrows(CarInternalErrorException.class,
                () -> mManager.getBooleanProperty(PROP_VALUE_STATUS_ERROR_BOOLEAN, 0));
    }

    /**
     * Test {@link CarPropertyManager#getFloatProperty(int, int)} when vhal returns a value with
     * unavailable status before S.
     */
    @Test
    public void testGetFloatPropertyWithUnavailableStatusBeforeS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isLessThan(Build.VERSION_CODES.S);
        assertThat(mManager.getFloatProperty(PROP_VALUE_STATUS_UNAVAILABLE_FLOAT, 0)).isEqualTo(0f);
    }

    /**
     * Test {@link CarPropertyManager#getFloatProperty(int, int)} when vhal returns a value with
     * unavailable status equal or after R.
     */
    @Test
    public void testGetFloatPropertyWithUnavailableStatusEqualAfterS() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);
        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getFloatProperty(PROP_VALUE_STATUS_UNAVAILABLE_FLOAT, 0));
    }

    /**
     * Test {@link CarPropertyManager#getProperty(Class, int, int)}
     */
    @Test
    public void testGetPropertyWithClass() {
        mManager.setProperty(Integer[].class, CUSTOM_GLOBAL_INT_ARRAY_PROP, 0,
                FAKE_INT_ARRAY_VALUE);

        CarPropertyValue<Integer[]> result = mManager.getProperty(Integer[].class,
                CUSTOM_GLOBAL_INT_ARRAY_PROP, 0);
        assertThat(result.getValue()).asList().containsExactlyElementsIn(FAKE_INT_ARRAY_VALUE);
    }

    /**
     * Test {@link CarPropertyManager#isPropertyAvailable(int, int)}
     */
    @Test
    public void testIsPropertyAvailable() {
        assertThat(mManager.isPropertyAvailable(CUSTOM_GLOBAL_INT_ARRAY_PROP, 0)).isFalse();

        mManager.setProperty(Integer[].class, CUSTOM_GLOBAL_INT_ARRAY_PROP, 0,
                FAKE_INT_ARRAY_VALUE);

        assertThat(mManager.isPropertyAvailable(CUSTOM_GLOBAL_INT_ARRAY_PROP, 0)).isTrue();
    }

    /**
     * Test {@link CarPropertyManager#getWritePermission(int)}
     * and {@link CarPropertyManager#getWritePermission(int)}
     */
    @Test
    public void testGetPermission() {
        String hvacReadPermission = mManager.getReadPermission(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET);
        assertThat(hvacReadPermission).isEqualTo(Car.PERMISSION_CONTROL_CAR_CLIMATE);
        String hvacWritePermission = mManager.getWritePermission(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET);
        assertThat(hvacWritePermission).isEqualTo(Car.PERMISSION_CONTROL_CAR_CLIMATE);

        // For read-only property
        String vinReadPermission = mManager.getReadPermission(VehiclePropertyIds.INFO_VIN);
        assertThat(vinReadPermission).isEqualTo(Car.PERMISSION_IDENTIFICATION);
        String vinWritePermission = mManager.getWritePermission(VehiclePropertyIds.INFO_VIN);
        assertThat(vinWritePermission).isNull();
    }

    @Test
    public void testGetPropertyConfig() {
        CarPropertyConfig<?> config = mManager.getCarPropertyConfig(CUSTOM_SEAT_MIXED_PROP_ID_1);
        assertThat(config.getPropertyId()).isEqualTo(CUSTOM_SEAT_MIXED_PROP_ID_1);
        // returns null if it cannot find the propertyConfig for the property.
        assertThat(mManager.getCarPropertyConfig(FAKE_PROPERTY_ID)).isNull();
    }

    @Test
    public void testGetPropertyConfig_withReadOnlyPermission() {
        CarPropertyConfig<?> configForReadOnlyProperty = mManager
                .getCarPropertyConfig(PROP_WITH_READ_ONLY_PERMISSION);

        assertThat(configForReadOnlyProperty).isNotNull();
        assertThat(configForReadOnlyProperty.getPropertyId())
                .isEqualTo(PROP_WITH_READ_ONLY_PERMISSION);
    }

    @Test
    public void testGetPropertyConfig_withWriteOnlyPermission() {
        CarPropertyConfig<?> configForWriteOnlyProperty = mManager
                .getCarPropertyConfig(PROP_WITH_WRITE_ONLY_PERMISSION);

        assertThat(configForWriteOnlyProperty).isNotNull();
        assertThat(configForWriteOnlyProperty.getPropertyId())
                .isEqualTo(PROP_WITH_WRITE_ONLY_PERMISSION);
    }

    @Test
    public void testGetAreaId() {
        int result = mManager.getAreaId(CUSTOM_SEAT_MIXED_PROP_ID_1, VehicleAreaSeat.ROW_1_LEFT);
        assertThat(result).isEqualTo(DRIVER_SIDE_AREA_ID);
        //test for the GLOBAL property
        int globalAreaId =
                mManager.getAreaId(CUSTOM_GLOBAL_MIXED_PROP_ID_2, VehicleAreaSeat.ROW_1_LEFT);
        assertThat(globalAreaId).isEqualTo(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL);
        //test exception
        assertThrows(IllegalArgumentException.class, () -> mManager.getAreaId(
                CUSTOM_SEAT_MIXED_PROP_ID_1, VehicleAreaSeat.ROW_3_CENTER));
        assertThrows(IllegalArgumentException.class, () -> mManager.getAreaId(FAKE_PROPERTY_ID,
                VehicleAreaSeat.ROW_1_LEFT));
    }

    @Test
    public void testRegisterPropertyGetInitialValueHandleNotAvailableStatusCode() throws Exception {
        TestCallback callback = new TestCallback(/* initValueCount= */ 1,
                /* changeEventCount= */ 0, /* errorEventCount= */ 0);

        mManager.registerCallback(callback, PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);

        callback.assertRegisterCompleted();
        List<CarPropertyValue> carPropertyValues = callback.getInitialValues();
        assertThat(carPropertyValues).hasSize(1);
        assertThat(carPropertyValues.get(0).getStatus()).isEqualTo(
                CarPropertyValue.STATUS_UNAVAILABLE);
    }

    @Test
    public void testRegisterPropertyGetInitialValueHandleAccessDeniedStatusCodes()
            throws Exception {
        TestCallback callback = new TestCallback(/* initValueCount= */ 1,
                /* changeEventCount= */ 0, /* errorEventCount= */ 0);

        mManager.registerCallback(callback, PROP_CAUSE_STATUS_CODE_ACCESS_DENIED,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);

        callback.assertRegisterCompleted();
        List<CarPropertyValue> carPropertyValues = callback.getInitialValues();
        assertThat(carPropertyValues).hasSize(1);
        assertThat(carPropertyValues.get(0).getStatus()).isEqualTo(
                CarPropertyValue.STATUS_ERROR);
    }

    @Test
    public void testRegisterPropertyGetInitialValueHandleInternalErrorStatusCodes()
            throws Exception {
        TestCallback callback = new TestCallback(/* initValueCount= */ 1,
                /* changeEventCount= */ 0, /* errorEventCount= */ 0);

        mManager.registerCallback(callback, PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);

        callback.assertRegisterCompleted();
        List<CarPropertyValue> carPropertyValues = callback.getInitialValues();
        assertThat(carPropertyValues).hasSize(1);
        assertThat(carPropertyValues.get(0).getStatus()).isEqualTo(
                CarPropertyValue.STATUS_ERROR);
    }

    @Test
    public void testRegisterPropertyGetInitialValueHandleInvalidArgStatusCode() throws Exception {
        TestCallback callback = new TestCallback(/* initValueCount= */ 1,
                /* changeEventCount= */ 0, /* errorEventCount= */ 0);

        mManager.registerCallback(callback, PROP_CAUSE_STATUS_CODE_INVALID_ARG,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);

        // We should not receive any initial value event.
        assertThrows(IllegalStateException.class, () -> callback.assertRegisterCompleted(
                /* timeoutInMs=*/ 1000));
    }

    @Test
    public void testRegisterPropertyGetInitialValueHandleTryAgainStatusCode() throws Exception {
        TestCallback callback = new TestCallback(/* initValueCount= */ 1,
                /* changeEventCount= */ 0, /* errorEventCount= */ 0);

        mManager.registerCallback(callback, PROP_CAUSE_STATUS_CODE_TRY_AGAIN,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);

        // We should not receive any initial value event.
        assertThrows(IllegalStateException.class, () -> callback.assertRegisterCompleted(
                /* timeoutInMs=*/ 1000));
    }

    @Test
    public void testNotReceiveOnErrorEvent() throws Exception {
        TestCallback callback = new TestCallback(/* initValueCount= */ 2, /* changeEventCount= */ 0,
                /* errorEventCount= */ 1);
        mManager.registerCallback(callback, VehiclePropertyIds.HVAC_TEMPERATURE_SET,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);
        callback.assertRegisterCompleted();
        injectErrorEvent(VehiclePropertyIds.HVAC_TEMPERATURE_SET, PASSENGER_SIDE_AREA_ID,
                VehicleHalStatusCode.STATUS_INTERNAL_ERROR);
        // app never change the value of HVAC_TEMPERATURE_SET, it won't get an error code.
        callback.assertOnErrorEventNotCalled();
    }

    @Test
    public void testReceiveOnErrorEvent() throws Exception {
        TestCallback callback = new TestCallback(/* initValueCount= */ 2, /* changeEventCount= */ 0,
                /* errorEventCount= */ 1);
        mManager.registerCallback(callback, VehiclePropertyIds.HVAC_TEMPERATURE_SET,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);
        callback.assertRegisterCompleted();
        mManager.setFloatProperty(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET, PASSENGER_SIDE_AREA_ID,
                CHANGED_TEMP_VALUE);
        injectErrorEvent(VehiclePropertyIds.HVAC_TEMPERATURE_SET, PASSENGER_SIDE_AREA_ID,
                VehicleHalStatusCode.STATUS_INTERNAL_ERROR);
        callback.assertOnErrorEventCalled();
        assertThat(callback.getErrorCode()).isEqualTo(
                CarPropertyManager.CAR_SET_PROPERTY_ERROR_CODE_UNKNOWN);
    }

    @Test
    public void testNotReceiveOnErrorEventAfterUnregister() throws Exception {
        TestCallback callback1 = new TestCallback(/* initValueCount= */ 2,
                /* changeEventCount= */ 0, /* errorEventCount= */ 1);
        mManager.registerCallback(callback1, VehiclePropertyIds.HVAC_TEMPERATURE_SET,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);
        callback1.assertRegisterCompleted();
        TestCallback callback2 = new TestCallback(/* initValueCount= */ 2,
                /* changeEventCount= */ 0, /* errorEventCount= */ 1);
        mManager.registerCallback(callback2, VehiclePropertyIds.HVAC_TEMPERATURE_SET,
                CarPropertyManager.SENSOR_RATE_ONCHANGE);
        mManager.setFloatProperty(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET, PASSENGER_SIDE_AREA_ID,
                CHANGED_TEMP_VALUE);
        mManager.unregisterCallback(callback1, VehiclePropertyIds.HVAC_TEMPERATURE_SET);
        SystemClock.sleep(WAIT_FOR_NO_EVENTS);
        injectErrorEvent(VehiclePropertyIds.HVAC_TEMPERATURE_SET, PASSENGER_SIDE_AREA_ID,
                VehicleHalStatusCode.STATUS_INTERNAL_ERROR);
        // callback1 is unregistered
        callback1.assertOnErrorEventNotCalled();
        callback2.assertOnErrorEventCalled();
    }

    @Test
    public void testSetterExceptionsBeforeR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isLessThan(Build.VERSION_CODES.R);

        assertThrows(IllegalStateException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_ACCESS_DENIED,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(IllegalStateException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(IllegalStateException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(IllegalArgumentException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_INVALID_ARG,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(RuntimeException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_ACCESS_DENIED,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
    }

    @Test
    public void testSetterExceptionsEqualAfterR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.Q);

        assertThrows(PropertyAccessDeniedSecurityException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_ACCESS_DENIED,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(PropertyNotAvailableAndRetryException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_TRY_AGAIN,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(CarInternalErrorException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(IllegalArgumentException.class,
                () -> mManager.setProperty(Integer.class, PROP_CAUSE_STATUS_CODE_INVALID_ARG,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
        assertThrows(IllegalArgumentException.class,
                () -> mManager.setProperty(Integer.class, PROP_UNSUPPORTED,
                        VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 1));
    }

    @Test
    public void testGetterExceptionsBeforeR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isLessThan(Build.VERSION_CODES.R);

        assertThrows(IllegalStateException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_ACCESS_DENIED, 0));
        assertThrows(IllegalStateException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_ACCESS_DENIED, 0));

        assertThrows(IllegalArgumentException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_INVALID_ARG, 0));
        assertThrows(IllegalArgumentException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_INVALID_ARG, 0));

        assertThrows(IllegalStateException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE, 0));
        assertThrows(IllegalStateException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE, 0));

        assertThrows(IllegalStateException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR, 0));
        assertThrows(IllegalStateException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR, 0));

        assertThrows(IllegalStateException.class, () -> mManager.getProperty(NULL_VALUE_PROP, 0));
        assertThrows(IllegalStateException.class,
                () -> mManager.getIntProperty(NULL_VALUE_PROP, 0));

        Truth.assertThat(mManager.getProperty(PROP_CAUSE_STATUS_CODE_TRY_AGAIN, 0)).isNull();
        assertThat(mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_TRY_AGAIN, 0)).isEqualTo(0);

    }

    @Test
    public void testGetterExceptionsEqualAfterR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);

        assertThrows(PropertyAccessDeniedSecurityException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_ACCESS_DENIED, 0));
        assertThrows(PropertyAccessDeniedSecurityException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_ACCESS_DENIED, 0));
        assertThrows(IllegalArgumentException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_INVALID_ARG, 0));
        assertThrows(IllegalArgumentException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_INVALID_ARG, 0));

        assertThrows(PropertyNotAvailableAndRetryException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_TRY_AGAIN, 0));
        assertThrows(PropertyNotAvailableAndRetryException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_TRY_AGAIN, 0));

        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE, 0));
        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE, 0));

        assertThrows(CarInternalErrorException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR, 0));
        assertThrows(CarInternalErrorException.class,
                () -> mManager.getIntProperty(PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR, 0));

        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getProperty(NULL_VALUE_PROP, 0));
        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getIntProperty(NULL_VALUE_PROP, 0));
        assertThrows(IllegalArgumentException.class,
                () -> mManager.getProperty(PROP_UNSUPPORTED, 0));
        assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getIntProperty(NULL_VALUE_PROP, 0));
    }

    @Test
    public void testOnChangeEventWithSameAreaId() throws Exception {
        // init
        TestCallback callback = new TestCallback(/* initValueCount= */ 2, /* changeEventCount= */ 1,
                /* errorEventCount= */ 0);
        mManager.registerCallback(callback, CUSTOM_SEAT_INT_PROP_1, 0);
        callback.assertRegisterCompleted();

        VehiclePropValue firstFakeValueDriveSide = new VehiclePropValue();
        firstFakeValueDriveSide.prop = CUSTOM_SEAT_INT_PROP_1;
        firstFakeValueDriveSide.areaId = DRIVER_SIDE_AREA_ID;
        firstFakeValueDriveSide.value = new RawPropValues();
        firstFakeValueDriveSide.value.int32Values = new int[]{2};
        firstFakeValueDriveSide.timestamp = SystemClock.elapsedRealtimeNanos();
        VehiclePropValue secFakeValueDriveSide = new VehiclePropValue();
        secFakeValueDriveSide.prop = CUSTOM_SEAT_INT_PROP_1;
        secFakeValueDriveSide.areaId = DRIVER_SIDE_AREA_ID;
        secFakeValueDriveSide.value = new RawPropValues();
        secFakeValueDriveSide.value.int32Values = new int[]{3}; // 0 in HAL indicate false;
        secFakeValueDriveSide.timestamp = SystemClock.elapsedRealtimeNanos();
        // inject the new event first
        getAidlMockedVehicleHal().injectEvent(secFakeValueDriveSide);
        // inject the old event
        getAidlMockedVehicleHal().injectEvent(firstFakeValueDriveSide);

        List<CarPropertyValue> events = callback.waitAndGetChangeEvents();

        // Client should only get the new event
        assertThat(events).hasSize(1);
        assertThat(events.get(0).getValue()).isEqualTo(3);

    }

    @Test
    public void testOnChangeEventWithDifferentAreaId() throws Exception {
        // init
        TestCallback callback = new TestCallback(/* initValueCount= */ 2, /* changeEventCount= */ 2,
                /* errorEventCount= */ 0);
        mManager.registerCallback(callback, CUSTOM_SEAT_INT_PROP_2, 0);
        callback.assertRegisterCompleted();
        VehiclePropValue fakeValueDriveSide = new VehiclePropValue();
        fakeValueDriveSide.prop = CUSTOM_SEAT_INT_PROP_2;
        fakeValueDriveSide.areaId = DRIVER_SIDE_AREA_ID;
        fakeValueDriveSide.value = new RawPropValues();
        fakeValueDriveSide.value.int32Values = new int[]{4};
        fakeValueDriveSide.timestamp = SystemClock.elapsedRealtimeNanos();

        VehiclePropValue fakeValuePsgSide = new VehiclePropValue();
        fakeValuePsgSide.prop = CUSTOM_SEAT_INT_PROP_2;
        fakeValuePsgSide.areaId = PASSENGER_SIDE_AREA_ID;
        fakeValuePsgSide.value = new RawPropValues();
        fakeValuePsgSide.value.int32Values = new int[]{5};
        fakeValuePsgSide.timestamp = SystemClock.elapsedRealtimeNanos();

        // inject passenger event before driver event
        getAidlMockedVehicleHal().injectEvent(fakeValuePsgSide);
        getAidlMockedVehicleHal().injectEvent(fakeValueDriveSide);

        List<CarPropertyValue> events = callback.waitAndGetChangeEvents();

        // both events should be received by listener
        assertThat(events).hasSize(2);
        assertThat(events.get(0).getValue()).isEqualTo(5);
        assertThat(events.get(1).getValue()).isEqualTo(4);
    }

    @Test
    public void testOnChangeEventPropErrorStatus() throws Exception {
        // init
        TestCallback callback = new TestCallback(/* initValueCount= */ 2, /* changeEventCount= */ 1,
                /* errorEventCount= */ 0);

        mManager.registerCallback(callback, CUSTOM_SEAT_INT_PROP_1, 0);

        callback.assertRegisterCompleted(/* timeoutMs= */ 1000);

        VehiclePropValue prop = new VehiclePropValue();
        prop.prop = CUSTOM_SEAT_INT_PROP_1;
        prop.areaId = DRIVER_SIDE_AREA_ID;
        prop.value = new RawPropValues();
        prop.status = VehiclePropertyStatus.ERROR;
        prop.timestamp = SystemClock.elapsedRealtimeNanos();

        getAidlMockedVehicleHal().injectEvent(prop);

        List<CarPropertyValue> carPropertyValues = callback.waitAndGetChangeEvents();
        assertThat(carPropertyValues).hasSize(1);
        assertThat(carPropertyValues.get(0).getStatus()).isEqualTo(CarPropertyValue.STATUS_ERROR);
    }

    @Test
    public void testOnChangeEventPropUnavailableStatus() throws Exception {
        // init
        TestCallback callback = new TestCallback(/* initValueCount= */ 2, /* changeEventCount= */ 1,
                /* errorEventCount= */ 0);

        mManager.registerCallback(callback, CUSTOM_SEAT_INT_PROP_1, 0);

        callback.assertRegisterCompleted();

        VehiclePropValue prop = new VehiclePropValue();
        prop.prop = CUSTOM_SEAT_INT_PROP_1;
        prop.areaId = DRIVER_SIDE_AREA_ID;
        prop.value = new RawPropValues();
        prop.status = VehiclePropertyStatus.UNAVAILABLE;
        prop.timestamp = SystemClock.elapsedRealtimeNanos();

        getAidlMockedVehicleHal().injectEvent(prop);

        List<CarPropertyValue> carPropertyValues = callback.waitAndGetChangeEvents();
        assertThat(carPropertyValues).hasSize(1);
        assertThat(carPropertyValues.get(0).getStatus()).isEqualTo(
                CarPropertyValue.STATUS_UNAVAILABLE);
    }

    @Test
    public void testOnChangeEventInvalidPayload() throws Exception {
        // init
        TestCallback callback = new TestCallback(/* initValueCount= */ 2, /* changeEventCount= */ 0,
                /* errorEventCount= */ 0);
        mManager.registerCallback(callback, CUSTOM_SEAT_INT_PROP_1, 0);
        callback.assertRegisterCompleted();

        List<VehiclePropValue> props = new ArrayList<>();
        VehiclePropValue emptyProp = new VehiclePropValue();
        emptyProp.prop = CUSTOM_SEAT_INT_PROP_1;
        props.add(emptyProp);

        VehiclePropValue twoIntsProp = new VehiclePropValue();
        twoIntsProp.prop = CUSTOM_SEAT_INT_PROP_1;
        twoIntsProp.value = new RawPropValues();
        twoIntsProp.value.int32Values = new int[]{0, 1};
        props.add(twoIntsProp);

        VehiclePropValue propWithFloat = new VehiclePropValue();
        propWithFloat.prop = CUSTOM_SEAT_INT_PROP_1;
        propWithFloat.value = new RawPropValues();
        propWithFloat.value.floatValues = new float[]{0f};
        props.add(propWithFloat);

        VehiclePropValue propWithString = new VehiclePropValue();
        propWithString.prop = CUSTOM_SEAT_INT_PROP_1;
        propWithString.value = new RawPropValues();
        propWithString.value.stringValue = "1234";
        props.add(propWithString);

        for (VehiclePropValue prop : props) {
            // inject passenger event before driver event
            getAidlMockedVehicleHal().injectEvent(prop);

            assertThat(callback.getChangeEventCounter()).isEqualTo(0);
        }
    }

    @Test
    public void registerCallback_handlesContinuousPropertyUpdateRate() throws Exception {
        float wheelLeftFrontValue = 11.11f;
        long wheelLeftFrontTimestampNanos = Duration.ofSeconds(1).toNanos();

        float notNewEnoughWheelLeftFrontValue = 22.22f;
        long notNewEnoughWheelLeftFrontTimestampNanos = Duration.ofMillis(1999).toNanos();

        float newEnoughWheelLeftFrontValue = 33.33f;
        long newEnoughWheelLeftFrontTimestampNanos = Duration.ofSeconds(2).toNanos();

        TestCallback callback = new TestCallback(/* initValueCount= */ 4, /* changeEventCount= */ 2,
                /* errorEventCount= */ 0);
        assertThat(mManager.registerCallback(callback, VehiclePropertyIds.TIRE_PRESSURE,
                1f)).isTrue();
        callback.assertRegisterCompleted();

        long currentElapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
        getAidlMockedVehicleHal().injectEvent(
                newTirePressureVehiclePropValue(VehicleAreaWheel.WHEEL_LEFT_FRONT,
                        wheelLeftFrontValue,
                        currentElapsedRealtimeNanos + wheelLeftFrontTimestampNanos));
        getAidlMockedVehicleHal().injectEvent(
                newTirePressureVehiclePropValue(VehicleAreaWheel.WHEEL_LEFT_FRONT,
                        notNewEnoughWheelLeftFrontValue,
                        currentElapsedRealtimeNanos + notNewEnoughWheelLeftFrontTimestampNanos));
        getAidlMockedVehicleHal().injectEvent(
                newTirePressureVehiclePropValue(VehicleAreaWheel.WHEEL_LEFT_FRONT,
                        newEnoughWheelLeftFrontValue,
                        currentElapsedRealtimeNanos + newEnoughWheelLeftFrontTimestampNanos));

        List<CarPropertyValue> carPropertyValues = callback.waitAndGetChangeEvents();
        assertThat(carPropertyValues).hasSize(2);

        assertTirePressureCarPropertyValue(carPropertyValues.get(0),
                VehicleAreaWheel.WHEEL_LEFT_FRONT, wheelLeftFrontValue,
                currentElapsedRealtimeNanos + wheelLeftFrontTimestampNanos);

        assertTirePressureCarPropertyValue(carPropertyValues.get(1),
                VehicleAreaWheel.WHEEL_LEFT_FRONT, newEnoughWheelLeftFrontValue,
                currentElapsedRealtimeNanos + newEnoughWheelLeftFrontTimestampNanos);
    }

    @Test
    public void registerCallback_handlesOutOfTimeOrderEventsWithDifferentAreaIds()
            throws Exception {
        float wheelLeftFrontValue = 11.11f;
        long wheelLeftFrontTimestampNanos = Duration.ofSeconds(4).toNanos();

        float wheelRightFrontValue = 22.22f;
        long wheelRightFrontTimestampNanos = Duration.ofSeconds(3).toNanos();

        float wheelLeftRearValue = 33.33f;
        long wheelLeftRearTimestampNanos = Duration.ofSeconds(2).toNanos();

        float wheelRightRearValue = 44.44f;
        long wheelRightRearTimestampNanos = Duration.ofSeconds(1).toNanos();

        // Initially we have 4 area Ids, so we will have 4 initial values. In the test we will
        // inject 4 events which will generate 4 change events.
        TestCallback callback = new TestCallback(/* initValueCount= */ 4, /* changeEventCount= */ 4,
                /* errorEventCount= */ 0);
        // AidlMockedVehicleHal will not actually genenerate property events for continuous
        // property, so the subscription rate does not matter.
        assertThat(mManager.registerCallback(callback, VehiclePropertyIds.TIRE_PRESSURE, 1f))
                .isTrue();

        callback.assertRegisterCompleted();

        long currentElapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
        // inject events in time order from newest to oldest
        getAidlMockedVehicleHal().injectEvent(
                newTirePressureVehiclePropValue(VehicleAreaWheel.WHEEL_LEFT_FRONT,
                        wheelLeftFrontValue,
                        currentElapsedRealtimeNanos + wheelLeftFrontTimestampNanos));
        getAidlMockedVehicleHal().injectEvent(
                newTirePressureVehiclePropValue(VehicleAreaWheel.WHEEL_RIGHT_FRONT,
                        wheelRightFrontValue,
                        currentElapsedRealtimeNanos + wheelRightFrontTimestampNanos));
        getAidlMockedVehicleHal().injectEvent(
                newTirePressureVehiclePropValue(VehicleAreaWheel.WHEEL_LEFT_REAR,
                        wheelLeftRearValue,
                        currentElapsedRealtimeNanos + wheelLeftRearTimestampNanos));
        getAidlMockedVehicleHal().injectEvent(
                newTirePressureVehiclePropValue(VehicleAreaWheel.WHEEL_RIGHT_REAR,
                        wheelRightRearValue,
                        currentElapsedRealtimeNanos + wheelRightRearTimestampNanos));

        List<CarPropertyValue> carPropertyValues = callback.waitAndGetChangeEvents();
        assertThat(carPropertyValues).hasSize(4);

        assertTirePressureCarPropertyValue(carPropertyValues.get(0),
                VehicleAreaWheel.WHEEL_LEFT_FRONT, wheelLeftFrontValue,
                currentElapsedRealtimeNanos + wheelLeftFrontTimestampNanos);

        assertTirePressureCarPropertyValue(carPropertyValues.get(1),
                VehicleAreaWheel.WHEEL_RIGHT_FRONT, wheelRightFrontValue,
                currentElapsedRealtimeNanos + wheelRightFrontTimestampNanos);

        assertTirePressureCarPropertyValue(carPropertyValues.get(2),
                VehicleAreaWheel.WHEEL_LEFT_REAR, wheelLeftRearValue,
                currentElapsedRealtimeNanos + wheelLeftRearTimestampNanos);

        assertTirePressureCarPropertyValue(carPropertyValues.get(3),
                VehicleAreaWheel.WHEEL_RIGHT_REAR, wheelRightRearValue,
                currentElapsedRealtimeNanos + wheelRightRearTimestampNanos);
    }

    @Test
    public void testGetPropertiesAsync() throws Exception {
        List<GetPropertyRequest> getPropertyRequests = new ArrayList<>();
        Executor callbackExecutor = new HandlerExecutor(mHandler);
        Set<Integer> requestIds = new ArraySet();

        // Regular property.
        GetPropertyRequest vinRequest = mManager.generateGetPropertyRequest(
                VehiclePropertyIds.INFO_VIN, /* areaId= */ 0);
        // Property with area.
        GetPropertyRequest hvacTempDriverRequest = mManager.generateGetPropertyRequest(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET, DRIVER_SIDE_AREA_ID);
        GetPropertyRequest hvacTempPsgRequest = mManager.generateGetPropertyRequest(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET, PASSENGER_SIDE_AREA_ID);

        getPropertyRequests.add(vinRequest);
        getPropertyRequests.add(hvacTempDriverRequest);
        getPropertyRequests.add(hvacTempPsgRequest);

        requestIds.add(vinRequest.getRequestId());
        requestIds.add(hvacTempDriverRequest.getRequestId());
        requestIds.add(hvacTempPsgRequest.getRequestId());

        int resultCount = 3;
        int errorCount = 0;

        int vendorErrorRequestId = 0;

        // A list of properties that will generate error results.
        for (int propId : List.of(
                PROP_VALUE_STATUS_ERROR_INT_ARRAY,
                PROP_VALUE_STATUS_ERROR_BOOLEAN,
                PROP_VALUE_STATUS_UNAVAILABLE_INT,
                PROP_VALUE_STATUS_UNAVAILABLE_FLOAT,
                PROP_CAUSE_STATUS_CODE_TRY_AGAIN,
                PROP_CAUSE_STATUS_CODE_ACCESS_DENIED,
                PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE,
                PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE,
                PROP_CAUSE_STATUS_CODE_INVALID_ARG
            )) {
            GetPropertyRequest errorRequest = mManager.generateGetPropertyRequest(
                    propId, /* areaId= */ 0);
            getPropertyRequests.add(errorRequest);
            requestIds.add(errorRequest.getRequestId());
            errorCount++;
            if (propId == PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE) {
                vendorErrorRequestId = errorRequest.getRequestId();
            }
        }

        GetPropertyRequest unavailableDriverRequest = mManager.generateGetPropertyRequest(
                PROP_VALUE_STATUS_UNAVAILABLE_SEAT, DRIVER_SIDE_AREA_ID);
        getPropertyRequests.add(unavailableDriverRequest);
        requestIds.add(unavailableDriverRequest.getRequestId());
        errorCount++;

        GetPropertyRequest unavailablePsgRequest = mManager.generateGetPropertyRequest(
                PROP_VALUE_STATUS_UNAVAILABLE_SEAT, PASSENGER_SIDE_AREA_ID);
        getPropertyRequests.add(unavailablePsgRequest);
        requestIds.add(unavailablePsgRequest.getRequestId());
        errorCount++;

        TestPropertyAsyncCallback callback = new TestPropertyAsyncCallback(
                requestIds);
        mManager.getPropertiesAsync(getPropertyRequests, /* timeoutInMs= */ 1000,
                /* cancellationSignal= */ null, callbackExecutor, callback);

        // Make the timeout longer than the timeout specified in getPropertiesAsync since the
        // error callback will be delivered after the request timed-out.
        callback.waitAndFinish(/* timeoutInMs= */ 2000);

        assertThat(callback.getTestErrors()).isEmpty();
        List<GetPropertyResult<?>> results = callback.getGetResultList();
        assertThat(results.size()).isEqualTo(resultCount);
        assertThat(callback.getErrorList().size()).isEqualTo(errorCount);
        for (GetPropertyResult<?> result : results) {
            int resultRequestId = result.getRequestId();
            if (resultRequestId == vinRequest.getRequestId()) {
                assertThat(result.getValue().getClass()).isEqualTo(String.class);
                assertThat(result.getValue()).isEqualTo(TEST_VIN);
            } else if (resultRequestId == hvacTempDriverRequest.getRequestId()
                    || resultRequestId == hvacTempPsgRequest.getRequestId()) {
                assertThat(result.getValue().getClass()).isEqualTo(Float.class);
                assertThat(result.getValue()).isEqualTo(INIT_TEMP_VALUE);
            } else {
                Assert.fail("unknown result request Id: " + resultRequestId);
            }
        }
        for (PropertyAsyncError error : callback.getErrorList()) {
            assertThat(error.getErrorCode()).isNotEqualTo(0);
            int propertyId = error.getPropertyId();
            if (propertyId == PROP_VALUE_STATUS_ERROR_INT_ARRAY
                    || propertyId == PROP_VALUE_STATUS_ERROR_BOOLEAN
                    || propertyId == PROP_CAUSE_STATUS_CODE_ACCESS_DENIED
                    || propertyId == PROP_CAUSE_STATUS_CODE_INVALID_ARG) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_INTERNAL_ERROR);
                assertThat(error.getVendorErrorCode()).isEqualTo(0);
            }
            if (propertyId == PROP_VALUE_STATUS_UNAVAILABLE_INT
                    || propertyId == PROP_VALUE_STATUS_UNAVAILABLE_FLOAT
                    || propertyId == PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_NOT_AVAILABLE);
                assertThat(error.getVendorErrorCode()).isEqualTo(0);
            }
            if (propertyId == PROP_CAUSE_STATUS_CODE_TRY_AGAIN) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_TIMEOUT);
                assertThat(error.getVendorErrorCode()).isEqualTo(0);
            }
            if (error.getRequestId() == vendorErrorRequestId) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_INTERNAL_ERROR);
                assertThat(error.getVendorErrorCode()).isEqualTo(VENDOR_CODE_FOR_INTERNAL_ERROR);
            }
        }
    }

    @Test
    public void testSetPropertiesAsync() throws Exception {
        List<SetPropertyRequest<?>> setPropertyRequests = new ArrayList<>();
        Executor callbackExecutor = new HandlerExecutor(mHandler);
        Set<Integer> requestIds = new ArraySet();

        // Global read-write property.
        SetPropertyRequest<Boolean> fuelDoorOpenRequest = mManager.generateSetPropertyRequest(
                VehiclePropertyIds.FUEL_DOOR_OPEN, 0, true);
        // Seat area type read-write property.
        float tempValue1 = 10.1f;
        // This is less than minValue: 10, so it should be set to min value instead.
        float tempValue2 = 9.9f;
        SetPropertyRequest<Float> hvacTempDriverRequest = mManager.generateSetPropertyRequest(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET, DRIVER_SIDE_AREA_ID, tempValue1);
        SetPropertyRequest<Float> hvacTempPsgRequest = mManager.generateSetPropertyRequest(
                VehiclePropertyIds.HVAC_TEMPERATURE_SET, PASSENGER_SIDE_AREA_ID, tempValue2);
        SetPropertyRequest<Long> writeOnlyPropRequest = mManager.generateSetPropertyRequest(
                VehiclePropertyIds.EPOCH_TIME, 0, /* value= */ 1L);
        // Write only property with the default waitForProperty set to true should generate error.
        writeOnlyPropRequest.setWaitForPropertyUpdate(false);

        setPropertyRequests.add(fuelDoorOpenRequest);
        setPropertyRequests.add(hvacTempDriverRequest);
        setPropertyRequests.add(hvacTempPsgRequest);
        setPropertyRequests.add(writeOnlyPropRequest);

        requestIds.add(fuelDoorOpenRequest.getRequestId());
        requestIds.add(hvacTempDriverRequest.getRequestId());
        requestIds.add(hvacTempPsgRequest.getRequestId());
        requestIds.add(writeOnlyPropRequest.getRequestId());

        List<Integer> successPropIds = List.of(
                VehiclePropertyIds.FUEL_DOOR_OPEN,
                VehiclePropertyIds.HVAC_TEMPERATURE_SET,
                VehiclePropertyIds.EPOCH_TIME);

        int resultCount = requestIds.size();
        int errorCount = 0;
        int vendorErrorRequestId = 0;

        // A list of properties that will generate error results.
        List<Integer> errorPropIds = List.of(
                PROP_CAUSE_STATUS_CODE_TRY_AGAIN,
                PROP_CAUSE_STATUS_CODE_ACCESS_DENIED,
                PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE,
                PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE,
                PROP_CAUSE_STATUS_CODE_INVALID_ARG,
                PROP_ERROR_EVENT_NOT_AVAILABLE_DISABLED);
        for (int propId : errorPropIds) {
            SetPropertyRequest<Integer> errorRequest = mManager.generateSetPropertyRequest(
                    propId, /* areaId= */ 0, /* value= */ 1);
            setPropertyRequests.add(errorRequest);
            requestIds.add(errorRequest.getRequestId());
            errorCount++;
            if (propId == PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE) {
                vendorErrorRequestId = errorRequest.getRequestId();
            }
        }

        long startTime = SystemClock.elapsedRealtimeNanos();
        TestPropertyAsyncCallback callback = new TestPropertyAsyncCallback(requestIds);

        mManager.setPropertiesAsync(setPropertyRequests, /* timeoutInMs= */ 1000,
                /* cancellationSignal= */ null, callbackExecutor, callback);

        // Make the timeout longer than the timeout specified in setPropertiesAsync since the
        // error callback will be delivered after the request timed-out.
        callback.waitAndFinish(/* timeoutInMs= */ 2000);

        assertThat(callback.getTestErrors()).isEmpty();
        List<SetPropertyResult> results = callback.getSetResultList();
        assertThat(results.size()).isEqualTo(resultCount);
        assertThat(callback.getErrorList().size()).isEqualTo(errorCount);
        for (SetPropertyResult result : results) {
            assertThat(result.getPropertyId()).isIn(successPropIds);
            if (result.getPropertyId() == VehiclePropertyIds.HVAC_TEMPERATURE_SET) {
                assertThat(result.getAreaId()).isIn(List.of(
                        DRIVER_SIDE_AREA_ID, PASSENGER_SIDE_AREA_ID));
            }
            assertThat(result.getUpdateTimestampNanos()).isGreaterThan(startTime);
        }
        for (PropertyAsyncError error : callback.getErrorList()) {
            int propertyId = error.getPropertyId();
            assertThat(propertyId).isIn(errorPropIds);
            assertThat(error.getAreaId()).isEqualTo(0);
            if (propertyId == PROP_CAUSE_STATUS_CODE_ACCESS_DENIED
                    || propertyId == PROP_CAUSE_STATUS_CODE_INVALID_ARG) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_INTERNAL_ERROR);
                assertThat(error.getVendorErrorCode()).isEqualTo(0);
            }
            if (propertyId == PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE
                    || propertyId == PROP_ERROR_EVENT_NOT_AVAILABLE_DISABLED) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_NOT_AVAILABLE);
                assertThat(error.getVendorErrorCode()).isEqualTo(0);
            }
            if (propertyId == PROP_CAUSE_STATUS_CODE_TRY_AGAIN) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_TIMEOUT);
                assertThat(error.getVendorErrorCode()).isEqualTo(0);
            }
            if (error.getRequestId() == vendorErrorRequestId) {
                assertWithMessage("receive correct error for property ID: " + propertyId)
                        .that(error.getErrorCode()).isEqualTo(STATUS_ERROR_NOT_AVAILABLE);
                assertThat(error.getVendorErrorCode()).isEqualTo(VENDOR_CODE_FOR_NOT_AVAILABLE);
            }
        }
    }

    @Test
    public void testGetVendorErrorCode_forGetProperty_throwsNotAvailable_EqualAfterR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);
        PropertyNotAvailableException thrown = assertThrows(PropertyNotAvailableException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE,
                        /* areaId= */ 0));

        assertThat(thrown.getVendorErrorCode()).isEqualTo(VENDOR_CODE_FOR_NOT_AVAILABLE);
    }

    @Test
    public void testGetVendorErrorCode_forGetProperty_throwsInternalError_EqualAfterR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);
        CarInternalErrorException thrown = assertThrows(CarInternalErrorException.class,
                () -> mManager.getProperty(PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE,
                        /* areaId= */ 0));

        assertThat(thrown.getVendorErrorCode()).isEqualTo(VENDOR_CODE_FOR_INTERNAL_ERROR);
    }

    @Test
    public void testGetVendorErrorCode_forSetProperty_throwsNotAvailable_EqualAfterR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);
        PropertyNotAvailableException thrown = assertThrows(PropertyNotAvailableException.class,
                () -> mManager.setProperty(Integer.class,
                        PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE, /* areaId= */ 0,
                        /* val= */ 0));

        assertThat(thrown.getVendorErrorCode()).isEqualTo(VENDOR_CODE_FOR_NOT_AVAILABLE);
    }

    @Test
    public void testGetVendorErrorCode_forSetProperty_throwsInternalError_EqualAfterR() {
        Truth.assertThat(getContext().getApplicationInfo().targetSdkVersion)
                .isAtLeast(Build.VERSION_CODES.R);
        CarInternalErrorException thrown = assertThrows(CarInternalErrorException.class,
                () -> mManager.setProperty(Integer.class,
                        PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE, /* areaId= */0,
                        /* val= */ 0));

        assertThat(thrown.getVendorErrorCode()).isEqualTo(VENDOR_CODE_FOR_INTERNAL_ERROR);
    }

    @Override
    protected void configureMockedHal() {
        PropertyHandler handler = new PropertyHandler();
        addAidlProperty(CUSTOM_SEAT_MIXED_PROP_ID_1, handler).setConfigArray(CONFIG_ARRAY_1)
                .addAreaConfig(DRIVER_SIDE_AREA_ID).addAreaConfig(PASSENGER_SIDE_AREA_ID);
        addAidlProperty(CUSTOM_GLOBAL_MIXED_PROP_ID_2, handler).setConfigArray(CONFIG_ARRAY_2);
        addAidlProperty(CUSTOM_GLOBAL_MIXED_PROP_ID_3, handler).setConfigArray(CONFIG_ARRAY_3);
        addAidlProperty(CUSTOM_GLOBAL_INT_ARRAY_PROP, handler);

        addAidlProperty(VehicleProperty.TIRE_PRESSURE, handler).addAreaConfig(
                VehicleAreaWheel.WHEEL_LEFT_REAR).addAreaConfig(
                VehicleAreaWheel.WHEEL_RIGHT_REAR).addAreaConfig(
                VehicleAreaWheel.WHEEL_RIGHT_FRONT).addAreaConfig(
                VehicleAreaWheel.WHEEL_LEFT_FRONT).setChangeMode(
                CarPropertyConfig.VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS).setMaxSampleRate(
                10).setMinSampleRate(1);

        VehiclePropValue tempValue = new VehiclePropValue();
        tempValue.value = new RawPropValues();
        tempValue.value.floatValues = new float[]{INIT_TEMP_VALUE};
        tempValue.prop = VehicleProperty.HVAC_TEMPERATURE_SET;
        addAidlProperty(VehicleProperty.HVAC_TEMPERATURE_SET, tempValue)
                .addAreaConfig(DRIVER_SIDE_AREA_ID, /* minValue = */ 10, /* maxValue = */ 20)
                .addAreaConfig(PASSENGER_SIDE_AREA_ID, /* minValue = */ 10, /* maxValue = */ 20);
        VehiclePropValue vinValue = new VehiclePropValue();
        vinValue.value = new RawPropValues();
        vinValue.value.stringValue = TEST_VIN;
        vinValue.prop = VehicleProperty.INFO_VIN;
        addAidlProperty(VehicleProperty.INFO_VIN, vinValue);
        addAidlProperty(VehicleProperty.FUEL_DOOR_OPEN);
        addAidlProperty(VehicleProperty.ANDROID_EPOCH_TIME);

        addAidlProperty(PROP_VALUE_STATUS_ERROR_INT_ARRAY, handler);
        addAidlProperty(PROP_VALUE_STATUS_UNKNOWN_INT_ARRAY, handler);
        addAidlProperty(PROP_VALUE_STATUS_UNAVAILABLE_INT, handler);
        addAidlProperty(PROP_VALUE_STATUS_UNAVAILABLE_FLOAT, handler);
        addAidlProperty(PROP_VALUE_STATUS_ERROR_BOOLEAN, handler);
        addAidlProperty(PROP_VALUE_STATUS_UNAVAILABLE_SEAT, handler)
                .addAreaConfig(DRIVER_SIDE_AREA_ID).addAreaConfig(PASSENGER_SIDE_AREA_ID)
                .setChangeMode(CarPropertyConfig.VEHICLE_PROPERTY_CHANGE_MODE_CONTINUOUS)
                .setMaxSampleRate(10).setMinSampleRate(1);

        addAidlProperty(PROP_CAUSE_STATUS_CODE_ACCESS_DENIED, handler);
        addAidlProperty(PROP_CAUSE_STATUS_CODE_TRY_AGAIN, handler);
        addAidlProperty(PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR, handler);
        addAidlProperty(PROP_CAUSE_STATUS_CODE_INVALID_ARG, handler);
        addAidlProperty(PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE, handler);
        addAidlProperty(PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE, handler);
        addAidlProperty(PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE, handler);

        addAidlProperty(PROP_CAUSE_STATUS_CODE_UNKNOWN, handler);

        addAidlProperty(CUSTOM_SEAT_INT_PROP_1, handler).addAreaConfig(DRIVER_SIDE_AREA_ID)
                .addAreaConfig(PASSENGER_SIDE_AREA_ID);
        addAidlProperty(CUSTOM_SEAT_INT_PROP_2, handler).addAreaConfig(DRIVER_SIDE_AREA_ID)
                .addAreaConfig(PASSENGER_SIDE_AREA_ID);

        addAidlProperty(NULL_VALUE_PROP, handler);
        addAidlProperty(PROP_UNSUPPORTED, handler);
        addAidlProperty(PROP_ERROR_EVENT_NOT_AVAILABLE_DISABLED, handler);

        // Add properties for permission testing.
        addAidlProperty(SUPPORT_CUSTOM_PERMISSION, handler).setConfigArray(
                VENDOR_PERMISSION_CONFIG);
        addAidlProperty(PROP_WITH_READ_ONLY_PERMISSION, handler);
        addAidlProperty(PROP_WITH_WRITE_ONLY_PERMISSION, handler);

        addAidlProperty(PROP_UNSUPPORTED, handler);
    }

    private class PropertyHandler implements VehicleHalPropertyHandler {
        SparseArray<SparseArray<VehiclePropValue>> mValueByAreaIdByPropId = new SparseArray<>();

        @Override
        public synchronized boolean onPropertySet2(VehiclePropValue value) {
            // Simulate VehicleHal.set() behavior.
            if (value.prop == PROP_ERROR_EVENT_NOT_AVAILABLE_DISABLED) {
                injectErrorEvent(PROP_ERROR_EVENT_NOT_AVAILABLE_DISABLED, /* areaId= */ 0,
                        VehicleHalStatusCode.STATUS_NOT_AVAILABLE_DISABLED);
                // Don't generate property change event.
                return false;
            }

            int statusCode = mapPropertyToVhalStatusCode(value.prop);
            if (statusCode != VehicleHalStatusCode.STATUS_OK) {
                // The ServiceSpecificException here would pass the statusCode back to caller.
                throw new ServiceSpecificException(statusCode);
            }

            int areaId = value.areaId;
            int propId = value.prop;
            if (mValueByAreaIdByPropId.get(propId) == null) {
                mValueByAreaIdByPropId.put(propId, new SparseArray<>());
            }
            mValueByAreaIdByPropId.get(propId).put(areaId, value);
            return true;
        }

        @Override
        public synchronized VehiclePropValue onPropertyGet(VehiclePropValue value) {
            // Simulate VehicleHal.get() behavior.
            int vhalStatusCode = mapPropertyToVhalStatusCode(value.prop);
            if (vhalStatusCode != VehicleHalStatusCode.STATUS_OK) {
                // The ServiceSpecificException here would pass the statusCode back to caller.
                throw new ServiceSpecificException(vhalStatusCode);
            }

            if (value.prop == NULL_VALUE_PROP) {
                // Return null to simulate an unavailable property.
                // HAL implementation should return STATUS_TRY_AGAIN when a property is unavailable,
                // however, it may also return null with STATUS_OKAY, and we want to handle this
                // properly.
                return null;
            }

            VehiclePropValue returnValue = new VehiclePropValue();
            returnValue.prop = value.prop;
            returnValue.areaId = value.areaId;
            returnValue.timestamp = SystemClock.elapsedRealtimeNanos();
            returnValue.value = new RawPropValues();
            int propertyStatus = mapPropertyToVehiclePropertyStatus(value.prop);
            if (propertyStatus != VehiclePropertyStatus.AVAILABLE) {
                returnValue.status = propertyStatus;
                return returnValue;
            }
            if (mValueByAreaIdByPropId.get(value.prop) == null) {
                return null;
            }
            return mValueByAreaIdByPropId.get(value.prop).get(value.areaId);
        }

        @Override
        public synchronized void onPropertySubscribe(int property, float sampleRate) {
            Log.d(TAG, "onPropertySubscribe property "
                    + property + " sampleRate " + sampleRate);
        }

        @Override
        public synchronized void onPropertyUnsubscribe(int property) {
            Log.d(TAG, "onPropertyUnSubscribe property " + property);
        }
    }

    private static String propToString(int propertyId) {
        return VehiclePropertyIds.toString(propertyId) + " (" + propertyId + ")";
    }

    private static int mapPropertyToVhalStatusCode(int propId) {
        switch (propId) {
            case PROP_CAUSE_STATUS_CODE_TRY_AGAIN:
                return VehicleHalStatusCode.STATUS_TRY_AGAIN;
            case PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE:
                return VehicleHalStatusCode.STATUS_NOT_AVAILABLE;
            case PROP_CAUSE_STATUS_CODE_ACCESS_DENIED:
                return VehicleHalStatusCode.STATUS_ACCESS_DENIED;
            case PROP_CAUSE_STATUS_CODE_INVALID_ARG:
                return VehicleHalStatusCode.STATUS_INVALID_ARG;
            case PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR:
                return VehicleHalStatusCode.STATUS_INTERNAL_ERROR;
            case PROP_CAUSE_STATUS_CODE_UNKNOWN:
                return -1;
            case PROP_CAUSE_STATUS_CODE_INTERNAL_ERROR_WITH_VENDOR_CODE:
                return INTERNAL_ERROR_WITH_VENDOR_CODE;
            case PROP_CAUSE_STATUS_CODE_NOT_AVAILABLE_WITH_VENDOR_CODE:
                return NOT_AVAILABLE_WITH_VENDOR_CODE;
            default:
                return VehicleHalStatusCode.STATUS_OK;
        }
    }

    private static int mapPropertyToVehiclePropertyStatus(int propId) {
        switch (propId) {
            case PROP_VALUE_STATUS_ERROR_INT_ARRAY:
            case PROP_VALUE_STATUS_ERROR_BOOLEAN:
                return VehiclePropertyStatus.ERROR;
            case PROP_VALUE_STATUS_UNAVAILABLE_INT:
            case PROP_VALUE_STATUS_UNAVAILABLE_FLOAT:
                return VehiclePropertyStatus.UNAVAILABLE;
            case PROP_VALUE_STATUS_UNKNOWN_INT_ARRAY:
                return -1;
            default:
                return VehiclePropertyStatus.AVAILABLE;
        }
    }

    private static VehiclePropValue newTirePressureVehiclePropValue(int areaId, float floatValue,
            long timestampNanos) {
        VehiclePropValue vehiclePropValue = new VehiclePropValue();
        vehiclePropValue.prop = VehiclePropertyIds.TIRE_PRESSURE;
        vehiclePropValue.areaId = areaId;
        vehiclePropValue.value = new RawPropValues();
        vehiclePropValue.value.floatValues = new float[]{floatValue};
        vehiclePropValue.timestamp = timestampNanos;
        return vehiclePropValue;
    }

    private static void assertTirePressureCarPropertyValue(CarPropertyValue<?> carPropertyValue,
            int areaId, float floatValue, long timestampNanos) {
        assertThat(carPropertyValue.getPropertyId()).isEqualTo(VehiclePropertyIds.TIRE_PRESSURE);
        assertThat(carPropertyValue.getAreaId()).isEqualTo(areaId);
        assertThat(carPropertyValue.getStatus()).isEqualTo(CarPropertyValue.STATUS_AVAILABLE);
        assertThat(carPropertyValue.getTimestamp()).isEqualTo(timestampNanos);
        assertThat(carPropertyValue.getValue()).isEqualTo(floatValue);
    }

    private static class TestCallback implements CarPropertyManager.CarPropertyEventCallback {
        private static final String CALLBACK_TAG = "ErrorEventTest";

        private final int mInitValueCount;
        private final int mChangeEventCount;
        private final int mErrorEventCount;
        private CountDownLatch mInitialValueCdLatch;
        private CountDownLatch mChangeEventCdLatch;
        private CountDownLatch mErrorEventCdLatch;

        private final Object mLock = new Object();
        private final List<CarPropertyValue> mChangeEvents = new ArrayList<>();
        private final List<CarPropertyValue> mInitialValues = new ArrayList<>();
        private Integer mErrorCode;

        TestCallback(int initValueCount, int changeEventCount, int errorEventCount) {
            mInitValueCount = initValueCount;
            mChangeEventCount = changeEventCount;
            mErrorEventCount = errorEventCount;
            // We expect to receive one initial event for each area.
            mInitialValueCdLatch = new CountDownLatch(mInitValueCount);
            mChangeEventCdLatch = new CountDownLatch(mChangeEventCount);
            mErrorEventCdLatch = new CountDownLatch(mErrorEventCount);
        }

        @Override
        public void onChangeEvent(CarPropertyValue carPropertyValue) {
            Log.d(CALLBACK_TAG, "onChangeEvent: " + carPropertyValue);
            synchronized (mLock) {
                if (mInitialValueCdLatch.getCount() > 0) {
                    mInitialValueCdLatch.countDown();
                    mInitialValues.add(carPropertyValue);
                } else {
                    mChangeEventCdLatch.countDown();
                    mChangeEvents.add(carPropertyValue);
                }
            }
        }

        @Override
        public void onErrorEvent(int propId, int areaId) {
            Log.d(CALLBACK_TAG, "onErrorEvent, propId: " + propId + " areaId: " + areaId);
            synchronized (mLock) {
                mErrorEventCdLatch.countDown();
            }
        }

        @Override
        public void onErrorEvent(int propId, int areaId, int errorCode) {
            Log.d(CALLBACK_TAG, "onErrorEvent, propId: " + propId + " areaId: " + areaId
                    + "errorCode: " + errorCode);
            synchronized (mLock) {
                mErrorCode = errorCode;
                mErrorEventCdLatch.countDown();
            }
        }

        public Integer getErrorCode() {
            synchronized (mLock) {
                return mErrorCode;
            }
        }

        public void assertOnErrorEventCalled() throws InterruptedException {
            if (!mErrorEventCdLatch.await(CALLBACK_SHORT_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
                long got = mErrorEventCount - mErrorEventCdLatch.getCount();
                throw new IllegalStateException("Does not receive enough error events before  "
                        + CALLBACK_SHORT_TIMEOUT_MS + " ms, got: " + got
                        + ", expected: " + mErrorEventCount);
            }
        }

        public void assertOnErrorEventNotCalled() throws InterruptedException {
            if (mErrorEventCdLatch.await(CALLBACK_SHORT_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
                long got = mErrorEventCount - mErrorEventCdLatch.getCount();
                throw new IllegalStateException("Receive more error events than expected after  "
                        + CALLBACK_SHORT_TIMEOUT_MS + " ms, got: " + got
                        + ", expected less than: " + mErrorEventCount);
            }
        }

        public void assertRegisterCompleted() throws InterruptedException {
            assertRegisterCompleted(CALLBACK_SHORT_TIMEOUT_MS);
        }

        public void assertRegisterCompleted(int timeoutMs) throws InterruptedException {
            if (!mInitialValueCdLatch.await(timeoutMs, TimeUnit.MILLISECONDS)) {
                long got = mInitValueCount - mInitialValueCdLatch.getCount();
                throw new IllegalStateException("Does not receive enough initial value events "
                        + "before  " + CALLBACK_SHORT_TIMEOUT_MS + " ms, got: " + got
                        + ", expected: " + mInitValueCount);
            }
        }

        public int getChangeEventCounter() {
            synchronized (mLock) {
                return mChangeEvents.size();
            }
        }

        public List<CarPropertyValue> waitAndGetChangeEvents() throws InterruptedException {
            if (!mChangeEventCdLatch.await(CALLBACK_SHORT_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
                long got = mChangeEventCount - mChangeEventCdLatch.getCount();
                throw new IllegalStateException("Does not receive enough property events before  "
                        + CALLBACK_SHORT_TIMEOUT_MS + " ms, got: " + got
                        + ", expected: " + mChangeEventCount);
            }
            synchronized (mLock) {
                return mChangeEvents;
            }
        }

        public List<CarPropertyValue> getInitialValues() {
            synchronized (mLock) {
                return mInitialValues;
            }
        }
    }

    // This is almost the same as {@link android.os.HandlerExecutor} except that it will not throw
    // exception even if the underlying handler is already shut down.
    private static class HandlerExecutor implements Executor {
        private final Handler mHandler;

        HandlerExecutor(@NonNull Handler handler) {
            mHandler = handler;
        }

        @Override
        public void execute(Runnable command) {
            mHandler.post(command);
        }
    }

}