test_main.cpp revision 96e9de049f4dd2ee7d02eaf9a662e286964c2039 
1/*
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
17#define LOG_TAG "LibHidlTest"
18
19#include <android-base/logging.h>
20#include <condition_variable>
21#include <gmock/gmock.h>
22#include <gtest/gtest.h>
23#include <hidl/HidlSupport.h>
24#include <hidl/Status.h>
25#include <hidl/TaskRunner.h>
26#include <vector>
27
28#define EXPECT_ARRAYEQ(__a1__, __a2__, __size__) EXPECT_TRUE(isArrayEqual(__a1__, __a2__, __size__))
29#define EXPECT_2DARRAYEQ(__a1__, __a2__, __size1__, __size2__) \
30        EXPECT_TRUE(is2dArrayEqual(__a1__, __a2__, __size1__, __size2__))
31
32template<typename T, typename S>
33static inline bool isArrayEqual(const T arr1, const S arr2, size_t size) {
34    for(size_t i = 0; i < size; i++)
35        if(arr1[i] != arr2[i])
36            return false;
37    return true;
38}
39
40template<typename T, typename S>
41static inline bool is2dArrayEqual(const T arr1, const S arr2, size_t size1, size_t size2) {
42    for(size_t i = 0; i < size1; i++)
43        for (size_t j = 0; j < size2; j++)
44            if(arr1[i][j] != arr2[i][j])
45                return false;
46    return true;
47}
48
49class LibHidlTest : public ::testing::Test {
50public:
51    virtual void SetUp() override {
52    }
53    virtual void TearDown() override {
54    }
55};
56
57TEST_F(LibHidlTest, StringTest) {
58    using android::hardware::hidl_string;
59    hidl_string s; // empty constructor
60    EXPECT_STREQ(s.c_str(), "");
61    hidl_string s1 = "s1"; // copy = from cstr
62    EXPECT_STREQ(s1.c_str(), "s1");
63    hidl_string s2("s2"); // copy constructor from cstr
64    EXPECT_STREQ(s2.c_str(), "s2");
65    hidl_string s2a(nullptr); // copy constructor from null cstr
66    EXPECT_STREQ("", s2a.c_str());
67    s2a = nullptr; // = from nullptr cstr
68    EXPECT_STREQ(s2a.c_str(), "");
69    hidl_string s3 = hidl_string("s3"); // move =
70    EXPECT_STREQ(s3.c_str(), "s3");
71    hidl_string s4 = hidl_string("12345", 3); // copy constructor from cstr w/ length
72    EXPECT_STREQ(s4.c_str(), "123");
73    hidl_string s5(hidl_string(hidl_string("s5"))); // move constructor
74    EXPECT_STREQ(s5.c_str(), "s5");
75    hidl_string s6(std::string("s6")); // copy constructor from std::string
76    EXPECT_STREQ(s6.c_str(), "s6");
77    hidl_string s7 = std::string("s7"); // copy = from std::string
78    EXPECT_STREQ(s7.c_str(), "s7");
79    hidl_string s8(s7); // copy constructor // NOLINT, test the copy constructor
80    EXPECT_STREQ(s8.c_str(), "s7");
81    hidl_string s9 = s8; // copy =  // NOLINT, test the copy operator
82    EXPECT_STREQ(s9.c_str(), "s7");
83    char myCString[20] = "myCString";
84    s.setToExternal(&myCString[0], strlen(myCString));
85    EXPECT_STREQ(s.c_str(), "myCString");
86    myCString[2] = 'D';
87    EXPECT_STREQ(s.c_str(), "myDString");
88    s.clear(); // should not affect myCString
89    EXPECT_STREQ(myCString, "myDString");
90
91    // casts
92    s = "great";
93    std::string myString = s;
94    const char *anotherCString = s.c_str();
95    EXPECT_EQ(myString, "great");
96    EXPECT_STREQ(anotherCString, "great");
97
98    const hidl_string t = "not so great";
99    std::string myTString = t;
100    const char * anotherTCString = t.c_str();
101    EXPECT_EQ(myTString, "not so great");
102    EXPECT_STREQ(anotherTCString, "not so great");
103
104    // Assignment from hidl_string to std::string
105    std::string tgt;
106    hidl_string src("some stuff");
107    tgt = src;
108    EXPECT_STREQ(tgt.c_str(), "some stuff");
109
110    // Stream output operator
111    hidl_string msg("hidl_string works with operator<<");
112    std::cout << msg;
113
114    // Comparisons
115    const char * cstr1 = "abc";
116    std::string string1(cstr1);
117    hidl_string hs1(cstr1);
118    const char * cstrE = "abc";
119    std::string stringE(cstrE);
120    hidl_string hsE(cstrE);
121    const char * cstrNE = "ABC";
122    std::string stringNE(cstrNE);
123    hidl_string hsNE(cstrNE);
124    const char * cstr2 = "def";
125    std::string string2(cstr2);
126    hidl_string hs2(cstr2);
127
128    EXPECT_TRUE(hs1  == hsE);
129    EXPECT_FALSE(hs1 == hsNE);
130    EXPECT_TRUE(hs1  == cstrE);
131    EXPECT_FALSE(hs1 == cstrNE);
132    EXPECT_TRUE(hs1  == stringE);
133    EXPECT_FALSE(hs1 == stringNE);
134    EXPECT_FALSE(hs1 != hsE);
135    EXPECT_TRUE(hs1  != hsNE);
136    EXPECT_FALSE(hs1 != cstrE);
137    EXPECT_TRUE(hs1  != cstrNE);
138    EXPECT_FALSE(hs1 != stringE);
139    EXPECT_TRUE(hs1  != stringNE);
140
141    EXPECT_TRUE(hs1 < hs2);
142    EXPECT_FALSE(hs2 < hs1);
143    EXPECT_TRUE(hs2 > hs1);
144    EXPECT_FALSE(hs1 > hs2);
145    EXPECT_TRUE(hs1 <= hs1);
146    EXPECT_TRUE(hs1 <= hs2);
147    EXPECT_FALSE(hs2 <= hs1);
148    EXPECT_TRUE(hs1 >= hs1);
149    EXPECT_TRUE(hs2 >= hs1);
150    EXPECT_FALSE(hs2 <= hs1);
151}
152
153TEST_F(LibHidlTest, MemoryTest) {
154    using android::hardware::hidl_memory;
155
156    hidl_memory mem1 = hidl_memory(); // default constructor
157    hidl_memory mem2 = mem1; // copy constructor (nullptr), NOLINT
158
159    EXPECT_EQ(nullptr, mem2.handle());
160
161    native_handle_t* testHandle = native_handle_create(0 /* numInts */, 0 /* numFds */);
162
163    hidl_memory mem3 = hidl_memory("foo", testHandle, 42 /* size */); // owns testHandle
164    hidl_memory mem4 = mem3; // copy constructor (regular handle), NOLINT
165
166    EXPECT_EQ(mem3.name(), mem4.name());
167    EXPECT_EQ(mem3.size(), mem4.size());
168    EXPECT_NE(nullptr, mem4.handle());
169    EXPECT_NE(mem3.handle(), mem4.handle()); // check handle cloned
170
171    hidl_memory mem5 = hidl_memory("foo", nullptr, 0); // hidl memory works with nullptr handle
172    hidl_memory mem6 = mem5; // NOLINT, test copying
173    EXPECT_EQ(nullptr, mem5.handle());
174    EXPECT_EQ(nullptr, mem6.handle());
175}
176
177TEST_F(LibHidlTest, VecInitTest) {
178    using android::hardware::hidl_vec;
179    using std::vector;
180    int32_t empty[3] = {0};
181    int32_t array[] = {5, 6, 7};
182    vector<int32_t> v(array, array + 3);
183
184    hidl_vec<int32_t> hv0(3);  // size
185    EXPECT_EQ(hv0.size(), 3ul);
186    EXPECT_ARRAYEQ(hv0, empty, 3);
187
188    hidl_vec<int32_t> hv1 = v; // copy =
189    EXPECT_ARRAYEQ(hv1, array, 3);
190    EXPECT_ARRAYEQ(hv1, v, 3);
191    hidl_vec<int32_t> hv2(v); // copy constructor
192    EXPECT_ARRAYEQ(hv2, v, 3);
193
194    vector<int32_t> v2 = hv1; // cast
195    EXPECT_ARRAYEQ(v2, v, 3);
196
197    hidl_vec<int32_t> v3 = {5, 6, 7}; // initializer_list
198    EXPECT_EQ(v3.size(), 3ul);
199    EXPECT_ARRAYEQ(v3, array, v3.size());
200}
201
202TEST_F(LibHidlTest, VecIterTest) {
203    int32_t array[] = {5, 6, 7};
204    android::hardware::hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
205
206    auto iter = hv1.begin();    // iterator begin()
207    EXPECT_EQ(*iter++, 5);
208    EXPECT_EQ(*iter, 6);
209    EXPECT_EQ(*++iter, 7);
210    EXPECT_EQ(*iter--, 7);
211    EXPECT_EQ(*iter, 6);
212    EXPECT_EQ(*--iter, 5);
213
214    iter += 2;
215    EXPECT_EQ(*iter, 7);
216    iter -= 2;
217    EXPECT_EQ(*iter, 5);
218
219    iter++;
220    EXPECT_EQ(*(iter + 1), 7);
221    EXPECT_EQ(*(1 + iter), 7);
222    EXPECT_EQ(*(iter - 1), 5);
223    EXPECT_EQ(*iter, 6);
224
225    auto five = iter - 1;
226    auto seven = iter + 1;
227    EXPECT_EQ(seven - five, 2);
228    EXPECT_EQ(five - seven, -2);
229
230    EXPECT_LT(five, seven);
231    EXPECT_LE(five, seven);
232    EXPECT_GT(seven, five);
233    EXPECT_GE(seven, five);
234
235    EXPECT_EQ(seven[0], 7);
236    EXPECT_EQ(five[1], 6);
237}
238
239TEST_F(LibHidlTest, VecIterForTest) {
240    using android::hardware::hidl_vec;
241    int32_t array[] = {5, 6, 7};
242    hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
243
244    int32_t sum = 0;            // range based for loop interoperability
245    for (auto &&i: hv1) {
246        sum += i;
247    }
248    EXPECT_EQ(sum, 5+6+7);
249
250    for (auto iter = hv1.begin(); iter < hv1.end(); ++iter) {
251        *iter += 10;
252    }
253    const hidl_vec<int32_t> &v4 = hv1;
254    sum = 0;
255    for (const auto &i : v4) {
256        sum += i;
257    }
258    EXPECT_EQ(sum, 15+16+17);
259}
260
261TEST_F(LibHidlTest, VecEqTest) {
262    android::hardware::hidl_vec<int32_t> hv1{5, 6, 7};
263    android::hardware::hidl_vec<int32_t> hv2{5, 6, 7};
264    android::hardware::hidl_vec<int32_t> hv3{5, 6, 8};
265
266    // use the == and != operator intentionally here
267    EXPECT_TRUE(hv1 == hv2);
268    EXPECT_TRUE(hv1 != hv3);
269}
270
271TEST_F(LibHidlTest, VecRangeCtorTest) {
272    struct ConvertibleType {
273        int val;
274
275        explicit ConvertibleType(int val) : val(val) {}
276        explicit operator int() const { return val; }
277        bool operator==(const int& other) const { return val == other; }
278    };
279
280    std::vector<ConvertibleType> input{
281        ConvertibleType(1), ConvertibleType(2), ConvertibleType(3),
282    };
283
284    android::hardware::hidl_vec<int> hv(input.begin(), input.end());
285
286    EXPECT_EQ(input.size(), hv.size());
287    int sum = 0;
288    for (unsigned i = 0; i < input.size(); i++) {
289        EXPECT_EQ(input[i], hv[i]);
290        sum += hv[i];
291    }
292    EXPECT_EQ(sum, 1 + 2 + 3);
293}
294
295TEST_F(LibHidlTest, ArrayTest) {
296    using android::hardware::hidl_array;
297    int32_t array[] = {5, 6, 7};
298
299    hidl_array<int32_t, 3> ha(array);
300    EXPECT_ARRAYEQ(ha, array, 3);
301}
302
303TEST_F(LibHidlTest, TaskRunnerTest) {
304    using android::hardware::details::TaskRunner;
305    using namespace std::chrono_literals;
306
307    std::condition_variable cv;
308    std::mutex m;
309
310    TaskRunner tr;
311    tr.start(1 /* limit */);
312    bool flag = false;
313    tr.push([&] {
314        flag = true;
315        cv.notify_all();
316    });
317
318    std::unique_lock<std::mutex> lock(m);
319
320    // 1s so this doesn't deadlock. This isn't a performance test.
321    EXPECT_TRUE(cv.wait_for(lock, 1s, [&]{return flag;}));
322    EXPECT_TRUE(flag);
323}
324
325TEST_F(LibHidlTest, StringCmpTest) {
326    using android::hardware::hidl_string;
327    const char * s = "good";
328    hidl_string hs(s);
329    EXPECT_NE(hs.c_str(), s);
330
331    EXPECT_TRUE(hs == s); // operator ==
332    EXPECT_TRUE(s == hs);
333
334    EXPECT_FALSE(hs != s); // operator ==
335    EXPECT_FALSE(s != hs);
336}
337
338template <typename T>
339void great(android::hardware::hidl_vec<T>) {}
340
341TEST_F(LibHidlTest, VecCopyTest) {
342    android::hardware::hidl_vec<int32_t> v;
343    great(v);
344}
345
346TEST_F(LibHidlTest, StdArrayTest) {
347    using android::hardware::hidl_array;
348    hidl_array<int32_t, 5> array{(int32_t[5]){1, 2, 3, 4, 5}};
349    std::array<int32_t, 5> stdArray = array;
350    EXPECT_ARRAYEQ(array.data(), stdArray.data(), 5);
351    hidl_array<int32_t, 5> array2 = stdArray;
352    EXPECT_ARRAYEQ(array.data(), array2.data(), 5);
353}
354
355TEST_F(LibHidlTest, MultiDimStdArrayTest) {
356    using android::hardware::hidl_array;
357    hidl_array<int32_t, 2, 3> array;
358    for (size_t i = 0; i < 2; i++) {
359        for (size_t j = 0; j < 3; j++) {
360            array[i][j] = i + j + i * j;
361        }
362    }
363    std::array<std::array<int32_t, 3>, 2> stdArray = array;
364    EXPECT_2DARRAYEQ(array, stdArray, 2, 3);
365    hidl_array<int32_t, 2, 3> array2 = stdArray;
366    EXPECT_2DARRAYEQ(array, array2, 2, 3);
367}
368
369TEST_F(LibHidlTest, HidlVersionTest) {
370    using android::hardware::hidl_version;
371    hidl_version v1_0{1, 0};
372    EXPECT_EQ(1, v1_0.get_major());
373    EXPECT_EQ(0, v1_0.get_minor());
374    hidl_version v2_0{2, 0};
375    hidl_version v2_1{2, 1};
376    hidl_version v2_2{2, 2};
377    hidl_version v3_0{3, 0};
378    hidl_version v3_0b{3,0};
379
380    EXPECT_TRUE(v1_0 < v2_0);
381    EXPECT_TRUE(v2_0 < v2_1);
382    EXPECT_TRUE(v2_1 < v3_0);
383    EXPECT_TRUE(v2_0 > v1_0);
384    EXPECT_TRUE(v2_1 > v2_0);
385    EXPECT_TRUE(v3_0 > v2_1);
386    EXPECT_TRUE(v3_0 == v3_0b);
387    EXPECT_TRUE(v3_0 <= v3_0b);
388    EXPECT_TRUE(v2_2 <= v3_0);
389    EXPECT_TRUE(v3_0 >= v3_0b);
390    EXPECT_TRUE(v3_0 >= v2_2);
391}
392
393TEST_F(LibHidlTest, ReturnMoveTest) {
394    using namespace ::android;
395    using ::android::hardware::Return;
396    using ::android::hardware::Status;
397    Return<void> ret{Status::fromStatusT(DEAD_OBJECT)};
398    ret.isOk();
399    ret = {Status::fromStatusT(DEAD_OBJECT)};
400    ret.isOk();
401}
402
403TEST_F(LibHidlTest, ReturnTest) {
404    using ::android::DEAD_OBJECT;
405    using ::android::hardware::Return;
406    using ::android::hardware::Status;
407    using ::android::hardware::hidl_string;
408
409    EXPECT_FALSE(Return<void>(Status::fromStatusT(DEAD_OBJECT)).isOk());
410    EXPECT_TRUE(Return<void>(Status::ok()).isOk());
411
412    hidl_string one = "1";
413    hidl_string two = "2";
414    Return<hidl_string> ret = Return<hidl_string>(Status::fromStatusT(DEAD_OBJECT));
415
416    EXPECT_EQ(one, Return<hidl_string>(one).withDefault(two));
417    EXPECT_EQ(two, ret.withDefault(two));
418
419    hidl_string&& moved = ret.withDefault(std::move(two));
420    EXPECT_EQ("2", moved);
421
422    const hidl_string three = "3";
423    EXPECT_EQ(three, ret.withDefault(three));
424}
425
426std::string toString(const ::android::hardware::Status &s) {
427    using ::android::hardware::operator<<;
428    std::ostringstream oss;
429    oss << s;
430    return oss.str();
431}
432
433TEST_F(LibHidlTest, StatusStringTest) {
434    using namespace ::android;
435    using ::android::hardware::Status;
436    using ::testing::HasSubstr;
437
438    EXPECT_EQ(toString(Status::ok()), "No error");
439
440    EXPECT_THAT(toString(Status::fromStatusT(DEAD_OBJECT)), HasSubstr("DEAD_OBJECT"));
441
442    EXPECT_THAT(toString(Status::fromStatusT(-EBUSY)), HasSubstr("busy"));
443
444    EXPECT_THAT(toString(Status::fromExceptionCode(Status::EX_NULL_POINTER)),
445            HasSubstr("EX_NULL_POINTER"));
446
447}
448
449int main(int argc, char **argv) {
450    ::testing::InitGoogleTest(&argc, argv);
451    return RUN_ALL_TESTS();
452}
453