test_main.cpp revision 6f6675464c82fc796d72458d7268e28d759b997f
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 tr.start(1 /* limit */); 261 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 272TEST_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 285template <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 293TEST_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 316TEST_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 340TEST_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} 349 350std::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 368 EXPECT_THAT(toString(Status::fromExceptionCode(Status::EX_NULL_POINTER)), 369 HasSubstr("EX_NULL_POINTER")); 370 371} 372 373int main(int argc, char **argv) { 374 ::testing::InitGoogleTest(&argc, argv); 375 return RUN_ALL_TESTS(); 376} 377