| /* |
| * Copyright 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "AnimationModuleTests" |
| |
| #include "AnimationModule.h" |
| #include "MathHelp.h" |
| |
| #include <android/hardware/automotive/vehicle/2.0/IVehicle.h> |
| #include <gtest/gtest.h> |
| #include <map> |
| |
| namespace android { |
| namespace hardware { |
| namespace automotive { |
| namespace sv { |
| namespace V1_0 { |
| namespace implementation { |
| namespace { |
| |
| std::map<std::string, CarPart> getSampleCarPartsMap() { |
| std::vector<std::string> carFrameChildPartIds{"front_left_door", "front_right_door", |
| "front_left_blinker", "front_right_blinker", |
| "sun_roof"}; |
| |
| android_auto::surround_view::CarPart frame(std::vector<CarVertex>(), |
| android_auto::surround_view::CarMaterial(), |
| gMat4Identity, "root", carFrameChildPartIds); |
| |
| android_auto::surround_view::CarPart frameChild(std::vector<CarVertex>(), |
| android_auto::surround_view::CarMaterial(), |
| gMat4Identity, "frame", |
| std::vector<std::string>()); |
| |
| std::map<std::string, CarPart> sampleCarParts; |
| sampleCarParts.emplace(std::make_pair("frame", frame)); |
| sampleCarParts.emplace(std::make_pair("front_left_door", frameChild)); |
| sampleCarParts.emplace(std::make_pair("front_right_door", frameChild)); |
| sampleCarParts.emplace(std::make_pair("front_left_blinker", frameChild)); |
| sampleCarParts.emplace(std::make_pair("front_right_blinker", frameChild)); |
| sampleCarParts.emplace(std::make_pair("sun_roof", frameChild)); |
| return sampleCarParts; |
| } |
| |
| std::vector<AnimationInfo> getSampleAnimations() { |
| AnimationInfo frameAnimation = AnimationInfo{ |
| .partId = "frame", |
| .parentId = "root", |
| .pose = gMat4Identity, |
| }; |
| |
| RotationOp frontLeftDoorRotationOp = |
| RotationOp{.vhalProperty = (int64_t)(0x0200 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | VehicleArea::DOOR) |
| << 32 | |
| (int64_t)(VehicleArea::DOOR), |
| .type = AnimationType::ROTATION_ANGLE, |
| .axis = |
| RotationAxis{ |
| .axisVector = std::array<float, 3>{0.0f, 0.0f, 1.0f}, |
| .rotationPoint = std::array<float, 3>{-1.0f, 0.5f, 0.0f}, |
| }, |
| .animationTime = 2000, |
| .rotationRange = |
| Range{ |
| .start = 0.0f, |
| .end = 90.0f, |
| }, |
| .vhalRange = Range{ |
| .start = 0.0f, |
| .end = (float)INT32_MAX, |
| }}; |
| |
| std::map<uint64_t, std::vector<RotationOp>> frontLeftDoorRotationOpsMap; |
| |
| frontLeftDoorRotationOpsMap.emplace( |
| std::make_pair(frontLeftDoorRotationOp.vhalProperty, |
| std::vector<RotationOp>{frontLeftDoorRotationOp})); |
| |
| AnimationInfo frontLeftDoorAnimation = AnimationInfo{ |
| .partId = "front_left_door", |
| .parentId = "frame", |
| .pose = gMat4Identity, |
| .rotationOpsMap = frontLeftDoorRotationOpsMap, |
| }; |
| |
| RotationOp frontRightDoorRotationOp = |
| RotationOp{.vhalProperty = (int64_t)(0x0201 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | VehicleArea::DOOR) |
| << 32 | |
| (int64_t)(VehicleArea::DOOR), |
| .type = AnimationType::ROTATION_ANGLE, |
| .axis = |
| RotationAxis{ |
| .axisVector = std::array<float, 3>{0.0f, 0.0f, 1.0f}, |
| .rotationPoint = std::array<float, 3>{1.0f, 0.5f, 0.0f}, |
| }, |
| .animationTime = 2000, |
| .rotationRange = |
| Range{ |
| .start = 0.0f, |
| .end = -90.0f, |
| }, |
| .vhalRange = Range{ |
| .start = 0.0f, |
| .end = (float)INT32_MAX, |
| }}; |
| |
| std::map<uint64_t, std::vector<RotationOp>> frontRightDoorRotationOpsMap; |
| |
| frontRightDoorRotationOpsMap.emplace( |
| std::make_pair(frontRightDoorRotationOp.vhalProperty, |
| std::vector<RotationOp>{frontRightDoorRotationOp})); |
| |
| AnimationInfo frontRightDoorAnimation = AnimationInfo{ |
| .partId = "front_right_door", |
| .parentId = "frame", |
| .pose = gMat4Identity, |
| .rotationOpsMap = frontRightDoorRotationOpsMap, |
| }; |
| |
| GammaOp frontLeftBlinkerGammaOp = GammaOp{ |
| .vhalProperty = (int64_t)(0x0300 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | VehicleArea::GLOBAL) |
| << 32 | |
| (int64_t)(VehicleArea::GLOBAL), |
| .type = AnimationType::ADJUST_GAMMA_REPEAT, |
| .animationTime = 1000, |
| .gammaRange = |
| Range{ |
| .start = 1.0f, |
| .end = 0.5f, |
| }, |
| .vhalRange = |
| Range{ |
| .start = 0.0f, |
| .end = (float)INT32_MAX, |
| }, |
| }; |
| |
| std::map<uint64_t, std::vector<GammaOp>> frontLeftBlinkerGammaOpsMap; |
| |
| frontLeftBlinkerGammaOpsMap.emplace( |
| std::make_pair(frontLeftBlinkerGammaOp.vhalProperty, |
| std::vector<GammaOp>{frontLeftBlinkerGammaOp})); |
| |
| AnimationInfo frontLeftBlinkerAnimation = AnimationInfo{ |
| .partId = "front_left_blinker", |
| .parentId = "frame", |
| .pose = gMat4Identity, |
| .gammaOpsMap = frontLeftBlinkerGammaOpsMap, |
| }; |
| |
| GammaOp frontRightBlinkerGammaOp = GammaOp{ |
| .vhalProperty = (int64_t)(0x0301 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | VehicleArea::GLOBAL) |
| << 32 | |
| (int64_t)(VehicleArea::GLOBAL), |
| .type = AnimationType::ADJUST_GAMMA_REPEAT, |
| .animationTime = 1000, |
| .gammaRange = |
| Range{ |
| .start = 1.0f, |
| .end = 0.5f, |
| }, |
| .vhalRange = |
| Range{ |
| .start = 0.0f, |
| .end = (float)INT32_MAX, |
| }, |
| }; |
| |
| std::map<uint64_t, std::vector<GammaOp>> frontRightBlinkerGammaOpsMap; |
| |
| frontRightBlinkerGammaOpsMap.emplace( |
| std::make_pair(frontRightBlinkerGammaOp.vhalProperty, |
| std::vector<GammaOp>{frontRightBlinkerGammaOp})); |
| |
| AnimationInfo frontRightBlinkerAnimation = AnimationInfo{ |
| .partId = "front_right_blinker", |
| .parentId = "frame", |
| .pose = gMat4Identity, |
| .gammaOpsMap = frontRightBlinkerGammaOpsMap, |
| }; |
| |
| TranslationOp sunRoofTranslationOp = TranslationOp{ |
| .vhalProperty = (int64_t)(0x0400 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | VehicleArea::GLOBAL) |
| << 32 | |
| (int64_t)(VehicleArea::GLOBAL), |
| .type = AnimationType::TRANSLATION, |
| .direction = std::array<float, 3>{0.0f, -1.0f, 0.0f}, |
| .animationTime = 3000, |
| .translationRange = |
| Range{ |
| .start = 0.0f, |
| .end = 0.5f, |
| }, |
| .vhalRange = |
| Range{ |
| .start = 0.0f, |
| .end = (float)INT32_MAX, |
| }, |
| }; |
| |
| std::map<uint64_t, std::vector<TranslationOp>> sunRoofRotationOpsMap; |
| sunRoofRotationOpsMap.emplace(std::make_pair(sunRoofTranslationOp.vhalProperty, |
| std::vector<TranslationOp>{sunRoofTranslationOp})); |
| |
| AnimationInfo sunRoofAnimation = AnimationInfo{ |
| .partId = "sun_roof", |
| .parentId = "frame", |
| .pose = gMat4Identity, |
| .translationOpsMap = sunRoofRotationOpsMap, |
| }; |
| |
| return std::vector<AnimationInfo>{frameAnimation, |
| frontLeftDoorAnimation, |
| frontRightDoorAnimation, |
| frontLeftBlinkerAnimation, |
| frontRightBlinkerAnimation, |
| sunRoofAnimation}; |
| } |
| |
| TEST(AnimationModuleTests, EmptyVhalSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| std::vector<AnimationParam> result = |
| animationModule.getUpdatedAnimationParams(std::vector<VehiclePropValue>()); |
| EXPECT_EQ(result.size(), 0); |
| } |
| |
| TEST(AnimationModuleTests, LeftDoorAnimationOnceSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::DOOR, |
| .prop = 0x0200 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::DOOR, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| |
| TEST(AnimationModuleTests, LeftDoorAnimationTenTimesSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| for (int i = 0; i < 10; ++i) { |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::DOOR, |
| .prop = 0x0200 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::DOOR, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| } |
| |
| TEST(AnimationModuleTests, RightDoorAnimationOnceSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::DOOR, |
| .prop = 0x0201 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::DOOR, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| |
| TEST(AnimationModuleTests, RightDoorAnimationTenTimesSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| for (int i = 0; i < 10; ++i) { |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::DOOR, |
| .prop = 0x0201 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::DOOR, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| } |
| |
| TEST(AnimationModuleTests, LeftBlinkerAnimationOnceSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0300 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| |
| TEST(AnimationModuleTests, LeftBlinkerAnimationTenTimesSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| for (int i = 0; i < 10; ++i) { |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0300 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| } |
| |
| TEST(AnimationModuleTests, RightBlinkerAnimationOnceSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0301 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| |
| TEST(AnimationModuleTests, RightBlinkerAnimationTenTimesSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| for (int i = 0; i < 10; ++i) { |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0301 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| } |
| |
| TEST(AnimationModuleTests, SunRoofAnimationOnceSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0400 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| |
| TEST(AnimationModuleTests, SunRoofAnimationTenTimesSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| for (int i = 0; i < 10; ++i) { |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0400 | VehiclePropertyGroup::SYSTEM | VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 1); |
| } |
| } |
| |
| TEST(AnimationModuleTests, All5PartsAnimationOnceSuccess) { |
| AnimationModule animationModule(getSampleCarPartsMap(), std::map<std::string, CarTexture>(), |
| getSampleAnimations()); |
| std::vector<AnimationParam> result = animationModule.getUpdatedAnimationParams( |
| std::vector<VehiclePropValue>{VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::DOOR, |
| .prop = 0x0200 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | |
| VehicleArea::DOOR, |
| .value.int32Values = |
| std::vector<int32_t>(1, INT32_MAX), |
| }, |
| VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::DOOR, |
| .prop = 0x0201 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | |
| VehicleArea::DOOR, |
| .value.int32Values = |
| std::vector<int32_t>(1, INT32_MAX), |
| }, |
| VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0300 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = |
| std::vector<int32_t>(1, INT32_MAX), |
| }, |
| VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0301 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = |
| std::vector<int32_t>(1, INT32_MAX), |
| }, |
| VehiclePropValue{ |
| .areaId = (int32_t)VehicleArea::GLOBAL, |
| .prop = 0x0400 | VehiclePropertyGroup::SYSTEM | |
| VehiclePropertyType::INT32 | |
| VehicleArea::GLOBAL, |
| .value.int32Values = |
| std::vector<int32_t>(1, INT32_MAX), |
| }}); |
| EXPECT_EQ(result.size(), 5); |
| } |
| |
| } // namespace |
| } // namespace implementation |
| } // namespace V1_0 |
| } // namespace sv |
| } // namespace automotive |
| } // namespace hardware |
| } // namespace android |
