1 /*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <functional>
18 #include <map>
19 #include <string>
20
21 #include <android/hidl/base/1.0/IBase.h>
22 #include <android/hidl/manager/1.0/IServiceManager.h>
23 #include <gtest/gtest.h>
24 #include <hidl/HidlBinderSupport.h>
25 #include <hidl/ServiceManagement.h>
26
27 using android::hardware::hidl_array;
28 using android::hardware::hidl_death_recipient;
29 using android::hardware::hidl_handle;
30 using android::hardware::hidl_string;
31 using android::hardware::hidl_vec;
32 using android::hardware::IBinder;
33 using android::hardware::toBinder;
34 using android::hidl::base::V1_0::IBase;
35 using android::hidl::manager::V1_0::IServiceManager;
36 using android::sp;
37 using android::wp;
38
39 template <typename T>
isOk(const::android::hardware::Return<T> & ret)40 static inline ::testing::AssertionResult isOk(const ::android::hardware::Return<T>& ret) {
41 return ret.isOk() ? (::testing::AssertionSuccess() << ret.description())
42 : (::testing::AssertionFailure() << ret.description());
43 }
44 #define ASSERT_OK(__ret__) ASSERT_TRUE(isOk(__ret__))
45 #define EXPECT_OK(__ret__) EXPECT_TRUE(isOk(__ret__))
46
47 struct Hal {
48 sp<IBase> service;
49 std::string name; // space separated list of android.hidl.foo@1.0::IFoo/instance-name
50 };
51
52 class VtsHalBaseV1_0TargetTest : public ::testing::Test {
53 public:
SetUp()54 virtual void SetUp() override {
55 default_manager_ = ::android::hardware::defaultServiceManager();
56
57 ASSERT_NE(default_manager_, nullptr)
58 << "Failed to get default service manager." << std::endl;
59
60 ASSERT_OK(default_manager_->list([&](const auto& list) {
61 for (const auto& name : list) {
62 const std::string strName = name;
63 auto loc = strName.find_first_of('/');
64 if (loc == std::string::npos) {
65 ADD_FAILURE() << "Invalid FQName: " << strName;
66 continue;
67 }
68 const std::string fqName = strName.substr(0, loc);
69 const std::string instance = strName.substr(loc + 1);
70
71 sp<IBase> service = default_manager_->get(fqName, instance);
72 if (service == nullptr) {
73 ADD_FAILURE() << "Null service for " << name << " " << fqName << " "
74 << instance;
75 continue;
76 }
77
78 sp<IBinder> binder = toBinder(service);
79 if (binder == nullptr) {
80 ADD_FAILURE() << "Null binder for " << name;
81 continue;
82 }
83
84 auto iter = all_hals_.find(binder);
85 if (iter != all_hals_.end()) {
86 // include all the names this is registered as for error messages
87 iter->second.name += " " + strName;
88 } else {
89 all_hals_.insert(iter, {binder, Hal{service, strName}});
90 }
91 }
92 }));
93
94 ASSERT_FALSE(all_hals_.empty()); // sanity
95 }
96
EachHal(const std::function<void (const Hal &)> & check)97 void EachHal(const std::function<void(const Hal&)>& check) {
98 for (auto iter = all_hals_.begin(); iter != all_hals_.end(); ++iter) {
99 check(iter->second);
100 }
101 }
102
103 // default service manager
104 sp<IServiceManager> default_manager_;
105
106 // map from underlying instance to actual instance
107 //
108 // this prevents calling the same service twice since the same service
109 // will get registered multiple times for its entire inheritance
110 // hierarchy (or perhaps as different instance names)
111 std::map<sp<IBinder>, Hal> all_hals_;
112 };
113
TEST_F(VtsHalBaseV1_0TargetTest,CanPing)114 TEST_F(VtsHalBaseV1_0TargetTest, CanPing) {
115 EachHal(
116 [&](const Hal& base) { EXPECT_OK(base.service->ping()) << "Cannot ping " << base.name; });
117 }
118
TEST_F(VtsHalBaseV1_0TargetTest,InterfaceChain)119 TEST_F(VtsHalBaseV1_0TargetTest, InterfaceChain) {
120 EachHal([&](const Hal& base) {
121 EXPECT_OK(base.service->interfaceChain([&](const auto& interfaceChain) {
122 // must include IBase + subclasses
123 EXPECT_GT(interfaceChain.size(), 1u) << "Invalid instance name " << base.name;
124 })) << base.name;
125 });
126 }
127
TEST_F(VtsHalBaseV1_0TargetTest,Descriptor)128 TEST_F(VtsHalBaseV1_0TargetTest, Descriptor) {
129 EachHal([&](const Hal& base) {
130 EXPECT_OK(base.service->interfaceDescriptor([&](const auto& descriptor) {
131 // must include IBase + subclasses
132 EXPECT_GT(descriptor.size(), 0u) << base.name;
133 EXPECT_NE(IBase::descriptor, descriptor) << base.name;
134 })) << base.name;
135 });
136 }
137
TEST_F(VtsHalBaseV1_0TargetTest,Death)138 TEST_F(VtsHalBaseV1_0TargetTest, Death) {
139 struct HidlDeathRecipient : hidl_death_recipient {
140 virtual void serviceDied(uint64_t /* cookie */, const wp<IBase>& /* who */){};
141 };
142 sp<hidl_death_recipient> recipient = new HidlDeathRecipient;
143
144 EachHal([&](const Hal& base) {
145 EXPECT_OK(base.service->linkToDeath(recipient, 0 /* cookie */))
146 << "Register death recipient " << base.name;
147 EXPECT_OK(base.service->unlinkToDeath(recipient)) << "Unlink death recipient " << base.name;
148 });
149 }
150
TEST_F(VtsHalBaseV1_0TargetTest,Debug)151 TEST_F(VtsHalBaseV1_0TargetTest, Debug) {
152 EachHal([&](const Hal& base) {
153 // normally one is passed, but this is tested by dumpstate
154 EXPECT_OK(base.service->debug(hidl_handle(), {}))
155 << "Handle empty debug handle " << base.name;
156 });
157 }
158
TEST_F(VtsHalBaseV1_0TargetTest,HashChain)159 TEST_F(VtsHalBaseV1_0TargetTest, HashChain) {
160 EachHal([&](const Hal& base) {
161 EXPECT_OK(base.service->getHashChain([&](const auto& hashChain) {
162 // must include IBase + subclasses
163 EXPECT_NE(0u, hashChain.size()) << "Invalid hash chain " << base.name;
164 })) << base.name;
165 });
166 }
167
main(int argc,char ** argv)168 int main(int argc, char** argv) {
169 ::testing::InitGoogleTest(&argc, argv);
170 return RUN_ALL_TESTS();
171 }
172