test_main.cpp revision 9fcbb36250a4392b12012cf5177c4669ef10e654 
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 s3 = hidl_string("s3"); // move =
63    EXPECT_STREQ(s3.c_str(), "s3");
64    hidl_string s4(hidl_string(hidl_string("s4"))); // move constructor
65    EXPECT_STREQ(s4.c_str(), "s4");
66    hidl_string s5(std::string("s5")); // copy constructor from std::string
67    EXPECT_STREQ(s5, "s5");
68    hidl_string s6 = std::string("s6"); // copy = from std::string
69    EXPECT_STREQ(s6, "s6");
70    hidl_string s7(s6); // copy constructor
71    EXPECT_STREQ(s7, "s6");
72    hidl_string s8 = s7; // copy =
73    EXPECT_STREQ(s8, "s6");
74    char myCString[20] = "myCString";
75    s.setToExternal(&myCString[0], strlen(myCString));
76    EXPECT_STREQ(s, "myCString");
77    myCString[2] = 'D';
78    EXPECT_STREQ(s, "myDString");
79    s.clear(); // should not affect myCString
80    EXPECT_STREQ(myCString, "myDString");
81
82    // casts
83    s = "great";
84    std::string myString = s;
85    const char *anotherCString = s;
86    EXPECT_EQ(myString, "great");
87    EXPECT_STREQ(anotherCString, "great");
88
89    // Comparisons
90    const char * cstr1 = "abc";
91    std::string string1(cstr1);
92    hidl_string hs1(cstr1);
93    const char * cstrE = "abc";
94    std::string stringE(cstrE);
95    hidl_string hsE(cstrE);
96    const char * cstrNE = "ABC";
97    std::string stringNE(cstrNE);
98    hidl_string hsNE(cstrNE);
99    EXPECT_TRUE(hs1  == hsE);
100    EXPECT_FALSE(hs1 != hsE);
101    EXPECT_TRUE(hs1  != hsNE);
102    EXPECT_FALSE(hs1 == hsNE);
103    EXPECT_TRUE(hs1  == cstrE);
104    EXPECT_FALSE(hs1 != cstrE);
105    EXPECT_TRUE(hs1  != cstrNE);
106    EXPECT_FALSE(hs1 == cstrNE);
107    EXPECT_TRUE(hs1  == stringE);
108    EXPECT_FALSE(hs1 != stringE);
109    EXPECT_TRUE(hs1  != stringNE);
110    EXPECT_FALSE(hs1 == stringNE);
111}
112
113TEST_F(LibHidlTest, VecInitTest) {
114    using android::hardware::hidl_vec;
115    using std::vector;
116    int32_t array[] = {5, 6, 7};
117    vector<int32_t> v(array, array + 3);
118
119    hidl_vec<int32_t> hv1 = v; // copy =
120    EXPECT_ARRAYEQ(hv1, array, 3);
121    EXPECT_ARRAYEQ(hv1, v, 3);
122    hidl_vec<int32_t> hv2(v); // copy constructor
123    EXPECT_ARRAYEQ(hv2, v, 3);
124
125    vector<int32_t> v2 = hv1; // cast
126    EXPECT_ARRAYEQ(v2, v, 3);
127
128    hidl_vec<int32_t> v3 = {5, 6, 7}; // initializer_list
129    EXPECT_EQ(v3.size(), 3ul);
130    EXPECT_ARRAYEQ(v3, array, v3.size());
131}
132
133TEST_F(LibHidlTest, VecIterTest) {
134    int32_t array[] = {5, 6, 7};
135    android::hardware::hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
136
137    auto iter = hv1.begin();    // iterator begin()
138    EXPECT_EQ(*iter++, 5);
139    EXPECT_EQ(*iter, 6);
140    EXPECT_EQ(*++iter, 7);
141    EXPECT_EQ(*iter--, 7);
142    EXPECT_EQ(*iter, 6);
143    EXPECT_EQ(*--iter, 5);
144
145    iter += 2;
146    EXPECT_EQ(*iter, 7);
147    iter -= 2;
148    EXPECT_EQ(*iter, 5);
149
150    iter++;
151    EXPECT_EQ(*(iter + 1), 7);
152    EXPECT_EQ(*(1 + iter), 7);
153    EXPECT_EQ(*(iter - 1), 5);
154    EXPECT_EQ(*iter, 6);
155
156    auto five = iter - 1;
157    auto seven = iter + 1;
158    EXPECT_EQ(seven - five, 2);
159    EXPECT_EQ(five - seven, -2);
160
161    EXPECT_LT(five, seven);
162    EXPECT_LE(five, seven);
163    EXPECT_GT(seven, five);
164    EXPECT_GE(seven, five);
165
166    EXPECT_EQ(seven[0], 7);
167    EXPECT_EQ(five[1], 6);
168}
169
170TEST_F(LibHidlTest, VecIterForTest) {
171    using android::hardware::hidl_vec;
172    int32_t array[] = {5, 6, 7};
173    hidl_vec<int32_t> hv1 = std::vector<int32_t>(array, array + 3);
174
175    int32_t sum = 0;            // range based for loop interoperability
176    for (auto &&i: hv1) {
177        sum += i;
178    }
179    EXPECT_EQ(sum, 5+6+7);
180
181    for (auto iter = hv1.begin(); iter < hv1.end(); ++iter) {
182        *iter += 10;
183    }
184    const hidl_vec<int32_t> &v4 = hv1;
185    sum = 0;
186    for (const auto &i : v4) {
187        sum += i;
188    }
189    EXPECT_EQ(sum, 15+16+17);
190}
191
192TEST_F(LibHidlTest, VecEqTest) {
193    android::hardware::hidl_vec<int32_t> hv1{5, 6, 7};
194    android::hardware::hidl_vec<int32_t> hv2{5, 6, 7};
195    android::hardware::hidl_vec<int32_t> hv3{5, 6, 8};
196
197    // use the == and != operator intentionally here
198    EXPECT_TRUE(hv1 == hv2);
199    EXPECT_TRUE(hv1 != hv3);
200}
201
202TEST_F(LibHidlTest, ArrayTest) {
203    using android::hardware::hidl_array;
204    int32_t array[] = {5, 6, 7};
205
206    hidl_array<int32_t, 3> ha(array);
207    EXPECT_ARRAYEQ(ha, array, 3);
208}
209
210TEST_F(LibHidlTest, TaskRunnerTest) {
211    using android::hardware::TaskRunner;
212    TaskRunner tr;
213    bool flag = false;
214    tr.push([&] {
215        usleep(1000);
216        flag = true;
217    });
218    usleep(500);
219    EXPECT_FALSE(flag);
220    usleep(1000);
221    EXPECT_TRUE(flag);
222}
223
224TEST_F(LibHidlTest, StringCmpTest) {
225    using android::hardware::hidl_string;
226    const char * s = "good";
227    hidl_string hs(s);
228    EXPECT_NE(hs.c_str(), s);
229
230    EXPECT_TRUE(hs == s); // operator ==
231    EXPECT_TRUE(s == hs);
232
233    EXPECT_FALSE(hs != s); // operator ==
234    EXPECT_FALSE(s != hs);
235}
236
237template <typename T>
238void great(android::hardware::hidl_vec<T>) {}
239
240TEST_F(LibHidlTest, VecCopyTest) {
241    android::hardware::hidl_vec<int32_t> v;
242    great(v);
243}
244
245TEST_F(LibHidlTest, StdArrayTest) {
246    using android::hardware::hidl_array;
247    hidl_array<int32_t, 5> array{(int32_t[5]){1, 2, 3, 4, 5}};
248    std::array<int32_t, 5> stdArray = array;
249    EXPECT_ARRAYEQ(array.data(), stdArray.data(), 5);
250    hidl_array<int32_t, 5> array2 = stdArray;
251    EXPECT_ARRAYEQ(array.data(), array2.data(), 5);
252}
253
254TEST_F(LibHidlTest, MultiDimStdArrayTest) {
255    using android::hardware::hidl_array;
256    hidl_array<int32_t, 2, 3> array;
257    for (size_t i = 0; i < 2; i++) {
258        for (size_t j = 0; j < 3; j++) {
259            array[i][j] = i + j + i * j;
260        }
261    }
262    std::array<std::array<int32_t, 3>, 2> stdArray = array;
263    EXPECT_2DARRAYEQ(array, stdArray, 2, 3);
264    hidl_array<int32_t, 2, 3> array2 = stdArray;
265    EXPECT_2DARRAYEQ(array, array2, 2, 3);
266}
267
268TEST_F(LibHidlTest, HidlVersionTest) {
269    using android::hardware::hidl_version;
270    hidl_version v1_0{1, 0};
271    EXPECT_EQ(1, v1_0.get_major());
272    EXPECT_EQ(0, v1_0.get_minor());
273    hidl_version v2_0{2, 0};
274    hidl_version v2_1{2, 1};
275    hidl_version v2_2{2, 2};
276    hidl_version v3_0{3, 0};
277    hidl_version v3_0b{3,0};
278
279    EXPECT_TRUE(v1_0 < v2_0);
280    EXPECT_TRUE(v2_0 < v2_1);
281    EXPECT_TRUE(v2_1 < v3_0);
282    EXPECT_TRUE(v2_0 > v1_0);
283    EXPECT_TRUE(v2_1 > v2_0);
284    EXPECT_TRUE(v3_0 > v2_1);
285    EXPECT_TRUE(v3_0 == v3_0b);
286    EXPECT_TRUE(v3_0 <= v3_0b);
287    EXPECT_TRUE(v2_2 <= v3_0);
288    EXPECT_TRUE(v3_0 >= v3_0b);
289    EXPECT_TRUE(v3_0 >= v2_2);
290}
291
292
293int main(int argc, char **argv) {
294    ::testing::InitGoogleTest(&argc, argv);
295    return RUN_ALL_TESTS();
296}
297