blob: 78591561a57eb29dbb90078ec08e23ab0d916106 [file] [log] [blame]
Yifan Hongb93f0502016-10-28 10:42:57 -07001/*
2 * Copyright (C) 2016 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
Yifan Hong602b85a2016-10-24 13:40:01 -070017#define LOG_TAG "LibHidlTest"
18
19#include <android-base/logging.h>
Yifan Hong2be94182017-03-03 19:07:38 -080020#include <gmock/gmock.h>
Yifan Hong602b85a2016-10-24 13:40:01 -070021#include <gtest/gtest.h>
22#include <hidl/HidlSupport.h>
Yifan Hong2be94182017-03-03 19:07:38 -080023#include <hidl/Status.h>
Yifan Hong5e2318c2016-10-27 17:19:21 -070024#include <hidl/TaskRunner.h>
Yifan Hong602b85a2016-10-24 13:40:01 -070025#include <vector>
26
27#define EXPECT_ARRAYEQ(__a1__, __a2__, __size__) EXPECT_TRUE(isArrayEqual(__a1__, __a2__, __size__))
Yifan Hong44ab6232016-11-22 16:28:24 -080028#define EXPECT_2DARRAYEQ(__a1__, __a2__, __size1__, __size2__) \
29 EXPECT_TRUE(is2dArrayEqual(__a1__, __a2__, __size1__, __size2__))
Yifan Hong602b85a2016-10-24 13:40:01 -070030
31template<typename T, typename S>
32static inline bool isArrayEqual(const T arr1, const S arr2, size_t size) {
33 for(size_t i = 0; i < size; i++)
34 if(arr1[i] != arr2[i])
35 return false;
36 return true;
37}
38
Yifan Hong44ab6232016-11-22 16:28:24 -080039template<typename T, typename S>
40static inline bool is2dArrayEqual(const T arr1, const S arr2, size_t size1, size_t size2) {
41 for(size_t i = 0; i < size1; i++)
42 for (size_t j = 0; j < size2; j++)
43 if(arr1[i][j] != arr2[i][j])
44 return false;
45 return true;
46}
47
Yifan Hong602b85a2016-10-24 13:40:01 -070048class LibHidlTest : public ::testing::Test {
49public:
50 virtual void SetUp() override {
51 }
52 virtual void TearDown() override {
53 }
54};
55
56TEST_F(LibHidlTest, StringTest) {
57 using android::hardware::hidl_string;
58 hidl_string s; // empty constructor
59 EXPECT_STREQ(s.c_str(), "");
60 hidl_string s1 = "s1"; // copy = from cstr
61 EXPECT_STREQ(s1.c_str(), "s1");
62 hidl_string s2("s2"); // copy constructor from cstr
63 EXPECT_STREQ(s2.c_str(), "s2");
Steven Morelanda21d84f2017-02-16 09:23:45 -080064 hidl_string s2a(nullptr); // copy constructor from null cstr
65 EXPECT_STREQ("", s2a);
Steven Moreland153f87a2017-02-28 09:42:26 -080066 s2a = nullptr; // = from nullptr cstr
67 EXPECT_STREQ(s2a.c_str(), "");
Yifan Hong602b85a2016-10-24 13:40:01 -070068 hidl_string s3 = hidl_string("s3"); // move =
69 EXPECT_STREQ(s3.c_str(), "s3");
Steven Moreland53120f72017-01-12 09:39:26 -080070 hidl_string s4 = hidl_string("12345", 3); // copy constructor from cstr w/ length
71 EXPECT_STREQ(s4.c_str(), "123");
72 hidl_string s5(hidl_string(hidl_string("s5"))); // move constructor
73 EXPECT_STREQ(s5.c_str(), "s5");
74 hidl_string s6(std::string("s6")); // copy constructor from std::string
Yifan Hong602b85a2016-10-24 13:40:01 -070075 EXPECT_STREQ(s6, "s6");
Steven Moreland53120f72017-01-12 09:39:26 -080076 hidl_string s7 = std::string("s7"); // copy = from std::string
77 EXPECT_STREQ(s7, "s7");
78 hidl_string s8(s7); // copy constructor
79 EXPECT_STREQ(s8, "s7");
80 hidl_string s9 = s8; // copy =
81 EXPECT_STREQ(s9, "s7");
Yifan Hong602b85a2016-10-24 13:40:01 -070082 char myCString[20] = "myCString";
83 s.setToExternal(&myCString[0], strlen(myCString));
84 EXPECT_STREQ(s, "myCString");
85 myCString[2] = 'D';
86 EXPECT_STREQ(s, "myDString");
87 s.clear(); // should not affect myCString
88 EXPECT_STREQ(myCString, "myDString");
Scott Randolphbb840f72016-11-21 14:39:26 -080089
Yifan Hong602b85a2016-10-24 13:40:01 -070090 // casts
91 s = "great";
92 std::string myString = s;
93 const char *anotherCString = s;
94 EXPECT_EQ(myString, "great");
95 EXPECT_STREQ(anotherCString, "great");
Scott Randolphbb840f72016-11-21 14:39:26 -080096
97 // Comparisons
98 const char * cstr1 = "abc";
99 std::string string1(cstr1);
100 hidl_string hs1(cstr1);
101 const char * cstrE = "abc";
102 std::string stringE(cstrE);
103 hidl_string hsE(cstrE);
104 const char * cstrNE = "ABC";
105 std::string stringNE(cstrNE);
106 hidl_string hsNE(cstrNE);
Steven Moreland551396a2017-02-13 18:33:20 -0800107 const char * cstr2 = "def";
108 std::string string2(cstr2);
109 hidl_string hs2(cstr2);
110
Scott Randolphbb840f72016-11-21 14:39:26 -0800111 EXPECT_TRUE(hs1 == hsE);
Scott Randolphbb840f72016-11-21 14:39:26 -0800112 EXPECT_FALSE(hs1 == hsNE);
113 EXPECT_TRUE(hs1 == cstrE);
Scott Randolphbb840f72016-11-21 14:39:26 -0800114 EXPECT_FALSE(hs1 == cstrNE);
115 EXPECT_TRUE(hs1 == stringE);
Steven Moreland551396a2017-02-13 18:33:20 -0800116 EXPECT_FALSE(hs1 == stringNE);
117 EXPECT_FALSE(hs1 != hsE);
118 EXPECT_TRUE(hs1 != hsNE);
119 EXPECT_FALSE(hs1 != cstrE);
120 EXPECT_TRUE(hs1 != cstrNE);
Scott Randolphbb840f72016-11-21 14:39:26 -0800121 EXPECT_FALSE(hs1 != stringE);
122 EXPECT_TRUE(hs1 != stringNE);
Steven Moreland551396a2017-02-13 18:33:20 -0800123
124 EXPECT_TRUE(hs1 < hs2);
125 EXPECT_FALSE(hs2 < hs1);
126 EXPECT_TRUE(hs2 > hs1);
127 EXPECT_FALSE(hs1 > hs2);
128 EXPECT_TRUE(hs1 <= hs1);
129 EXPECT_TRUE(hs1 <= hs2);
130 EXPECT_FALSE(hs2 <= hs1);
131 EXPECT_TRUE(hs1 >= hs1);
132 EXPECT_TRUE(hs2 >= hs1);
133 EXPECT_FALSE(hs2 <= hs1);
Yifan Hong602b85a2016-10-24 13:40:01 -0700134}
135
Jeff Tinker0f3461d2017-01-03 10:40:55 -0800136TEST_F(LibHidlTest, MemoryTest) {
137 using android::hardware::hidl_memory;
138
139 hidl_memory mem1 = hidl_memory(); // default constructor
140 hidl_memory mem2 = mem1; // copy constructor (nullptr)
141
142 EXPECT_EQ(nullptr, mem2.handle());
143
144 native_handle_t* testHandle = native_handle_create(0 /* numInts */, 0 /* numFds */);
145
146 hidl_memory mem3 = hidl_memory("foo", testHandle, 42 /* size */); // owns testHandle
147 hidl_memory mem4 = mem3; // copy constructor (regular handle)
148
149 EXPECT_EQ(mem3.name(), mem4.name());
150 EXPECT_EQ(mem3.size(), mem4.size());
151 EXPECT_NE(nullptr, mem4.handle());
152 EXPECT_NE(mem3.handle(), mem4.handle()); // check handle cloned
153
154 hidl_memory mem5 = hidl_memory("foo", nullptr, 0); // hidl memory works with nullptr handle
155 hidl_memory mem6 = mem5;
156 EXPECT_EQ(nullptr, mem5.handle());
157 EXPECT_EQ(nullptr, mem6.handle());
158}
159
Yifan Hong64fdf4d2016-12-09 16:22:45 -0800160TEST_F(LibHidlTest, VecInitTest) {
Yifan Hong602b85a2016-10-24 13:40:01 -0700161 using android::hardware::hidl_vec;
162 using std::vector;
163 int32_t array[] = {5, 6, 7};
164 vector<int32_t> v(array, array + 3);
165
166 hidl_vec<int32_t> hv1 = v; // copy =
167 EXPECT_ARRAYEQ(hv1, array, 3);
168 EXPECT_ARRAYEQ(hv1, v, 3);
169 hidl_vec<int32_t> hv2(v); // copy constructor
170 EXPECT_ARRAYEQ(hv2, v, 3);
171
172 vector<int32_t> v2 = hv1; // cast
173 EXPECT_ARRAYEQ(v2, v, 3);
Steven Moreland9fbfe472016-11-14 16:49:17 -0800174
175 hidl_vec<int32_t> v3 = {5, 6, 7}; // initializer_list
Steven Morelandb69926a2016-11-15 10:02:57 -0800176 EXPECT_EQ(v3.size(), 3ul);
Steven Moreland9fbfe472016-11-14 16:49:17 -0800177 EXPECT_ARRAYEQ(v3, array, v3.size());
Yifan Hong64fdf4d2016-12-09 16:22:45 -0800178}
179
180TEST_F(LibHidlTest, VecIterTest) {
181 int32_t array[] = {5, 6, 7};
182 android::hardware::hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
Scott Randolphbb840f72016-11-21 14:39:26 -0800183
184 auto iter = hv1.begin(); // iterator begin()
Yifan Hong64fdf4d2016-12-09 16:22:45 -0800185 EXPECT_EQ(*iter++, 5);
Scott Randolphbb840f72016-11-21 14:39:26 -0800186 EXPECT_EQ(*iter, 6);
Yifan Hong64fdf4d2016-12-09 16:22:45 -0800187 EXPECT_EQ(*++iter, 7);
188 EXPECT_EQ(*iter--, 7);
189 EXPECT_EQ(*iter, 6);
190 EXPECT_EQ(*--iter, 5);
191
192 iter += 2;
Scott Randolphbb840f72016-11-21 14:39:26 -0800193 EXPECT_EQ(*iter, 7);
Yifan Hong64fdf4d2016-12-09 16:22:45 -0800194 iter -= 2;
195 EXPECT_EQ(*iter, 5);
196
197 iter++;
198 EXPECT_EQ(*(iter + 1), 7);
199 EXPECT_EQ(*(1 + iter), 7);
200 EXPECT_EQ(*(iter - 1), 5);
201 EXPECT_EQ(*iter, 6);
202
203 auto five = iter - 1;
204 auto seven = iter + 1;
205 EXPECT_EQ(seven - five, 2);
206 EXPECT_EQ(five - seven, -2);
207
208 EXPECT_LT(five, seven);
209 EXPECT_LE(five, seven);
210 EXPECT_GT(seven, five);
211 EXPECT_GE(seven, five);
212
213 EXPECT_EQ(seven[0], 7);
214 EXPECT_EQ(five[1], 6);
215}
216
217TEST_F(LibHidlTest, VecIterForTest) {
218 using android::hardware::hidl_vec;
219 int32_t array[] = {5, 6, 7};
220 hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
Scott Randolphbb840f72016-11-21 14:39:26 -0800221
222 int32_t sum = 0; // range based for loop interoperability
223 for (auto &&i: hv1) {
224 sum += i;
225 }
226 EXPECT_EQ(sum, 5+6+7);
Yifan Hong64fdf4d2016-12-09 16:22:45 -0800227
228 for (auto iter = hv1.begin(); iter < hv1.end(); ++iter) {
229 *iter += 10;
230 }
231 const hidl_vec<int32_t> &v4 = hv1;
232 sum = 0;
233 for (const auto &i : v4) {
234 sum += i;
235 }
236 EXPECT_EQ(sum, 15+16+17);
Yifan Hong602b85a2016-10-24 13:40:01 -0700237}
238
Yifan Hong9fcbb362016-12-20 16:46:41 -0800239TEST_F(LibHidlTest, VecEqTest) {
240 android::hardware::hidl_vec<int32_t> hv1{5, 6, 7};
241 android::hardware::hidl_vec<int32_t> hv2{5, 6, 7};
242 android::hardware::hidl_vec<int32_t> hv3{5, 6, 8};
243
244 // use the == and != operator intentionally here
245 EXPECT_TRUE(hv1 == hv2);
246 EXPECT_TRUE(hv1 != hv3);
247}
248
Sasha Levitskiy3da68482016-11-17 16:48:43 -0800249TEST_F(LibHidlTest, ArrayTest) {
250 using android::hardware::hidl_array;
251 int32_t array[] = {5, 6, 7};
252
253 hidl_array<int32_t, 3> ha(array);
254 EXPECT_ARRAYEQ(ha, array, 3);
255}
256
Yifan Hong5e2318c2016-10-27 17:19:21 -0700257TEST_F(LibHidlTest, TaskRunnerTest) {
Yifan Hong0a351392017-03-20 17:17:52 -0700258 using android::hardware::details::TaskRunner;
Yifan Hong5e2318c2016-10-27 17:19:21 -0700259 TaskRunner tr;
Yifan Hong6f667542017-03-20 19:04:05 -0700260 tr.start(1 /* limit */);
Yifan Hong5e2318c2016-10-27 17:19:21 -0700261 bool flag = false;
262 tr.push([&] {
263 usleep(1000);
264 flag = true;
265 });
266 usleep(500);
267 EXPECT_FALSE(flag);
268 usleep(1000);
269 EXPECT_TRUE(flag);
270}
271
Yifan Hong5708fb42016-10-26 17:50:29 -0700272TEST_F(LibHidlTest, StringCmpTest) {
273 using android::hardware::hidl_string;
274 const char * s = "good";
275 hidl_string hs(s);
276 EXPECT_NE(hs.c_str(), s);
277
278 EXPECT_TRUE(hs == s); // operator ==
279 EXPECT_TRUE(s == hs);
280
281 EXPECT_FALSE(hs != s); // operator ==
282 EXPECT_FALSE(s != hs);
283}
284
Yifan Hong602b85a2016-10-24 13:40:01 -0700285template <typename T>
286void great(android::hardware::hidl_vec<T>) {}
287
288TEST_F(LibHidlTest, VecCopyTest) {
289 android::hardware::hidl_vec<int32_t> v;
290 great(v);
291}
292
Yifan Hong44ab6232016-11-22 16:28:24 -0800293TEST_F(LibHidlTest, StdArrayTest) {
294 using android::hardware::hidl_array;
295 hidl_array<int32_t, 5> array{(int32_t[5]){1, 2, 3, 4, 5}};
296 std::array<int32_t, 5> stdArray = array;
297 EXPECT_ARRAYEQ(array.data(), stdArray.data(), 5);
298 hidl_array<int32_t, 5> array2 = stdArray;
299 EXPECT_ARRAYEQ(array.data(), array2.data(), 5);
300}
301
302TEST_F(LibHidlTest, MultiDimStdArrayTest) {
303 using android::hardware::hidl_array;
304 hidl_array<int32_t, 2, 3> array;
305 for (size_t i = 0; i < 2; i++) {
306 for (size_t j = 0; j < 3; j++) {
307 array[i][j] = i + j + i * j;
308 }
309 }
310 std::array<std::array<int32_t, 3>, 2> stdArray = array;
311 EXPECT_2DARRAYEQ(array, stdArray, 2, 3);
312 hidl_array<int32_t, 2, 3> array2 = stdArray;
313 EXPECT_2DARRAYEQ(array, array2, 2, 3);
314}
315
Eino-Ville Talvala19f4db52016-12-14 15:19:28 -0800316TEST_F(LibHidlTest, HidlVersionTest) {
317 using android::hardware::hidl_version;
318 hidl_version v1_0{1, 0};
319 EXPECT_EQ(1, v1_0.get_major());
320 EXPECT_EQ(0, v1_0.get_minor());
321 hidl_version v2_0{2, 0};
322 hidl_version v2_1{2, 1};
323 hidl_version v2_2{2, 2};
324 hidl_version v3_0{3, 0};
325 hidl_version v3_0b{3,0};
326
327 EXPECT_TRUE(v1_0 < v2_0);
328 EXPECT_TRUE(v2_0 < v2_1);
329 EXPECT_TRUE(v2_1 < v3_0);
330 EXPECT_TRUE(v2_0 > v1_0);
331 EXPECT_TRUE(v2_1 > v2_0);
332 EXPECT_TRUE(v3_0 > v2_1);
333 EXPECT_TRUE(v3_0 == v3_0b);
334 EXPECT_TRUE(v3_0 <= v3_0b);
335 EXPECT_TRUE(v2_2 <= v3_0);
336 EXPECT_TRUE(v3_0 >= v3_0b);
337 EXPECT_TRUE(v3_0 >= v2_2);
338}
339
Yifan Hongaf4e43c2017-03-03 19:10:52 -0800340TEST_F(LibHidlTest, ReturnMoveTest) {
341 using namespace ::android;
342 using ::android::hardware::Return;
343 using ::android::hardware::Status;
344 Return<void> ret{Status::fromStatusT(DEAD_OBJECT)};
345 ret.isOk();
346 ret = {Status::fromStatusT(DEAD_OBJECT)};
347 ret.isOk();
348}
Eino-Ville Talvala19f4db52016-12-14 15:19:28 -0800349
Yifan Hong2be94182017-03-03 19:07:38 -0800350std::string toString(const ::android::hardware::Status &s) {
351 using ::android::hardware::operator<<;
352 std::ostringstream oss;
353 oss << s;
354 return oss.str();
355}
356
357TEST_F(LibHidlTest, StatusStringTest) {
358 using namespace ::android;
359 using ::android::hardware::Status;
360 using ::testing::HasSubstr;
361
362 EXPECT_EQ(toString(Status::ok()), "No error");
363
364 EXPECT_THAT(toString(Status::fromStatusT(DEAD_OBJECT)), HasSubstr("DEAD_OBJECT"));
365
366 EXPECT_THAT(toString(Status::fromStatusT(-EBUSY)), HasSubstr("busy"));
367
Yifan Hong2be94182017-03-03 19:07:38 -0800368 EXPECT_THAT(toString(Status::fromExceptionCode(Status::EX_NULL_POINTER)),
369 HasSubstr("EX_NULL_POINTER"));
370
371}
372
Yifan Hong602b85a2016-10-24 13:40:01 -0700373int main(int argc, char **argv) {
374 ::testing::InitGoogleTest(&argc, argv);
375 return RUN_ALL_TESTS();
376}