From af8a2f9394e8c5a2125a342a77f8d86d0f3e56bc Mon Sep 17 00:00:00 2001 From: Brian Duddie Date: Fri, 14 Feb 2020 15:39:19 -0800 Subject: [PATCH 1/2] Run clang-format on context hub 1.0 VTS Test: n/a Change-Id: I80eb0a7c0b722ede4ed84087a7b5e4ed318e5fd5 --- .../VtsHalContexthubV1_0TargetTest.cpp | 310 +++++++++--------- 1 file changed, 146 insertions(+), 164 deletions(-) diff --git a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp index a1d173bc32..83e12aed3a 100644 --- a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp +++ b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp @@ -30,10 +30,11 @@ #include #include -using ::android::hardware::Return; -using ::android::hardware::Void; +using ::android::sp; using ::android::hardware::hidl_string; using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; using ::android::hardware::contexthub::V1_0::AsyncEventType; using ::android::hardware::contexthub::V1_0::ContextHub; using ::android::hardware::contexthub::V1_0::ContextHubMsg; @@ -43,7 +44,6 @@ using ::android::hardware::contexthub::V1_0::IContexthubCallback; using ::android::hardware::contexthub::V1_0::NanoAppBinary; using ::android::hardware::contexthub::V1_0::Result; using ::android::hardware::contexthub::V1_0::TransactionResult; -using ::android::sp; #define ASSERT_OK(result) ASSERT_EQ(result, Result::OK) #define EXPECT_OK(result) EXPECT_EQ(result, Result::OK) @@ -56,24 +56,23 @@ constexpr uint64_t kNonExistentAppId = 0x476f6f6754555555; // Helper that does explicit conversion of an enum class to its underlying/base // type. Useful for stream output of enum values. -template -constexpr typename std::underlying_type::type asBaseType( - EnumType value) { - return static_cast::type>(value); +template +constexpr typename std::underlying_type::type asBaseType(EnumType value) { + return static_cast::type>(value); } // Synchronously queries IContexthub::getHubs() and returns the result hidl_vec getHubsSync(sp hubApi) { - hidl_vec hubList; - std::promise barrier; + hidl_vec hubList; + std::promise barrier; - hubApi->getHubs([&hubList, &barrier](const hidl_vec& hubs) { - hubList = hubs; - barrier.set_value(); - }); - barrier.get_future().wait_for(std::chrono::seconds(1)); + hubApi->getHubs([&hubList, &barrier](const hidl_vec& hubs) { + hubList = hubs; + barrier.set_value(); + }); + barrier.get_future().wait_for(std::chrono::seconds(1)); - return hubList; + return hubList; } // Gets a list of valid hub IDs in the system @@ -119,62 +118,58 @@ class ContexthubHidlTest : public ::testing::TestWithParam handleClientMsg(const ContextHubMsg& /*msg*/) override { - ALOGD("Got client message callback"); - return Void(); - } + public: + virtual Return handleClientMsg(const ContextHubMsg& /*msg*/) override { + ALOGD("Got client message callback"); + return Void(); + } - virtual Return handleTxnResult( - uint32_t txnId, TransactionResult result) override { - ALOGD("Got transaction result callback for txnId %" PRIu32 " with result %" - PRId32, txnId, result); - return Void(); - } + virtual Return handleTxnResult(uint32_t txnId, TransactionResult result) override { + ALOGD("Got transaction result callback for txnId %" PRIu32 " with result %" PRId32, txnId, + result); + return Void(); + } - virtual Return handleHubEvent(AsyncEventType evt) override { - ALOGD("Got hub event callback for event type %" PRIu32, evt); - return Void(); - } + virtual Return handleHubEvent(AsyncEventType evt) override { + ALOGD("Got hub event callback for event type %" PRIu32, evt); + return Void(); + } - virtual Return handleAppAbort(uint64_t appId, uint32_t abortCode) - override { - ALOGD("Got app abort notification for appId 0x%" PRIx64 " with abort code " - "0x%" PRIx32, appId, abortCode); - return Void(); - } + virtual Return handleAppAbort(uint64_t appId, uint32_t abortCode) override { + ALOGD("Got app abort notification for appId 0x%" PRIx64 + " with abort code " + "0x%" PRIx32, + appId, abortCode); + return Void(); + } - virtual Return handleAppsInfo(const hidl_vec& /*appInfo*/) - override { - ALOGD("Got app info callback"); - return Void(); - } + virtual Return handleAppsInfo(const hidl_vec& /*appInfo*/) override { + ALOGD("Got app info callback"); + return Void(); + } }; // Wait for a callback to occur (signaled by the given future) up to the // provided timeout. If the future is invalid or the callback does not come // within the given time, returns false. -template -bool waitForCallback( - std::future future, - ReturnType *result, - std::chrono::milliseconds timeout = std::chrono::seconds(5)) { - auto expiration = std::chrono::system_clock::now() + timeout; +template +bool waitForCallback(std::future future, ReturnType* result, + std::chrono::milliseconds timeout = std::chrono::seconds(5)) { + auto expiration = std::chrono::system_clock::now() + timeout; - EXPECT_NE(result, nullptr); - EXPECT_TRUE(future.valid()); - if (result != nullptr && future.valid()) { - std::future_status status = future.wait_until(expiration); - EXPECT_NE(status, std::future_status::timeout) - << "Timed out waiting for callback"; + EXPECT_NE(result, nullptr); + EXPECT_TRUE(future.valid()); + if (result != nullptr && future.valid()) { + std::future_status status = future.wait_until(expiration); + EXPECT_NE(status, std::future_status::timeout) << "Timed out waiting for callback"; - if (status == std::future_status::ready) { - *result = future.get(); - return true; + if (status == std::future_status::ready) { + *result = future.get(); + return true; + } } - } - return false; + return false; } // Ensures that the metadata reported in getHubs() is sane @@ -199,169 +194,156 @@ TEST_P(ContexthubHidlTest, TestGetHubs) { } TEST_P(ContexthubHidlTest, TestRegisterCallback) { - ALOGD("TestRegisterCallback called, hubId %" PRIu32, getHubId()); - ASSERT_OK(registerCallback(new ContexthubCallbackBase())); + ALOGD("TestRegisterCallback called, hubId %" PRIu32, getHubId()); + ASSERT_OK(registerCallback(new ContexthubCallbackBase())); } TEST_P(ContexthubHidlTest, TestRegisterNullCallback) { - ALOGD("TestRegisterNullCallback called, hubId %" PRIu32, getHubId()); - ASSERT_OK(registerCallback(nullptr)); + ALOGD("TestRegisterNullCallback called, hubId %" PRIu32, getHubId()); + ASSERT_OK(registerCallback(nullptr)); } // Helper callback that puts the async appInfo callback data into a promise class QueryAppsCallback : public ContexthubCallbackBase { - public: - virtual Return handleAppsInfo(const hidl_vec& appInfo) - override { - ALOGD("Got app info callback with %zu apps", appInfo.size()); - promise.set_value(appInfo); - return Void(); - } + public: + virtual Return handleAppsInfo(const hidl_vec& appInfo) override { + ALOGD("Got app info callback with %zu apps", appInfo.size()); + promise.set_value(appInfo); + return Void(); + } - std::promise> promise; + std::promise> promise; }; // Calls queryApps() and checks the returned metadata TEST_P(ContexthubHidlTest, TestQueryApps) { - ALOGD("TestQueryApps called, hubId %u", getHubId()); - sp cb = new QueryAppsCallback(); - ASSERT_OK(registerCallback(cb)); + ALOGD("TestQueryApps called, hubId %u", getHubId()); + sp cb = new QueryAppsCallback(); + ASSERT_OK(registerCallback(cb)); - Result result = hubApi->queryApps(getHubId()); - ASSERT_OK(result); + Result result = hubApi->queryApps(getHubId()); + ASSERT_OK(result); - ALOGD("Waiting for app info callback"); - hidl_vec appList; - ASSERT_TRUE(waitForCallback(cb->promise.get_future(), &appList)); - for (const HubAppInfo &appInfo : appList) { - EXPECT_NE(appInfo.appId, UINT64_C(0)); - EXPECT_NE(appInfo.appId, kNonExistentAppId); - } + ALOGD("Waiting for app info callback"); + hidl_vec appList; + ASSERT_TRUE(waitForCallback(cb->promise.get_future(), &appList)); + for (const HubAppInfo& appInfo : appList) { + EXPECT_NE(appInfo.appId, UINT64_C(0)); + EXPECT_NE(appInfo.appId, kNonExistentAppId); + } } // Helper callback that puts the TransactionResult for the expectedTxnId into a // promise class TxnResultCallback : public ContexthubCallbackBase { - public: - virtual Return handleTxnResult( - uint32_t txnId, TransactionResult result) override { - ALOGD("Got transaction result callback for txnId %" PRIu32 " (expecting %" - PRIu32 ") with result %" PRId32, txnId, expectedTxnId, result); - if (txnId == expectedTxnId) { - promise.set_value(result); + public: + virtual Return handleTxnResult(uint32_t txnId, TransactionResult result) override { + ALOGD("Got transaction result callback for txnId %" PRIu32 " (expecting %" PRIu32 + ") with result %" PRId32, + txnId, expectedTxnId, result); + if (txnId == expectedTxnId) { + promise.set_value(result); + } + return Void(); } - return Void(); - } - uint32_t expectedTxnId = 0; - std::promise promise; + uint32_t expectedTxnId = 0; + std::promise promise; }; // Parameterized fixture that sets the callback to TxnResultCallback class ContexthubTxnTest : public ContexthubHidlTest { - public: - virtual void SetUp() override { - ContexthubHidlTest::SetUp(); - ASSERT_OK(registerCallback(cb)); - } + public: + virtual void SetUp() override { + ContexthubHidlTest::SetUp(); + ASSERT_OK(registerCallback(cb)); + } - sp cb = new TxnResultCallback(); + sp cb = new TxnResultCallback(); }; - // Checks cases where the hub implementation is expected to return an error, but // that error can be returned either synchronously or in the asynchronous // transaction callback. Returns an AssertionResult that can be used in // ASSERT/EXPECT_TRUE. Allows checking the sync result against 1 additional // allowed error code apart from OK and TRANSACTION_FAILED, which are always // allowed. -::testing::AssertionResult checkFailureSyncOrAsync( - Result result, Result allowedSyncResult, - std::future&& future) { - if (result == Result::OK) { - // No error reported synchronously - this is OK, but then we should get an - // async callback with a failure status - TransactionResult asyncResult; - if (!waitForCallback(std::forward>(future), - &asyncResult)) { - return ::testing::AssertionFailure() - << "Got successful sync result, then failed to receive async cb"; - } else if (asyncResult == TransactionResult::SUCCESS) { - return ::testing::AssertionFailure() - << "Got successful sync result, then unexpected successful async " - "result"; +::testing::AssertionResult checkFailureSyncOrAsync(Result result, Result allowedSyncResult, + std::future&& future) { + if (result == Result::OK) { + // No error reported synchronously - this is OK, but then we should get an + // async callback with a failure status + TransactionResult asyncResult; + if (!waitForCallback(std::forward>(future), &asyncResult)) { + return ::testing::AssertionFailure() + << "Got successful sync result, then failed to receive async cb"; + } else if (asyncResult == TransactionResult::SUCCESS) { + return ::testing::AssertionFailure() + << "Got successful sync result, then unexpected successful async " + "result"; + } + } else if (result != allowedSyncResult && result != Result::TRANSACTION_FAILED) { + return ::testing::AssertionFailure() + << "Got sync result " << asBaseType(result) << ", expected TRANSACTION_FAILED or " + << asBaseType(allowedSyncResult); } - } else if (result != allowedSyncResult && - result != Result::TRANSACTION_FAILED) { - return ::testing::AssertionFailure() << "Got sync result " - << asBaseType(result) << ", expected TRANSACTION_FAILED or " - << asBaseType(allowedSyncResult); - } - return ::testing::AssertionSuccess(); + return ::testing::AssertionSuccess(); } TEST_P(ContexthubTxnTest, TestSendMessageToNonExistentNanoApp) { - ContextHubMsg msg; - msg.appName = kNonExistentAppId; - msg.msgType = 1; - msg.msg.resize(4); - std::fill(msg.msg.begin(), msg.msg.end(), 0); + ContextHubMsg msg; + msg.appName = kNonExistentAppId; + msg.msgType = 1; + msg.msg.resize(4); + std::fill(msg.msg.begin(), msg.msg.end(), 0); - ALOGD("Sending message to non-existent nanoapp"); - Result result = hubApi->sendMessageToHub(getHubId(), msg); - if (result != Result::OK && - result != Result::BAD_PARAMS && - result != Result::TRANSACTION_FAILED) { - FAIL() << "Got result " << asBaseType(result) << ", expected OK, BAD_PARAMS" - << ", or TRANSACTION_FAILED"; - } + ALOGD("Sending message to non-existent nanoapp"); + Result result = hubApi->sendMessageToHub(getHubId(), msg); + if (result != Result::OK && result != Result::BAD_PARAMS && + result != Result::TRANSACTION_FAILED) { + FAIL() << "Got result " << asBaseType(result) << ", expected OK, BAD_PARAMS" + << ", or TRANSACTION_FAILED"; + } } TEST_P(ContexthubTxnTest, TestLoadEmptyNanoApp) { - cb->expectedTxnId = 0123; - NanoAppBinary emptyApp; + cb->expectedTxnId = 0123; + NanoAppBinary emptyApp; - emptyApp.appId = kNonExistentAppId; - emptyApp.appVersion = 1; - emptyApp.flags = 0; - emptyApp.targetChreApiMajorVersion = 1; - emptyApp.targetChreApiMinorVersion = 0; + emptyApp.appId = kNonExistentAppId; + emptyApp.appVersion = 1; + emptyApp.flags = 0; + emptyApp.targetChreApiMajorVersion = 1; + emptyApp.targetChreApiMinorVersion = 0; - ALOGD("Loading empty nanoapp"); - Result result = hubApi->loadNanoApp(getHubId(), emptyApp, cb->expectedTxnId); - EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, - cb->promise.get_future())); + ALOGD("Loading empty nanoapp"); + Result result = hubApi->loadNanoApp(getHubId(), emptyApp, cb->expectedTxnId); + EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future())); } TEST_P(ContexthubTxnTest, TestUnloadNonexistentNanoApp) { - cb->expectedTxnId = 1234; + cb->expectedTxnId = 1234; - ALOGD("Unloading nonexistent nanoapp"); - Result result = hubApi->unloadNanoApp(getHubId(), kNonExistentAppId, - cb->expectedTxnId); - EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, - cb->promise.get_future())); + ALOGD("Unloading nonexistent nanoapp"); + Result result = hubApi->unloadNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId); + EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future())); } TEST_P(ContexthubTxnTest, TestEnableNonexistentNanoApp) { - cb->expectedTxnId = 2345; + cb->expectedTxnId = 2345; - ALOGD("Enabling nonexistent nanoapp"); - Result result = hubApi->enableNanoApp(getHubId(), kNonExistentAppId, - cb->expectedTxnId); - EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, - cb->promise.get_future())); + ALOGD("Enabling nonexistent nanoapp"); + Result result = hubApi->enableNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId); + EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future())); } TEST_P(ContexthubTxnTest, TestDisableNonexistentNanoApp) { - cb->expectedTxnId = 3456; + cb->expectedTxnId = 3456; - ALOGD("Disabling nonexistent nanoapp"); - Result result = hubApi->disableNanoApp(getHubId(), kNonExistentAppId, - cb->expectedTxnId); - EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, - cb->promise.get_future())); + ALOGD("Disabling nonexistent nanoapp"); + Result result = hubApi->disableNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId); + EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future())); } // Return the test parameters of a vecter of tuples for all IContexthub services and each of its hub From 01eb01a230f58f985119733118b0d6f06835cd63 Mon Sep 17 00:00:00 2001 From: Brian Duddie Date: Fri, 14 Feb 2020 15:35:57 -0800 Subject: [PATCH 2/2] Add VTS tests for Context Hub HAL 1.1 Extract some common functionality and add a new test for the newly-added method in HAL v1.1. Bug: 135951924 Test: atest VtsHalContexthubV1_0TargetTest \ VtsHalContexthubV1_1TargetTest Change-Id: I1cd335d4972bc3242245b2379a7cfa42d1c683a6 --- .../compatibility_matrix.current.xml | 2 +- contexthub/1.0/vts/functional/Android.bp | 5 +- .../VtsHalContexthubV1_0TargetTest.cpp | 129 ++---------------- contexthub/1.1/vts/functional/Android.bp | 30 ++++ contexthub/1.1/vts/functional/OWNERS | 8 ++ .../VtsHalContexthubV1_1TargetTest.cpp | 60 ++++++++ contexthub/common/vts/Android.bp | 30 ++++ .../common/vts/ContexthubCallbackBase.h | 63 +++++++++ .../common/vts/ContexthubHidlTestBase.h | 53 +++++++ contexthub/common/vts/OWNERS | 8 ++ .../common/vts/VtsHalContexthubUtils.cpp | 47 +++++++ contexthub/common/vts/VtsHalContexthubUtils.h | 70 ++++++++++ 12 files changed, 387 insertions(+), 118 deletions(-) create mode 100644 contexthub/1.1/vts/functional/Android.bp create mode 100644 contexthub/1.1/vts/functional/OWNERS create mode 100644 contexthub/1.1/vts/functional/VtsHalContexthubV1_1TargetTest.cpp create mode 100644 contexthub/common/vts/Android.bp create mode 100644 contexthub/common/vts/ContexthubCallbackBase.h create mode 100644 contexthub/common/vts/ContexthubHidlTestBase.h create mode 100644 contexthub/common/vts/OWNERS create mode 100644 contexthub/common/vts/VtsHalContexthubUtils.cpp create mode 100644 contexthub/common/vts/VtsHalContexthubUtils.h diff --git a/compatibility_matrices/compatibility_matrix.current.xml b/compatibility_matrices/compatibility_matrix.current.xml index f8cec640cc..9100f18765 100644 --- a/compatibility_matrices/compatibility_matrix.current.xml +++ b/compatibility_matrices/compatibility_matrix.current.xml @@ -153,7 +153,7 @@ android.hardware.contexthub - 1.0 + 1.0-1 IContexthub default diff --git a/contexthub/1.0/vts/functional/Android.bp b/contexthub/1.0/vts/functional/Android.bp index 9e99c334bc..d51c9669c8 100644 --- a/contexthub/1.0/vts/functional/Android.bp +++ b/contexthub/1.0/vts/functional/Android.bp @@ -18,7 +18,10 @@ cc_test { name: "VtsHalContexthubV1_0TargetTest", defaults: ["VtsHalTargetTestDefaults"], srcs: ["VtsHalContexthubV1_0TargetTest.cpp"], - static_libs: ["android.hardware.contexthub@1.0"], + static_libs: [ + "android.hardware.contexthub@1.0", + "VtsHalContexthubUtils", + ], test_suites: [ "general-tests", "vts-core", diff --git a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp index 83e12aed3a..ada232b9fc 100644 --- a/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp +++ b/contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp @@ -16,6 +16,10 @@ #define LOG_TAG "contexthub_hidl_hal_test" +#include "ContexthubCallbackBase.h" +#include "ContexthubHidlTestBase.h" +#include "VtsHalContexthubUtils.h" + #include #include #include @@ -23,7 +27,6 @@ #include #include #include -#include #include #include @@ -44,9 +47,11 @@ using ::android::hardware::contexthub::V1_0::IContexthubCallback; using ::android::hardware::contexthub::V1_0::NanoAppBinary; using ::android::hardware::contexthub::V1_0::Result; using ::android::hardware::contexthub::V1_0::TransactionResult; - -#define ASSERT_OK(result) ASSERT_EQ(result, Result::OK) -#define EXPECT_OK(result) EXPECT_EQ(result, Result::OK) +using ::android::hardware::contexthub::vts_utils::asBaseType; +using ::android::hardware::contexthub::vts_utils::ContexthubCallbackBase; +using ::android::hardware::contexthub::vts_utils::ContexthubHidlTestBase; +using ::android::hardware::contexthub::vts_utils::getHalAndHubIdList; +using ::android::hardware::contexthub::vts_utils::getHubsSync; namespace { @@ -54,100 +59,10 @@ namespace { // app ID is reserved and must never appear in the list of loaded apps. constexpr uint64_t kNonExistentAppId = 0x476f6f6754555555; -// Helper that does explicit conversion of an enum class to its underlying/base -// type. Useful for stream output of enum values. -template -constexpr typename std::underlying_type::type asBaseType(EnumType value) { - return static_cast::type>(value); -} +const std::vector> kTestParameters = + getHalAndHubIdList(); -// Synchronously queries IContexthub::getHubs() and returns the result -hidl_vec getHubsSync(sp hubApi) { - hidl_vec hubList; - std::promise barrier; - - hubApi->getHubs([&hubList, &barrier](const hidl_vec& hubs) { - hubList = hubs; - barrier.set_value(); - }); - barrier.get_future().wait_for(std::chrono::seconds(1)); - - return hubList; -} - -// Gets a list of valid hub IDs in the system -std::vector getHubIds(const std::string& service_name) { - std::vector hubIds; - - sp hubApi = IContexthub::getService(service_name); - - if (hubApi != nullptr) { - for (const ContextHub& hub : getHubsSync(hubApi)) { - hubIds.push_back(std::to_string(hub.hubId)); - } - } - - ALOGD("Running tests against all %zu reported hubs for service %s", hubIds.size(), - service_name.c_str()); - return hubIds; -} - -// Test fixture parameterized by hub ID, initializes the HAL and makes the context hub API handle -// available. -class ContexthubHidlTest : public ::testing::TestWithParam> { - public: - virtual void SetUp() override { - hubApi = IContexthub::getService(std::get<0>(GetParam())); - ASSERT_NE(hubApi, nullptr); - - // getHubs() must be called at least once for proper initialization of the - // HAL implementation - getHubsSync(hubApi); - } - - uint32_t getHubId() { return std::stoi(std::get<1>(GetParam())); } - - Result registerCallback(sp cb) { - Result result = hubApi->registerCallback(getHubId(), cb); - ALOGD("Registered callback, result %" PRIu32, result); - return result; - } - - sp hubApi; -}; - -// Base callback implementation that just logs all callbacks by default -class ContexthubCallbackBase : public IContexthubCallback { - public: - virtual Return handleClientMsg(const ContextHubMsg& /*msg*/) override { - ALOGD("Got client message callback"); - return Void(); - } - - virtual Return handleTxnResult(uint32_t txnId, TransactionResult result) override { - ALOGD("Got transaction result callback for txnId %" PRIu32 " with result %" PRId32, txnId, - result); - return Void(); - } - - virtual Return handleHubEvent(AsyncEventType evt) override { - ALOGD("Got hub event callback for event type %" PRIu32, evt); - return Void(); - } - - virtual Return handleAppAbort(uint64_t appId, uint32_t abortCode) override { - ALOGD("Got app abort notification for appId 0x%" PRIx64 - " with abort code " - "0x%" PRIx32, - appId, abortCode); - return Void(); - } - - virtual Return handleAppsInfo(const hidl_vec& /*appInfo*/) override { - ALOGD("Got app info callback"); - return Void(); - } -}; +class ContexthubHidlTest : public ContexthubHidlTestBase {}; // Wait for a callback to occur (signaled by the given future) up to the // provided timeout. If the future is invalid or the callback does not come @@ -174,7 +89,7 @@ bool waitForCallback(std::future future, ReturnType* result, // Ensures that the metadata reported in getHubs() is sane TEST_P(ContexthubHidlTest, TestGetHubs) { - hidl_vec hubs = getHubsSync(hubApi); + hidl_vec hubs = getHubsSync(hubApi.get()); ALOGD("System reports %zu hubs", hubs.size()); for (const ContextHub& hub : hubs) { @@ -346,24 +261,6 @@ TEST_P(ContexthubTxnTest, TestDisableNonexistentNanoApp) { EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future())); } -// Return the test parameters of a vecter of tuples for all IContexthub services and each of its hub -// id: -static std::vector> get_parameters() { - std::vector> parameters; - std::vector service_names = - android::hardware::getAllHalInstanceNames(IContexthub::descriptor); - for (const std::string& service_name : service_names) { - std::vector ids = getHubIds(service_name); - for (const std::string& id : ids) { - parameters.push_back(std::make_tuple(service_name, id)); - } - } - - return parameters; -} - -static std::vector> kTestParameters = get_parameters(); - INSTANTIATE_TEST_SUITE_P(HubIdSpecificTests, ContexthubHidlTest, testing::ValuesIn(kTestParameters), android::hardware::PrintInstanceTupleNameToString<>); diff --git a/contexthub/1.1/vts/functional/Android.bp b/contexthub/1.1/vts/functional/Android.bp new file mode 100644 index 0000000000..f1625a6b6b --- /dev/null +++ b/contexthub/1.1/vts/functional/Android.bp @@ -0,0 +1,30 @@ +// +// Copyright (C) 2020 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +cc_test { + name: "VtsHalContexthubV1_1TargetTest", + defaults: ["VtsHalTargetTestDefaults"], + srcs: ["VtsHalContexthubV1_1TargetTest.cpp"], + static_libs: [ + "android.hardware.contexthub@1.0", + "android.hardware.contexthub@1.1", + "VtsHalContexthubUtils", + ], + test_suites: [ + "general-tests", + "vts-core", + ], +} diff --git a/contexthub/1.1/vts/functional/OWNERS b/contexthub/1.1/vts/functional/OWNERS new file mode 100644 index 0000000000..161b2f069d --- /dev/null +++ b/contexthub/1.1/vts/functional/OWNERS @@ -0,0 +1,8 @@ +#Context Hub team +arthuri@google.com +bduddie@google.com +stange@google.com + +#VTS team +dshi@google.com +trong@google.com diff --git a/contexthub/1.1/vts/functional/VtsHalContexthubV1_1TargetTest.cpp b/contexthub/1.1/vts/functional/VtsHalContexthubV1_1TargetTest.cpp new file mode 100644 index 0000000000..f2fcdfca48 --- /dev/null +++ b/contexthub/1.1/vts/functional/VtsHalContexthubV1_1TargetTest.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "contexthub_hidl_hal_test" + +#include "ContexthubCallbackBase.h" +#include "ContexthubHidlTestBase.h" +#include "VtsHalContexthubUtils.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using ::android::hardware::contexthub::V1_1::IContexthub; +using ::android::hardware::contexthub::V1_1::Setting; +using ::android::hardware::contexthub::V1_1::SettingValue; +using ::android::hardware::contexthub::vts_utils::ContexthubCallbackBase; +using ::android::hardware::contexthub::vts_utils::ContexthubHidlTestBase; +using ::android::hardware::contexthub::vts_utils::getHalAndHubIdList; + +namespace { + +const std::vector> kTestParameters = + getHalAndHubIdList(); + +class ContexthubHidlTest : public ContexthubHidlTestBase {}; + +TEST_P(ContexthubHidlTest, TestOnSettingChanged) { + // In VTS, we only test that sending the values doesn't cause things to blow up - other test + // suites verify the expected E2E behavior in CHRE + ASSERT_OK(registerCallback(new ContexthubCallbackBase())); + hubApi->onSettingChanged(Setting::LOCATION, SettingValue::DISABLED); + hubApi->onSettingChanged(Setting::LOCATION, SettingValue::ENABLED); + ASSERT_OK(registerCallback(nullptr)); +} + +INSTANTIATE_TEST_SUITE_P(HubIdSpecificTests, ContexthubHidlTest, testing::ValuesIn(kTestParameters), + android::hardware::PrintInstanceTupleNameToString<>); + +} // anonymous namespace diff --git a/contexthub/common/vts/Android.bp b/contexthub/common/vts/Android.bp new file mode 100644 index 0000000000..3d5196a70e --- /dev/null +++ b/contexthub/common/vts/Android.bp @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +cc_test_library { + name: "VtsHalContexthubUtils", + srcs: [ + "VtsHalContexthubUtils.cpp", + ], + export_include_dirs: ["."], + shared_libs: [ + "android.hardware.contexthub@1.0", + "libhardware", + "libhidlbase", + "liblog", + "libutils", + ], +} diff --git a/contexthub/common/vts/ContexthubCallbackBase.h b/contexthub/common/vts/ContexthubCallbackBase.h new file mode 100644 index 0000000000..124a11601a --- /dev/null +++ b/contexthub/common/vts/ContexthubCallbackBase.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#pragma once + +#include +#include + +#include + +namespace android { +namespace hardware { +namespace contexthub { +namespace vts_utils { + +// Base callback implementation that just logs all callbacks by default, but +// records a failure if +class ContexthubCallbackBase : public V1_0::IContexthubCallback { + public: + virtual Return handleClientMsg(const V1_0::ContextHubMsg& /*msg*/) override { + ALOGD("Got client message callback"); + return Void(); + } + + virtual Return handleTxnResult(uint32_t txnId, V1_0::TransactionResult result) override { + ALOGD("Got transaction result callback for txnId %" PRIu32 " with result %" PRId32, txnId, + result); + return Void(); + } + + virtual Return handleHubEvent(V1_0::AsyncEventType evt) override { + ALOGD("Got hub event callback for event type %" PRIu32, evt); + return Void(); + } + + virtual Return handleAppAbort(uint64_t appId, uint32_t abortCode) override { + ALOGD("Got app abort notification for appId 0x%" PRIx64 " with abort code 0x%" PRIx32, + appId, abortCode); + return Void(); + } + + virtual Return handleAppsInfo(const hidl_vec& /*appInfo*/) override { + ALOGD("Got app info callback"); + return Void(); + } +}; + +} // namespace vts_utils +} // namespace contexthub +} // namespace hardware +} // namespace android diff --git a/contexthub/common/vts/ContexthubHidlTestBase.h b/contexthub/common/vts/ContexthubHidlTestBase.h new file mode 100644 index 0000000000..ee5b7d3cd5 --- /dev/null +++ b/contexthub/common/vts/ContexthubHidlTestBase.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#pragma once + +#include +#include + +#include +#include + +namespace android { +namespace hardware { +namespace contexthub { +namespace vts_utils { + +// Base fixture for Context Hub HAL tests. Parameterized by service name and hub ID. +template +class ContexthubHidlTestBase + : public ::testing::TestWithParam> { + public: + virtual void SetUp() override { fetchHubApi(); } + + void fetchHubApi() { + hubApi = IContexthubVersion::getService(std::get<0>(GetParam())); + ASSERT_NE(hubApi, nullptr); + } + + uint32_t getHubId() { return std::stoi(std::get<1>(GetParam())); } + + V1_0::Result registerCallback(sp cb) { + return hubApi->registerCallback(getHubId(), cb); + } + + sp hubApi; +}; + +} // namespace vts_utils +} // namespace contexthub +} // namespace hardware +} // namespace android diff --git a/contexthub/common/vts/OWNERS b/contexthub/common/vts/OWNERS new file mode 100644 index 0000000000..161b2f069d --- /dev/null +++ b/contexthub/common/vts/OWNERS @@ -0,0 +1,8 @@ +#Context Hub team +arthuri@google.com +bduddie@google.com +stange@google.com + +#VTS team +dshi@google.com +trong@google.com diff --git a/contexthub/common/vts/VtsHalContexthubUtils.cpp b/contexthub/common/vts/VtsHalContexthubUtils.cpp new file mode 100644 index 0000000000..5033b416c9 --- /dev/null +++ b/contexthub/common/vts/VtsHalContexthubUtils.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "VtsHalContexthubUtils.h" + +#include +#include + +namespace android { +namespace hardware { +namespace contexthub { +namespace vts_utils { + +using ::android::hardware::contexthub::V1_0::ContextHub; +using ::android::hardware::contexthub::V1_0::IContexthub; + +// Synchronously queries IContexthub::getHubs() and returns the result +hidl_vec getHubsSync(IContexthub* hubApi) { + hidl_vec hubList; + std::promise barrier; + + hubApi->getHubs([&hubList, &barrier](const hidl_vec& hubs) { + hubList = hubs; + barrier.set_value(); + }); + barrier.get_future().wait_for(std::chrono::seconds(1)); + + return hubList; +} + +} // namespace vts_utils +} // namespace contexthub +} // namespace hardware +} // namespace android diff --git a/contexthub/common/vts/VtsHalContexthubUtils.h b/contexthub/common/vts/VtsHalContexthubUtils.h new file mode 100644 index 0000000000..8f9b6946d9 --- /dev/null +++ b/contexthub/common/vts/VtsHalContexthubUtils.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#pragma once + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace android { +namespace hardware { +namespace contexthub { +namespace vts_utils { + +#define ASSERT_OK(result) ASSERT_EQ(result, ::android::hardware::contexthub::V1_0::Result::OK) +#define EXPECT_OK(result) EXPECT_EQ(result, ::android::hardware::contexthub::V1_0::Result::OK) + +// Helper that does explicit conversion of an enum class to its underlying/base +// type. Useful for stream output of enum values. +template +inline constexpr typename std::underlying_type::type asBaseType(EnumType value) { + return static_cast::type>(value); +} + +// Synchronously queries IContexthub::getHubs() and returns the result +hidl_vec getHubsSync(V1_0::IContexthub* hubApi); + +// Create a vector of tuples that include each IContexthub service paired with each hub ID it +// exposes via getHubs(). Each tuple represents a test target that we should run the VTS suite +// against. +template +static std::vector> getHalAndHubIdList() { + std::vector> parameters; + std::vector serviceNames = + ::android::hardware::getAllHalInstanceNames(IContexthubVersion::descriptor); + for (const std::string& serviceName : serviceNames) { + sp hubApi = IContexthubVersion::getService(serviceName); + if (hubApi != nullptr) { + hidl_vec hubs = getHubsSync(hubApi.get()); + for (const V1_0::ContextHub& hub : hubs) { + parameters.push_back(std::make_tuple(serviceName, std::to_string(hub.hubId))); + } + } + } + + return parameters; +} + +} // namespace vts_utils +} // namespace contexthub +} // namespace hardware +} // namespace android