tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
platform_hardware_interfaces/contexthub/aidl/vts/VtsAidlHalContextHubTargetTest.cpp
Rocky Fang 781409825d Ignore NanSessionStateChange test for old HAL 
Test: Tested on V1 HAL, before this change, it failed. After this
change, it showed ignored.
Bug: 287400067

Change-Id: I171cfd08da97d0b5830d241a9cd6ce2fa1f899dc
2023-06-16 00:42:41 +00:00

416 lines
15 KiB
C++
Raw Blame History

/*
* Copyright (C) 2021 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 <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include "VtsHalContexthubUtilsCommon.h"
#include <android/hardware/contexthub/BnContextHub.h>
#include <android/hardware/contexthub/BnContextHubCallback.h>
#include <android/hardware/contexthub/IContextHub.h>
#include <android/hardware/contexthub/IContextHubCallback.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <log/log.h>
#include <cinttypes>
#include <future>
using ::android::ProcessState;
using ::android::sp;
using ::android::String16;
using ::android::binder::Status;
using ::android::hardware::contexthub::AsyncEventType;
using ::android::hardware::contexthub::ContextHubInfo;
using ::android::hardware::contexthub::ContextHubMessage;
using ::android::hardware::contexthub::HostEndpointInfo;
using ::android::hardware::contexthub::IContextHub;
using ::android::hardware::contexthub::IContextHubCallbackDefault;
using ::android::hardware::contexthub::NanoappBinary;
using ::android::hardware::contexthub::NanoappInfo;
using ::android::hardware::contexthub::NanoappRpcService;
using ::android::hardware::contexthub::NanSessionRequest;
using ::android::hardware::contexthub::NanSessionStateUpdate;
using ::android::hardware::contexthub::Setting;
using ::android::hardware::contexthub::vts_utils::kNonExistentAppId;
using ::android::hardware::contexthub::vts_utils::waitForCallback;
class ContextHubAidl : public testing::TestWithParam<std::tuple<std::string, int32_t>> {
public:
virtual void SetUp() override {
contextHub = android::waitForDeclaredService<IContextHub>(
String16(std::get<0>(GetParam()).c_str()));
ASSERT_NE(contextHub, nullptr);
}
uint32_t getHubId() { return std::get<1>(GetParam()); }
void testSettingChanged(Setting setting);
sp<IContextHub> contextHub;
};
TEST_P(ContextHubAidl, TestGetHubs) {
std::vector<ContextHubInfo> hubs;
ASSERT_TRUE(contextHub->getContextHubs(&hubs).isOk());
ALOGD("System reports %zu hubs", hubs.size());
for (const ContextHubInfo& hub : hubs) {
ALOGD("Checking hub ID %" PRIu32, hub.id);
EXPECT_GT(hub.name.size(), 0);
EXPECT_GT(hub.vendor.size(), 0);
EXPECT_GT(hub.toolchain.size(), 0);
EXPECT_GT(hub.peakMips, 0);
EXPECT_GT(hub.chrePlatformId, 0);
EXPECT_GT(hub.chreApiMajorVersion, 0);
EXPECT_GE(hub.chreApiMinorVersion, 0);
EXPECT_GE(hub.chrePatchVersion, 0);
// Minimum 128 byte MTU as required by CHRE API v1.0
EXPECT_GE(hub.maxSupportedMessageLengthBytes, UINT32_C(128));
}
}
TEST_P(ContextHubAidl, TestEnableTestMode) {
Status status = contextHub->setTestMode(true);
if (status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION ||
status.transactionError() == android::UNKNOWN_TRANSACTION) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
} else {
ASSERT_TRUE(status.isOk());
}
}
TEST_P(ContextHubAidl, TestDisableTestMode) {
Status status = contextHub->setTestMode(false);
if (status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION ||
status.transactionError() == android::UNKNOWN_TRANSACTION) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
} else {
ASSERT_TRUE(status.isOk());
}
}
class EmptyContextHubCallback : public android::hardware::contexthub::BnContextHubCallback {
public:
Status handleNanoappInfo(const std::vector<NanoappInfo>& /* appInfo */) override {
return Status::ok();
}
Status handleContextHubMessage(const ContextHubMessage& /* msg */,
const std::vector<String16>& /* msgContentPerms */) override {
return Status::ok();
}
Status handleContextHubAsyncEvent(AsyncEventType /* evt */) override { return Status::ok(); }
Status handleTransactionResult(int32_t /* transactionId */, bool /* success */) override {
return Status::ok();
}
Status handleNanSessionRequest(const NanSessionRequest& /* request */) override {
return Status::ok();
}
};
TEST_P(ContextHubAidl, TestRegisterCallback) {
sp<EmptyContextHubCallback> cb = sp<EmptyContextHubCallback>::make();
ASSERT_TRUE(contextHub->registerCallback(getHubId(), cb).isOk());
}
// Helper callback that puts the async appInfo callback data into a promise
class QueryAppsCallback : public android::hardware::contexthub::BnContextHubCallback {
public:
Status handleNanoappInfo(const std::vector<NanoappInfo>& appInfo) override {
ALOGD("Got app info callback with %zu apps", appInfo.size());
promise.set_value(appInfo);
return Status::ok();
}
Status handleContextHubMessage(const ContextHubMessage& /* msg */,
const std::vector<String16>& /* msgContentPerms */) override {
return Status::ok();
}
Status handleContextHubAsyncEvent(AsyncEventType /* evt */) override { return Status::ok(); }
Status handleTransactionResult(int32_t /* transactionId */, bool /* success */) override {
return Status::ok();
}
Status handleNanSessionRequest(const NanSessionRequest& /* request */) override {
return Status::ok();
}
std::promise<std::vector<NanoappInfo>> promise;
};
// Calls queryApps() and checks the returned metadata
TEST_P(ContextHubAidl, TestQueryApps) {
sp<QueryAppsCallback> cb = sp<QueryAppsCallback>::make();
ASSERT_TRUE(contextHub->registerCallback(getHubId(), cb).isOk());
ASSERT_TRUE(contextHub->queryNanoapps(getHubId()).isOk());
std::vector<NanoappInfo> appInfoList;
ASSERT_TRUE(waitForCallback(cb->promise.get_future(), &appInfoList));
for (const NanoappInfo& appInfo : appInfoList) {
EXPECT_NE(appInfo.nanoappId, UINT64_C(0));
EXPECT_NE(appInfo.nanoappId, kNonExistentAppId);
// Verify services are unique.
std::set<uint64_t> existingServiceIds;
for (const NanoappRpcService& rpcService : appInfo.rpcServices) {
EXPECT_NE(rpcService.id, UINT64_C(0));
EXPECT_EQ(existingServiceIds.count(rpcService.id), 0);
existingServiceIds.insert(rpcService.id);
}
}
}
// Calls getPreloadedNanoappsIds() and verifies there are preloaded nanoapps
TEST_P(ContextHubAidl, TestGetPreloadedNanoappIds) {
std::vector<int64_t> preloadedNanoappIds;
Status status = contextHub->getPreloadedNanoappIds(getHubId(), &preloadedNanoappIds);
if (status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION ||
status.transactionError() == android::UNKNOWN_TRANSACTION) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
} else {
ASSERT_TRUE(status.isOk());
}
}
// Helper callback that puts the TransactionResult for the expectedTransactionId into a
// promise
class TransactionResultCallback : public android::hardware::contexthub::BnContextHubCallback {
public:
Status handleNanoappInfo(const std::vector<NanoappInfo>& /* appInfo */) override {
return Status::ok();
}
Status handleContextHubMessage(const ContextHubMessage& /* msg */,
const std::vector<String16>& /* msgContentPerms */) override {
return Status::ok();
}
Status handleContextHubAsyncEvent(AsyncEventType /* evt */) override { return Status::ok(); }
Status handleTransactionResult(int32_t transactionId, bool success) override {
ALOGD("Got transaction result callback for transactionId %" PRIu32 " (expecting %" PRIu32
") with success %d",
transactionId, expectedTransactionId, success);
if (transactionId == expectedTransactionId) {
promise.set_value(success);
}
return Status::ok();
}
Status handleNanSessionRequest(const NanSessionRequest& /* request */) override {
return Status::ok();
}
uint32_t expectedTransactionId = 0;
std::promise<bool> promise;
};
// Parameterized fixture that sets the callback to TransactionResultCallback
class ContextHubTransactionTest : public ContextHubAidl {
public:
virtual void SetUp() override {
ContextHubAidl::SetUp();
ASSERT_TRUE(contextHub->registerCallback(getHubId(), cb).isOk());
}
sp<TransactionResultCallback> cb = sp<TransactionResultCallback>::make();
};
TEST_P(ContextHubTransactionTest, TestSendMessageToNonExistentNanoapp) {
ContextHubMessage message;
message.nanoappId = kNonExistentAppId;
message.messageType = 1;
message.messageBody.resize(4);
std::fill(message.messageBody.begin(), message.messageBody.end(), 0);
ALOGD("Sending message to non-existent nanoapp");
ASSERT_TRUE(contextHub->sendMessageToHub(getHubId(), message).isOk());
}
TEST_P(ContextHubTransactionTest, TestLoadEmptyNanoapp) {
cb->expectedTransactionId = 0123;
NanoappBinary emptyApp;
emptyApp.nanoappId = kNonExistentAppId;
emptyApp.nanoappVersion = 1;
emptyApp.flags = 0;
emptyApp.targetChreApiMajorVersion = 1;
emptyApp.targetChreApiMinorVersion = 0;
ALOGD("Loading empty nanoapp");
bool success = contextHub->loadNanoapp(getHubId(), emptyApp, cb->expectedTransactionId).isOk();
if (success) {
bool transactionSuccess;
ASSERT_TRUE(waitForCallback(cb->promise.get_future(), &transactionSuccess));
ASSERT_FALSE(transactionSuccess);
}
}
TEST_P(ContextHubTransactionTest, TestUnloadNonexistentNanoapp) {
cb->expectedTransactionId = 1234;
ALOGD("Unloading nonexistent nanoapp");
bool success =
contextHub->unloadNanoapp(getHubId(), kNonExistentAppId, cb->expectedTransactionId)
.isOk();
if (success) {
bool transactionSuccess;
ASSERT_TRUE(waitForCallback(cb->promise.get_future(), &transactionSuccess));
ASSERT_FALSE(transactionSuccess);
}
}
TEST_P(ContextHubTransactionTest, TestEnableNonexistentNanoapp) {
cb->expectedTransactionId = 2345;
ALOGD("Enabling nonexistent nanoapp");
bool success =
contextHub->enableNanoapp(getHubId(), kNonExistentAppId, cb->expectedTransactionId)
.isOk();
if (success) {
bool transactionSuccess;
ASSERT_TRUE(waitForCallback(cb->promise.get_future(), &transactionSuccess));
ASSERT_FALSE(transactionSuccess);
}
}
TEST_P(ContextHubTransactionTest, TestDisableNonexistentNanoapp) {
cb->expectedTransactionId = 3456;
ALOGD("Disabling nonexistent nanoapp");
bool success =
contextHub->disableNanoapp(getHubId(), kNonExistentAppId, cb->expectedTransactionId)
.isOk();
if (success) {
bool transactionSuccess;
ASSERT_TRUE(waitForCallback(cb->promise.get_future(), &transactionSuccess));
ASSERT_FALSE(transactionSuccess);
}
}
void ContextHubAidl::testSettingChanged(Setting setting) {
// In VTS, we only test that sending the values doesn't cause things to blow up - GTS tests
// verify the expected E2E behavior in CHRE
sp<EmptyContextHubCallback> cb = sp<EmptyContextHubCallback>::make();
ASSERT_TRUE(contextHub->registerCallback(getHubId(), cb).isOk());
ASSERT_TRUE(contextHub->onSettingChanged(setting, true /* enabled */).isOk());
ASSERT_TRUE(contextHub->onSettingChanged(setting, false /* enabled */).isOk());
}
TEST_P(ContextHubAidl, TestOnLocationSettingChanged) {
testSettingChanged(Setting::LOCATION);
}
TEST_P(ContextHubAidl, TestOnWifiMainSettingChanged) {
testSettingChanged(Setting::WIFI_MAIN);
}
TEST_P(ContextHubAidl, TestOnWifiScanningSettingChanged) {
testSettingChanged(Setting::WIFI_SCANNING);
}
TEST_P(ContextHubAidl, TestOnAirplaneModeSettingChanged) {
testSettingChanged(Setting::AIRPLANE_MODE);
}
TEST_P(ContextHubAidl, TestOnMicrophoneSettingChanged) {
testSettingChanged(Setting::MICROPHONE);
}
TEST_P(ContextHubAidl, TestOnBtMainSettingChanged) {
testSettingChanged(Setting::BT_MAIN);
}
TEST_P(ContextHubAidl, TestOnBtScanningSettingChanged) {
testSettingChanged(Setting::BT_SCANNING);
}
std::vector<std::tuple<std::string, int32_t>> generateContextHubMapping() {
std::vector<std::tuple<std::string, int32_t>> tuples;
auto contextHubAidlNames = android::getAidlHalInstanceNames(IContextHub::descriptor);
std::vector<ContextHubInfo> contextHubInfos;
for (int i = 0; i < contextHubAidlNames.size(); i++) {
auto contextHubName = contextHubAidlNames[i].c_str();
auto contextHub = android::waitForDeclaredService<IContextHub>(String16(contextHubName));
if (contextHub->getContextHubs(&contextHubInfos).isOk()) {
for (auto& info : contextHubInfos) {
tuples.push_back(std::make_tuple(contextHubName, info.id));
}
}
}
return tuples;
}
TEST_P(ContextHubAidl, TestHostConnection) {
constexpr char16_t kHostEndpointId = 1;
HostEndpointInfo hostEndpointInfo;
hostEndpointInfo.type = HostEndpointInfo::Type::NATIVE;
hostEndpointInfo.hostEndpointId = kHostEndpointId;
ASSERT_TRUE(contextHub->onHostEndpointConnected(hostEndpointInfo).isOk());
ASSERT_TRUE(contextHub->onHostEndpointDisconnected(kHostEndpointId).isOk());
}
TEST_P(ContextHubAidl, TestInvalidHostConnection) {
constexpr char16_t kHostEndpointId = 1;
ASSERT_TRUE(contextHub->onHostEndpointDisconnected(kHostEndpointId).isOk());
}
TEST_P(ContextHubAidl, TestNanSessionStateChange) {
NanSessionStateUpdate update;
update.state = true;
Status status = contextHub->onNanSessionStateChanged(update);
if (status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION ||
status.transactionError() == android::UNKNOWN_TRANSACTION) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
} else {
ASSERT_TRUE(status.isOk());
update.state = false;
ASSERT_TRUE(contextHub->onNanSessionStateChanged(update).isOk());
}
}
std::string PrintGeneratedTest(const testing::TestParamInfo<ContextHubAidl::ParamType>& info) {
return std::string("CONTEXT_HUB_ID_") + std::to_string(std::get<1>(info.param));
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ContextHubAidl);
INSTANTIATE_TEST_SUITE_P(ContextHub, ContextHubAidl, testing::ValuesIn(generateContextHubMapping()),
PrintGeneratedTest);
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ContextHubTransactionTest);
INSTANTIATE_TEST_SUITE_P(ContextHub, ContextHubTransactionTest,
testing::ValuesIn(generateContextHubMapping()), PrintGeneratedTest);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
ProcessState::self()->setThreadPoolMaxThreadCount(1);
ProcessState::self()->startThreadPool();
return RUN_ALL_TESTS();
}
Reference in a new issue View git blame Copy permalink