test_main.cpp revision a21d84f11f066315bd1476368d511286d129cb8a 
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 <gtest/gtest.h>
21#include <hidl/HidlSupport.h>
22#include <hidl/TaskRunner.h>
23#include <vector>
24
25#define EXPECT_ARRAYEQ(__a1__, __a2__, __size__) EXPECT_TRUE(isArrayEqual(__a1__, __a2__, __size__))
26#define EXPECT_2DARRAYEQ(__a1__, __a2__, __size1__, __size2__) \
27        EXPECT_TRUE(is2dArrayEqual(__a1__, __a2__, __size1__, __size2__))
28
29template<typename T, typename S>
30static inline bool isArrayEqual(const T arr1, const S arr2, size_t size) {
31    for(size_t i = 0; i < size; i++)
32        if(arr1[i] != arr2[i])
33            return false;
34    return true;
35}
36
37template<typename T, typename S>
38static inline bool is2dArrayEqual(const T arr1, const S arr2, size_t size1, size_t size2) {
39    for(size_t i = 0; i < size1; i++)
40        for (size_t j = 0; j < size2; j++)
41            if(arr1[i][j] != arr2[i][j])
42                return false;
43    return true;
44}
45
46class LibHidlTest : public ::testing::Test {
47public:
48    virtual void SetUp() override {
49    }
50    virtual void TearDown() override {
51    }
52};
53
54TEST_F(LibHidlTest, StringTest) {
55    using android::hardware::hidl_string;
56    hidl_string s; // empty constructor
57    EXPECT_STREQ(s.c_str(), "");
58    hidl_string s1 = "s1"; // copy = from cstr
59    EXPECT_STREQ(s1.c_str(), "s1");
60    hidl_string s2("s2"); // copy constructor from cstr
61    EXPECT_STREQ(s2.c_str(), "s2");
62    hidl_string s2a(nullptr); // copy constructor from null cstr
63    EXPECT_STREQ("", s2a);
64    hidl_string s3 = hidl_string("s3"); // move =
65    EXPECT_STREQ(s3.c_str(), "s3");
66    hidl_string s4 = hidl_string("12345", 3); // copy constructor from cstr w/ length
67    EXPECT_STREQ(s4.c_str(), "123");
68    hidl_string s5(hidl_string(hidl_string("s5"))); // move constructor
69    EXPECT_STREQ(s5.c_str(), "s5");
70    hidl_string s6(std::string("s6")); // copy constructor from std::string
71    EXPECT_STREQ(s6, "s6");
72    hidl_string s7 = std::string("s7"); // copy = from std::string
73    EXPECT_STREQ(s7, "s7");
74    hidl_string s8(s7); // copy constructor
75    EXPECT_STREQ(s8, "s7");
76    hidl_string s9 = s8; // copy =
77    EXPECT_STREQ(s9, "s7");
78    char myCString[20] = "myCString";
79    s.setToExternal(&myCString[0], strlen(myCString));
80    EXPECT_STREQ(s, "myCString");
81    myCString[2] = 'D';
82    EXPECT_STREQ(s, "myDString");
83    s.clear(); // should not affect myCString
84    EXPECT_STREQ(myCString, "myDString");
85
86    // casts
87    s = "great";
88    std::string myString = s;
89    const char *anotherCString = s;
90    EXPECT_EQ(myString, "great");
91    EXPECT_STREQ(anotherCString, "great");
92
93    // Comparisons
94    const char * cstr1 = "abc";
95    std::string string1(cstr1);
96    hidl_string hs1(cstr1);
97    const char * cstrE = "abc";
98    std::string stringE(cstrE);
99    hidl_string hsE(cstrE);
100    const char * cstrNE = "ABC";
101    std::string stringNE(cstrNE);
102    hidl_string hsNE(cstrNE);
103    const char * cstr2 = "def";
104    std::string string2(cstr2);
105    hidl_string hs2(cstr2);
106
107    EXPECT_TRUE(hs1  == hsE);
108    EXPECT_FALSE(hs1 == hsNE);
109    EXPECT_TRUE(hs1  == cstrE);
110    EXPECT_FALSE(hs1 == cstrNE);
111    EXPECT_TRUE(hs1  == stringE);
112    EXPECT_FALSE(hs1 == stringNE);
113    EXPECT_FALSE(hs1 != hsE);
114    EXPECT_TRUE(hs1  != hsNE);
115    EXPECT_FALSE(hs1 != cstrE);
116    EXPECT_TRUE(hs1  != cstrNE);
117    EXPECT_FALSE(hs1 != stringE);
118    EXPECT_TRUE(hs1  != stringNE);
119
120    EXPECT_TRUE(hs1 < hs2);
121    EXPECT_FALSE(hs2 < hs1);
122    EXPECT_TRUE(hs2 > hs1);
123    EXPECT_FALSE(hs1 > hs2);
124    EXPECT_TRUE(hs1 <= hs1);
125    EXPECT_TRUE(hs1 <= hs2);
126    EXPECT_FALSE(hs2 <= hs1);
127    EXPECT_TRUE(hs1 >= hs1);
128    EXPECT_TRUE(hs2 >= hs1);
129    EXPECT_FALSE(hs2 <= hs1);
130}
131
132TEST_F(LibHidlTest, MemoryTest) {
133    using android::hardware::hidl_memory;
134
135    hidl_memory mem1 = hidl_memory(); // default constructor
136    hidl_memory mem2 = mem1; // copy constructor (nullptr)
137
138    EXPECT_EQ(nullptr, mem2.handle());
139
140    native_handle_t* testHandle = native_handle_create(0 /* numInts */, 0 /* numFds */);
141
142    hidl_memory mem3 = hidl_memory("foo", testHandle, 42 /* size */); // owns testHandle
143    hidl_memory mem4 = mem3; // copy constructor (regular handle)
144
145    EXPECT_EQ(mem3.name(), mem4.name());
146    EXPECT_EQ(mem3.size(), mem4.size());
147    EXPECT_NE(nullptr, mem4.handle());
148    EXPECT_NE(mem3.handle(), mem4.handle()); // check handle cloned
149
150    hidl_memory mem5 = hidl_memory("foo", nullptr, 0); // hidl memory works with nullptr handle
151    hidl_memory mem6 = mem5;
152    EXPECT_EQ(nullptr, mem5.handle());
153    EXPECT_EQ(nullptr, mem6.handle());
154}
155
156TEST_F(LibHidlTest, VecInitTest) {
157    using android::hardware::hidl_vec;
158    using std::vector;
159    int32_t array[] = {5, 6, 7};
160    vector<int32_t> v(array, array + 3);
161
162    hidl_vec<int32_t> hv1 = v; // copy =
163    EXPECT_ARRAYEQ(hv1, array, 3);
164    EXPECT_ARRAYEQ(hv1, v, 3);
165    hidl_vec<int32_t> hv2(v); // copy constructor
166    EXPECT_ARRAYEQ(hv2, v, 3);
167
168    vector<int32_t> v2 = hv1; // cast
169    EXPECT_ARRAYEQ(v2, v, 3);
170
171    hidl_vec<int32_t> v3 = {5, 6, 7}; // initializer_list
172    EXPECT_EQ(v3.size(), 3ul);
173    EXPECT_ARRAYEQ(v3, array, v3.size());
174}
175
176TEST_F(LibHidlTest, VecIterTest) {
177    int32_t array[] = {5, 6, 7};
178    android::hardware::hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
179
180    auto iter = hv1.begin();    // iterator begin()
181    EXPECT_EQ(*iter++, 5);
182    EXPECT_EQ(*iter, 6);
183    EXPECT_EQ(*++iter, 7);
184    EXPECT_EQ(*iter--, 7);
185    EXPECT_EQ(*iter, 6);
186    EXPECT_EQ(*--iter, 5);
187
188    iter += 2;
189    EXPECT_EQ(*iter, 7);
190    iter -= 2;
191    EXPECT_EQ(*iter, 5);
192
193    iter++;
194    EXPECT_EQ(*(iter + 1), 7);
195    EXPECT_EQ(*(1 + iter), 7);
196    EXPECT_EQ(*(iter - 1), 5);
197    EXPECT_EQ(*iter, 6);
198
199    auto five = iter - 1;
200    auto seven = iter + 1;
201    EXPECT_EQ(seven - five, 2);
202    EXPECT_EQ(five - seven, -2);
203
204    EXPECT_LT(five, seven);
205    EXPECT_LE(five, seven);
206    EXPECT_GT(seven, five);
207    EXPECT_GE(seven, five);
208
209    EXPECT_EQ(seven[0], 7);
210    EXPECT_EQ(five[1], 6);
211}
212
213TEST_F(LibHidlTest, VecIterForTest) {
214    using android::hardware::hidl_vec;
215    int32_t array[] = {5, 6, 7};
216    hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
217
218    int32_t sum = 0;            // range based for loop interoperability
219    for (auto &&i: hv1) {
220        sum += i;
221    }
222    EXPECT_EQ(sum, 5+6+7);
223
224    for (auto iter = hv1.begin(); iter < hv1.end(); ++iter) {
225        *iter += 10;
226    }
227    const hidl_vec<int32_t> &v4 = hv1;
228    sum = 0;
229    for (const auto &i : v4) {
230        sum += i;
231    }
232    EXPECT_EQ(sum, 15+16+17);
233}
234
235TEST_F(LibHidlTest, VecEqTest) {
236    android::hardware::hidl_vec<int32_t> hv1{5, 6, 7};
237    android::hardware::hidl_vec<int32_t> hv2{5, 6, 7};
238    android::hardware::hidl_vec<int32_t> hv3{5, 6, 8};
239
240    // use the == and != operator intentionally here
241    EXPECT_TRUE(hv1 == hv2);
242    EXPECT_TRUE(hv1 != hv3);
243}
244
245TEST_F(LibHidlTest, ArrayTest) {
246    using android::hardware::hidl_array;
247    int32_t array[] = {5, 6, 7};
248
249    hidl_array<int32_t, 3> ha(array);
250    EXPECT_ARRAYEQ(ha, array, 3);
251}
252
253TEST_F(LibHidlTest, TaskRunnerTest) {
254    using android::hardware::TaskRunner;
255    TaskRunner tr;
256    bool flag = false;
257    tr.push([&] {
258        usleep(1000);
259        flag = true;
260    });
261    usleep(500);
262    EXPECT_FALSE(flag);
263    usleep(1000);
264    EXPECT_TRUE(flag);
265}
266
267TEST_F(LibHidlTest, StringCmpTest) {
268    using android::hardware::hidl_string;
269    const char * s = "good";
270    hidl_string hs(s);
271    EXPECT_NE(hs.c_str(), s);
272
273    EXPECT_TRUE(hs == s); // operator ==
274    EXPECT_TRUE(s == hs);
275
276    EXPECT_FALSE(hs != s); // operator ==
277    EXPECT_FALSE(s != hs);
278}
279
280template <typename T>
281void great(android::hardware::hidl_vec<T>) {}
282
283TEST_F(LibHidlTest, VecCopyTest) {
284    android::hardware::hidl_vec<int32_t> v;
285    great(v);
286}
287
288TEST_F(LibHidlTest, StdArrayTest) {
289    using android::hardware::hidl_array;
290    hidl_array<int32_t, 5> array{(int32_t[5]){1, 2, 3, 4, 5}};
291    std::array<int32_t, 5> stdArray = array;
292    EXPECT_ARRAYEQ(array.data(), stdArray.data(), 5);
293    hidl_array<int32_t, 5> array2 = stdArray;
294    EXPECT_ARRAYEQ(array.data(), array2.data(), 5);
295}
296
297TEST_F(LibHidlTest, MultiDimStdArrayTest) {
298    using android::hardware::hidl_array;
299    hidl_array<int32_t, 2, 3> array;
300    for (size_t i = 0; i < 2; i++) {
301        for (size_t j = 0; j < 3; j++) {
302            array[i][j] = i + j + i * j;
303        }
304    }
305    std::array<std::array<int32_t, 3>, 2> stdArray = array;
306    EXPECT_2DARRAYEQ(array, stdArray, 2, 3);
307    hidl_array<int32_t, 2, 3> array2 = stdArray;
308    EXPECT_2DARRAYEQ(array, array2, 2, 3);
309}
310
311TEST_F(LibHidlTest, HidlVersionTest) {
312    using android::hardware::hidl_version;
313    hidl_version v1_0{1, 0};
314    EXPECT_EQ(1, v1_0.get_major());
315    EXPECT_EQ(0, v1_0.get_minor());
316    hidl_version v2_0{2, 0};
317    hidl_version v2_1{2, 1};
318    hidl_version v2_2{2, 2};
319    hidl_version v3_0{3, 0};
320    hidl_version v3_0b{3,0};
321
322    EXPECT_TRUE(v1_0 < v2_0);
323    EXPECT_TRUE(v2_0 < v2_1);
324    EXPECT_TRUE(v2_1 < v3_0);
325    EXPECT_TRUE(v2_0 > v1_0);
326    EXPECT_TRUE(v2_1 > v2_0);
327    EXPECT_TRUE(v3_0 > v2_1);
328    EXPECT_TRUE(v3_0 == v3_0b);
329    EXPECT_TRUE(v3_0 <= v3_0b);
330    EXPECT_TRUE(v2_2 <= v3_0);
331    EXPECT_TRUE(v3_0 >= v3_0b);
332    EXPECT_TRUE(v3_0 >= v2_2);
333}
334
335
336int main(int argc, char **argv) {
337    ::testing::InitGoogleTest(&argc, argv);
338    return RUN_ALL_TESTS();
339}
340