From 67e91107c6829b7fd96ca631e68b19809d964394 Mon Sep 17 00:00:00 2001 From: "Harpreet \\\"Eli\\\" Sangha" Date: Fri, 27 Sep 2019 19:00:46 +0900 Subject: [PATCH] vibrator: Async Callback API VTS Tests Bug: 136220871 Test: VTS Tests Change-Id: Icd8f794df76542c9f74e3ea762117da703db47d4 Signed-off-by: Harpreet \"Eli\" Sangha --- vibrator/1.4/vts/functional/Android.bp | 30 ++++ .../VtsHalVibratorV1_4TargetTest.cpp | 170 ++++++++++++++++++ 2 files changed, 200 insertions(+) create mode 100644 vibrator/1.4/vts/functional/Android.bp create mode 100644 vibrator/1.4/vts/functional/VtsHalVibratorV1_4TargetTest.cpp diff --git a/vibrator/1.4/vts/functional/Android.bp b/vibrator/1.4/vts/functional/Android.bp new file mode 100644 index 0000000000..4cdf3b66a7 --- /dev/null +++ b/vibrator/1.4/vts/functional/Android.bp @@ -0,0 +1,30 @@ +// +// 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. +// + +cc_test { + name: "VtsHalVibratorV1_4TargetTest", + defaults: ["VtsHalTargetTestDefaults"], + srcs: ["VtsHalVibratorV1_4TargetTest.cpp"], + static_libs: [ + "android.hardware.vibrator@1.0", + "android.hardware.vibrator@1.1", + "android.hardware.vibrator@1.2", + "android.hardware.vibrator@1.3", + "android.hardware.vibrator@1.4", + ], + test_suites: ["general-tests"], +} + diff --git a/vibrator/1.4/vts/functional/VtsHalVibratorV1_4TargetTest.cpp b/vibrator/1.4/vts/functional/VtsHalVibratorV1_4TargetTest.cpp new file mode 100644 index 0000000000..b51cc96942 --- /dev/null +++ b/vibrator/1.4/vts/functional/VtsHalVibratorV1_4TargetTest.cpp @@ -0,0 +1,170 @@ +/* + * 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. + */ + +#define LOG_TAG "vibrator_hidl_hal_test" + +#include +#include +#include +#include +#include +#include +#include + +#include + +using ::android::sp; +using ::android::hardware::hidl_bitfield; +using ::android::hardware::hidl_enum_range; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::vibrator::V1_0::EffectStrength; +using ::android::hardware::vibrator::V1_0::Status; +using ::android::hardware::vibrator::V1_3::Effect; +using ::android::hardware::vibrator::V1_4::Capabilities; +using ::android::hardware::vibrator::V1_4::IVibrator; +using ::android::hardware::vibrator::V1_4::IVibratorCallback; + +#define EXPECT_OK(ret) ASSERT_TRUE((ret).isOk()) + +class CompletionCallback : public IVibratorCallback { + public: + CompletionCallback(std::function callback) : mCallback(callback) {} + Return onComplete() override { + mCallback(); + return Void(); + } + + private: + std::function mCallback; +}; + +class VibratorHidlTest_1_4 : public testing::TestWithParam { + public: + virtual void SetUp() override { + vibrator = IVibrator::getService(GetParam()); + ASSERT_NE(vibrator, nullptr); + capabilities = vibrator->getCapabilities(); + } + + virtual void TearDown() override {} + + sp vibrator; + hidl_bitfield capabilities; +}; + +TEST_P(VibratorHidlTest_1_4, OnWithCallback) { + if (capabilities & Capabilities::ON_COMPLETION_CALLBACK) { + std::promise completionPromise; + std::future completionFuture{completionPromise.get_future()}; + sp callback = + new CompletionCallback([&completionPromise] { completionPromise.set_value(); }); + uint32_t duration = 250; + std::chrono::milliseconds timeout{duration * 2}; + EXPECT_EQ(Status::OK, vibrator->on_1_4(duration, callback)); + EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); + vibrator->off(); + } +} + +static void validatePerformEffectUnsupportedOperation(Status status, uint32_t lengthMs) { + ASSERT_EQ(Status::UNSUPPORTED_OPERATION, status); + ASSERT_EQ(static_cast(0), lengthMs) + << "Effects that return UNSUPPORTED_OPERATION must have a duration of zero"; +} + +static void validatePerformEffect(Status status, uint32_t lengthMs) { + ASSERT_TRUE(status == Status::OK || status == Status::UNSUPPORTED_OPERATION); + if (status == Status::OK) { + ASSERT_LT(static_cast(0), lengthMs) + << "Effects that return OK must return a positive duration"; + } else { + validatePerformEffectUnsupportedOperation(status, lengthMs); + } +} + +/* + * Test to make sure effects within the valid range return are either supported and return OK with + * a valid duration, or are unsupported and return UNSUPPORTED_OPERATION with a duration of 0. + */ +TEST_P(VibratorHidlTest_1_4, PerformEffect_1_4) { + Status performStatus; + uint32_t performLength; + auto validateWrapper = [&](Status status, uint32_t lengthMs) { + performStatus = status; + performLength = lengthMs; + validatePerformEffect(status, lengthMs); + }; + for (const auto& effect : hidl_enum_range()) { + for (const auto& strength : hidl_enum_range()) { + std::promise completionPromise; + std::future completionFuture{completionPromise.get_future()}; + sp callback = + new CompletionCallback([&completionPromise] { completionPromise.set_value(); }); + EXPECT_OK(vibrator->perform_1_4(effect, strength, callback, validateWrapper)); + if (performStatus == Status::OK && + (capabilities & Capabilities::PERFORM_COMPLETION_CALLBACK)) { + std::chrono::milliseconds timeout{performLength * 2}; + EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); + } + } + } +} + +/* + * Test to make sure effect values above the valid range are rejected. + */ +TEST_P(VibratorHidlTest_1_4, PerformEffect_1_4_BadEffects_AboveValidRange) { + Effect effect = *std::prev(hidl_enum_range().end()); + Effect badEffect = static_cast(static_cast(effect) + 1); + EXPECT_OK(vibrator->perform_1_4(badEffect, EffectStrength::LIGHT, nullptr, + validatePerformEffectUnsupportedOperation)); +} + +/* + * Test to make sure effect values below the valid range are rejected. + */ +TEST_P(VibratorHidlTest_1_4, PerformEffect_1_4_BadEffects_BelowValidRange) { + Effect effect = *hidl_enum_range().begin(); + Effect badEffect = static_cast(static_cast(effect) - 1); + EXPECT_OK(vibrator->perform_1_4(badEffect, EffectStrength::LIGHT, nullptr, + validatePerformEffectUnsupportedOperation)); +} + +/* + * Test to make sure strength values above the valid range are rejected. + */ +TEST_P(VibratorHidlTest_1_4, PerformEffect_1_4_BadStrength_AboveValidRange) { + EffectStrength strength = *std::prev(hidl_enum_range().end()); + EffectStrength badStrength = static_cast(static_cast(strength) + 1); + EXPECT_OK(vibrator->perform_1_4(Effect::THUD, badStrength, nullptr, + validatePerformEffectUnsupportedOperation)); +} + +/* + * Test to make sure strength values below the valid range are rejected. + */ +TEST_P(VibratorHidlTest_1_4, PerformEffect_1_4_BadStrength_BelowValidRange) { + EffectStrength strength = *hidl_enum_range().begin(); + EffectStrength badStrength = static_cast(static_cast(strength) - 1); + EXPECT_OK(vibrator->perform_1_4(Effect::THUD, badStrength, nullptr, + validatePerformEffectUnsupportedOperation)); +} + +INSTANTIATE_TEST_SUITE_P( + PerInstance, VibratorHidlTest_1_4, + testing::ValuesIn(android::hardware::getAllHalInstanceNames(IVibrator::descriptor)), + android::hardware::PrintInstanceNameToString);