test_main.cpp revision 0a35139d24ae0071475adeae3e1370b8f8617f8f 
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 <gmock/gmock.h>
21#include <gtest/gtest.h>
22#include <hidl/HidlSupport.h>
23#include <hidl/Status.h>
24#include <hidl/TaskRunner.h>
25#include <vector>
26
27#define EXPECT_ARRAYEQ(__a1__, __a2__, __size__) EXPECT_TRUE(isArrayEqual(__a1__, __a2__, __size__))
28#define EXPECT_2DARRAYEQ(__a1__, __a2__, __size1__, __size2__) \
29        EXPECT_TRUE(is2dArrayEqual(__a1__, __a2__, __size1__, __size2__))
30
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
39template<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
48class 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");
64    hidl_string s2a(nullptr); // copy constructor from null cstr
65    EXPECT_STREQ("", s2a);
66    s2a = nullptr; // = from nullptr cstr
67    EXPECT_STREQ(s2a.c_str(), "");
68    hidl_string s3 = hidl_string("s3"); // move =
69    EXPECT_STREQ(s3.c_str(), "s3");
70    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
75    EXPECT_STREQ(s6, "s6");
76    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");
82    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");
89
90    // casts
91    s = "great";
92    std::string myString = s;
93    const char *anotherCString = s;
94    EXPECT_EQ(myString, "great");
95    EXPECT_STREQ(anotherCString, "great");
96
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);
107    const char * cstr2 = "def";
108    std::string string2(cstr2);
109    hidl_string hs2(cstr2);
110
111    EXPECT_TRUE(hs1  == hsE);
112    EXPECT_FALSE(hs1 == hsNE);
113    EXPECT_TRUE(hs1  == cstrE);
114    EXPECT_FALSE(hs1 == cstrNE);
115    EXPECT_TRUE(hs1  == stringE);
116    EXPECT_FALSE(hs1 == stringNE);
117    EXPECT_FALSE(hs1 != hsE);
118    EXPECT_TRUE(hs1  != hsNE);
119    EXPECT_FALSE(hs1 != cstrE);
120    EXPECT_TRUE(hs1  != cstrNE);
121    EXPECT_FALSE(hs1 != stringE);
122    EXPECT_TRUE(hs1  != stringNE);
123
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);
134}
135
136TEST_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
160TEST_F(LibHidlTest, VecInitTest) {
161    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);
174
175    hidl_vec<int32_t> v3 = {5, 6, 7}; // initializer_list
176    EXPECT_EQ(v3.size(), 3ul);
177    EXPECT_ARRAYEQ(v3, array, v3.size());
178}
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);
183
184    auto iter = hv1.begin();    // iterator begin()
185    EXPECT_EQ(*iter++, 5);
186    EXPECT_EQ(*iter, 6);
187    EXPECT_EQ(*++iter, 7);
188    EXPECT_EQ(*iter--, 7);
189    EXPECT_EQ(*iter, 6);
190    EXPECT_EQ(*--iter, 5);
191
192    iter += 2;
193    EXPECT_EQ(*iter, 7);
194    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);
221
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);
227
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);
237}
238
239TEST_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
249TEST_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
257TEST_F(LibHidlTest, TaskRunnerTest) {
258    using android::hardware::details::TaskRunner;
259    TaskRunner tr;
260    bool flag = false;
261    tr.push([&] {
262        usleep(1000);
263        flag = true;
264    });
265    usleep(500);
266    EXPECT_FALSE(flag);
267    usleep(1000);
268    EXPECT_TRUE(flag);
269}
270
271TEST_F(LibHidlTest, StringCmpTest) {
272    using android::hardware::hidl_string;
273    const char * s = "good";
274    hidl_string hs(s);
275    EXPECT_NE(hs.c_str(), s);
276
277    EXPECT_TRUE(hs == s); // operator ==
278    EXPECT_TRUE(s == hs);
279
280    EXPECT_FALSE(hs != s); // operator ==
281    EXPECT_FALSE(s != hs);
282}
283
284template <typename T>
285void great(android::hardware::hidl_vec<T>) {}
286
287TEST_F(LibHidlTest, VecCopyTest) {
288    android::hardware::hidl_vec<int32_t> v;
289    great(v);
290}
291
292TEST_F(LibHidlTest, StdArrayTest) {
293    using android::hardware::hidl_array;
294    hidl_array<int32_t, 5> array{(int32_t[5]){1, 2, 3, 4, 5}};
295    std::array<int32_t, 5> stdArray = array;
296    EXPECT_ARRAYEQ(array.data(), stdArray.data(), 5);
297    hidl_array<int32_t, 5> array2 = stdArray;
298    EXPECT_ARRAYEQ(array.data(), array2.data(), 5);
299}
300
301TEST_F(LibHidlTest, MultiDimStdArrayTest) {
302    using android::hardware::hidl_array;
303    hidl_array<int32_t, 2, 3> array;
304    for (size_t i = 0; i < 2; i++) {
305        for (size_t j = 0; j < 3; j++) {
306            array[i][j] = i + j + i * j;
307        }
308    }
309    std::array<std::array<int32_t, 3>, 2> stdArray = array;
310    EXPECT_2DARRAYEQ(array, stdArray, 2, 3);
311    hidl_array<int32_t, 2, 3> array2 = stdArray;
312    EXPECT_2DARRAYEQ(array, array2, 2, 3);
313}
314
315TEST_F(LibHidlTest, HidlVersionTest) {
316    using android::hardware::hidl_version;
317    hidl_version v1_0{1, 0};
318    EXPECT_EQ(1, v1_0.get_major());
319    EXPECT_EQ(0, v1_0.get_minor());
320    hidl_version v2_0{2, 0};
321    hidl_version v2_1{2, 1};
322    hidl_version v2_2{2, 2};
323    hidl_version v3_0{3, 0};
324    hidl_version v3_0b{3,0};
325
326    EXPECT_TRUE(v1_0 < v2_0);
327    EXPECT_TRUE(v2_0 < v2_1);
328    EXPECT_TRUE(v2_1 < v3_0);
329    EXPECT_TRUE(v2_0 > v1_0);
330    EXPECT_TRUE(v2_1 > v2_0);
331    EXPECT_TRUE(v3_0 > v2_1);
332    EXPECT_TRUE(v3_0 == v3_0b);
333    EXPECT_TRUE(v3_0 <= v3_0b);
334    EXPECT_TRUE(v2_2 <= v3_0);
335    EXPECT_TRUE(v3_0 >= v3_0b);
336    EXPECT_TRUE(v3_0 >= v2_2);
337}
338
339TEST_F(LibHidlTest, ReturnMoveTest) {
340    using namespace ::android;
341    using ::android::hardware::Return;
342    using ::android::hardware::Status;
343    Return<void> ret{Status::fromStatusT(DEAD_OBJECT)};
344    ret.isOk();
345    ret = {Status::fromStatusT(DEAD_OBJECT)};
346    ret.isOk();
347}
348
349std::string toString(const ::android::hardware::Status &s) {
350    using ::android::hardware::operator<<;
351    std::ostringstream oss;
352    oss << s;
353    return oss.str();
354}
355
356TEST_F(LibHidlTest, StatusStringTest) {
357    using namespace ::android;
358    using ::android::hardware::Status;
359    using ::testing::HasSubstr;
360
361    EXPECT_EQ(toString(Status::ok()), "No error");
362
363    EXPECT_THAT(toString(Status::fromStatusT(DEAD_OBJECT)), HasSubstr("DEAD_OBJECT"));
364
365    EXPECT_THAT(toString(Status::fromStatusT(-EBUSY)), HasSubstr("busy"));
366
367    EXPECT_THAT(toString(Status::fromExceptionCode(Status::EX_NULL_POINTER)),
368            HasSubstr("EX_NULL_POINTER"));
369
370}
371
372int main(int argc, char **argv) {
373    ::testing::InitGoogleTest(&argc, argv);
374    return RUN_ALL_TESTS();
375}
376