1 /* 2 * Copyright (C) 2017 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_NDEBUG 0 18 #define LOG_TAG "hidl_test_java_native" 19 20 #include <android-base/logging.h> 21 22 #include <android/hardware/tests/baz/1.0/IBaz.h> 23 24 #include <hidl/LegacySupport.h> 25 26 #include <gtest/gtest.h> 27 28 #include <hidl/HidlTransportSupport.h> 29 #include <hidl/Status.h> 30 using ::android::sp; 31 using ::android::hardware::tests::baz::V1_0::IBase; 32 using ::android::hardware::tests::baz::V1_0::IBaz; 33 using ::android::hardware::tests::baz::V1_0::IBazCallback; 34 35 using ::android::hardware::hidl_array; 36 using ::android::hardware::hidl_vec; 37 using ::android::hardware::hidl_string; 38 using ::android::hardware::defaultPassthroughServiceImplementation; 39 using ::android::hardware::Return; 40 using ::android::hardware::Void; 41 42 struct BazCallback : public IBazCallback { 43 Return<void> heyItsMe(const sp<IBazCallback> &cb) override; 44 Return<void> hey() override; 45 }; 46 47 Return<void> BazCallback::heyItsMe( 48 const sp<IBazCallback> &cb) { 49 LOG(INFO) << "SERVER: heyItsMe cb = " << cb.get(); 50 51 return Void(); 52 } 53 54 Return<void> BazCallback::hey() { 55 LOG(INFO) << "SERVER: hey"; 56 57 return Void(); 58 } 59 60 using std::to_string; 61 62 static void usage(const char *me) { 63 fprintf(stderr, "%s [-c]lient | [-s]erver\n", me); 64 } 65 66 struct HidlEnvironment : public ::testing::Environment { 67 void SetUp() override { 68 } 69 70 void TearDown() override { 71 } 72 }; 73 74 struct HidlTest : public ::testing::Test { 75 sp<IBaz> baz; 76 77 void SetUp() override { 78 using namespace ::android::hardware; 79 80 baz = IBaz::getService("baz"); 81 82 CHECK(baz != NULL); 83 } 84 85 void TearDown() override { 86 } 87 }; 88 89 template <typename T> 90 static void EXPECT_OK(const ::android::hardware::Return<T> &ret) { 91 EXPECT_TRUE(ret.isOk()); 92 } 93 94 TEST_F(HidlTest, GetDescriptorTest) { 95 EXPECT_OK(baz->interfaceDescriptor([&] (const auto &desc) { 96 EXPECT_EQ(desc, IBaz::descriptor); 97 })); 98 } 99 100 TEST_F(HidlTest, BazSomeBaseMethodTest) { 101 EXPECT_OK(baz->someBaseMethod()); 102 } 103 104 TEST_F(HidlTest, BazSomeOtherBaseMethodTest) { 105 IBase::Foo foo; 106 foo.x = 1; 107 foo.y.z = 2.5; 108 // A valid UTF-8 string 109 foo.y.s = "Hello, world, \x46\x6F\x6F\x20\xC2\xA9\x20\x62\x61\x72\x20\xF0\x9D\x8C\x86\x20\x54\x72\x65\x62\x6C\x65\x20\xE2\x98\x83\x20\x72\x6F\x63\x6B\x73"; 110 111 foo.aaa.resize(5); 112 for (size_t i = 0; i < foo.aaa.size(); ++i) { 113 foo.aaa[i].z = 1.0f + (float)i * 0.01f; 114 foo.aaa[i].s = ("Hello, world " + std::to_string(i)).c_str(); 115 } 116 117 EXPECT_OK( 118 baz->someOtherBaseMethod( 119 foo, 120 [&](const auto &result) { 121 // Strings should have the same size as they did before 122 // marshaling. b/35038064 123 EXPECT_EQ(result.y.s.size(), foo.y.s.size()); 124 EXPECT_EQ(foo, result); 125 })); 126 } 127 128 TEST_F(HidlTest, BazSomeMethodWithFooArraysTest) { 129 hidl_array<IBase::Foo, 2> foo; 130 131 foo[0].x = 1; 132 foo[0].y.z = 2.5; 133 foo[0].y.s = "Hello, world"; 134 135 foo[0].aaa.resize(5); 136 for (size_t i = 0; i < foo[0].aaa.size(); ++i) { 137 foo[0].aaa[i].z = 1.0f + (float)i * 0.01f; 138 foo[0].aaa[i].s = ("Hello, world " + std::to_string(i)).c_str(); 139 } 140 141 foo[1].x = 2; 142 foo[1].y.z = -2.5; 143 foo[1].y.s = "Morituri te salutant"; 144 145 foo[1].aaa.resize(3); 146 for (size_t i = 0; i < foo[1].aaa.size(); ++i) { 147 foo[1].aaa[i].z = 2.0f - (float)i * 0.01f; 148 foo[1].aaa[i].s = ("Alea iacta est: " + std::to_string(i)).c_str(); 149 } 150 151 hidl_array<IBaz::Foo, 2> fooExpectedOutput; 152 fooExpectedOutput[0] = foo[1]; 153 fooExpectedOutput[1] = foo[0]; 154 155 EXPECT_OK( 156 baz->someMethodWithFooArrays( 157 foo, 158 [&](const auto &result) { 159 EXPECT_EQ(result, fooExpectedOutput); 160 })); 161 } 162 163 TEST_F(HidlTest, BazSomeMethodWithFooVectorsTest) { 164 hidl_vec<IBase::Foo> foo; 165 foo.resize(2); 166 167 foo[0].x = 1; 168 foo[0].y.z = 2.5; 169 foo[0].y.s = "Hello, world"; 170 171 foo[0].aaa.resize(5); 172 for (size_t i = 0; i < foo[0].aaa.size(); ++i) { 173 foo[0].aaa[i].z = 1.0f + (float)i * 0.01f; 174 foo[0].aaa[i].s = ("Hello, world " + std::to_string(i)).c_str(); 175 } 176 177 foo[1].x = 2; 178 foo[1].y.z = -2.5; 179 foo[1].y.s = "Morituri te salutant"; 180 181 foo[1].aaa.resize(3); 182 for (size_t i = 0; i < foo[1].aaa.size(); ++i) { 183 foo[1].aaa[i].z = 2.0f - (float)i * 0.01f; 184 foo[1].aaa[i].s = ("Alea iacta est: " + std::to_string(i)).c_str(); 185 } 186 187 hidl_vec<IBaz::Foo> fooExpectedOutput; 188 fooExpectedOutput.resize(2); 189 fooExpectedOutput[0] = foo[1]; 190 fooExpectedOutput[1] = foo[0]; 191 192 EXPECT_OK( 193 baz->someMethodWithFooVectors( 194 foo, 195 [&](const auto &result) { 196 EXPECT_EQ(result, fooExpectedOutput); 197 })); 198 } 199 200 TEST_F(HidlTest, BazSomeMethodWithVectorOfArray) { 201 IBase::VectorOfArray in, expectedOut; 202 in.addresses.resize(3); 203 expectedOut.addresses.resize(3); 204 205 size_t k = 0; 206 const size_t n = in.addresses.size(); 207 208 for (size_t i = 0; i < n; ++i) { 209 for (size_t j = 0; j < 6; ++j, ++k) { 210 in.addresses[i][j] = k; 211 expectedOut.addresses[n - 1 - i][j] = k; 212 } 213 } 214 215 EXPECT_OK( 216 baz->someMethodWithVectorOfArray( 217 in, 218 [&](const auto &out) { 219 EXPECT_EQ(expectedOut, out); 220 })); 221 } 222 223 TEST_F(HidlTest, BazSomeMethodTakingAVectorOfArray) { 224 hidl_vec<hidl_array<uint8_t, 6> > in, expectedOut; 225 in.resize(3); 226 expectedOut.resize(3); 227 228 size_t k = 0; 229 const size_t n = in.size(); 230 for (size_t i = 0; i < n; ++i) { 231 for (size_t j = 0; j < 6; ++j, ++k) { 232 in[i][j] = k; 233 expectedOut[n - 1 - i][j] = k; 234 } 235 } 236 237 EXPECT_OK( 238 baz->someMethodTakingAVectorOfArray( 239 in, 240 [&](const auto &out) { 241 EXPECT_EQ(expectedOut, out); 242 })); 243 } 244 245 static std::string numberToEnglish(int x) { 246 static const char *const kDigits[] = { 247 "zero", 248 "one", 249 "two", 250 "three", 251 "four", 252 "five", 253 "six", 254 "seven", 255 "eight", 256 "nine", 257 }; 258 259 if (x < 0) { 260 return "negative " + numberToEnglish(-x); 261 } 262 263 if (x < 10) { 264 return kDigits[x]; 265 } 266 267 if (x <= 15) { 268 static const char *const kSpecialTens[] = { 269 "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", 270 }; 271 272 return kSpecialTens[x - 10]; 273 } 274 275 if (x < 20) { 276 return std::string(kDigits[x % 10]) + "teen"; 277 } 278 279 if (x < 100) { 280 static const char *const kDecades[] = { 281 "twenty", "thirty", "forty", "fifty", "sixty", "seventy", 282 "eighty", "ninety", 283 }; 284 285 return std::string(kDecades[x / 10 - 2]) + kDigits[x % 10]; 286 } 287 288 return "positively huge!"; 289 } 290 291 TEST_F(HidlTest, BazTransposeTest) { 292 IBase::StringMatrix5x3 in; 293 IBase::StringMatrix3x5 expectedOut; 294 295 for (int i = 0; i < 5; ++i) { 296 for (int j = 0; j < 3; ++j) { 297 in.s[i][j] = expectedOut.s[j][i] = numberToEnglish(3 * i + j + 1).c_str(); 298 } 299 } 300 301 EXPECT_OK(baz->transpose( 302 in, 303 [&](const auto &out) { 304 EXPECT_EQ(expectedOut, out); 305 })); 306 } 307 308 TEST_F(HidlTest, BazTranspose2Test) { 309 hidl_array<hidl_string, 5, 3> in; 310 hidl_array<hidl_string, 3, 5> expectedOut; 311 312 for (int i = 0; i < 5; ++i) { 313 for (int j = 0; j < 3; ++j) { 314 in[i][j] = expectedOut[j][i] = numberToEnglish(3 * i + j + 1).c_str(); 315 } 316 } 317 318 EXPECT_OK(baz->transpose2( 319 in, 320 [&](const auto &out) { 321 EXPECT_EQ(expectedOut, out); 322 })); 323 } 324 325 TEST_F(HidlTest, BazSomeBoolMethodTest) { 326 auto result = baz->someBoolMethod(true); 327 EXPECT_OK(result); 328 EXPECT_EQ(result, false); 329 } 330 331 TEST_F(HidlTest, BazSomeBoolArrayMethodTest) { 332 hidl_array<bool, 3> someBoolArray; 333 someBoolArray[0] = true; 334 someBoolArray[1] = false; 335 someBoolArray[2] = true; 336 337 hidl_array<bool, 4> expectedOut; 338 expectedOut[0] = false; 339 expectedOut[1] = true; 340 expectedOut[2] = false; 341 expectedOut[3] = true; 342 343 EXPECT_OK( 344 baz->someBoolArrayMethod( 345 someBoolArray, 346 [&](const auto &result) { 347 EXPECT_EQ(expectedOut, result); 348 })); 349 } 350 351 TEST_F(HidlTest, BazSomeBoolVectorMethodTest) { 352 hidl_vec<bool> someBoolVector, expected; 353 someBoolVector.resize(4); 354 expected.resize(4); 355 356 for (size_t i = 0; i < someBoolVector.size(); ++i) { 357 someBoolVector[i] = ((i & 1) == 0); 358 expected[i] = !someBoolVector[i]; 359 } 360 361 EXPECT_OK( 362 baz->someBoolVectorMethod( 363 someBoolVector, 364 [&](const auto &result) { 365 EXPECT_EQ(expected, result); 366 })); 367 } 368 369 TEST_F(HidlTest, BazDoThisMethodTest) { 370 EXPECT_OK(baz->doThis(1.0f)); 371 } 372 373 TEST_F(HidlTest, BazDoThatAndReturnSomethingMethodTest) { 374 auto result = baz->doThatAndReturnSomething(1); 375 EXPECT_OK(result); 376 EXPECT_EQ(result, 666); 377 } 378 379 TEST_F(HidlTest, BazDoQuiteABitMethodTest) { 380 auto result = baz->doQuiteABit(1, 2ll, 3.0f, 4.0); 381 382 EXPECT_OK(result); 383 EXPECT_EQ(result, 666.5); 384 } 385 386 TEST_F(HidlTest, BazDoSomethingElseMethodTest) { 387 hidl_array<int32_t, 15> param; 388 hidl_array<int32_t, 32> expected; 389 390 for (size_t i = 0; i < 15; ++i) { 391 param[i] = expected[15 + i] = i; 392 expected[i] = 2 * i; 393 } 394 395 expected[30] = 1; 396 expected[31] = 2; 397 398 EXPECT_OK( 399 baz->doSomethingElse( 400 param, 401 [&](const auto &result) { 402 EXPECT_EQ(expected, result); 403 })); 404 } 405 406 TEST_F(HidlTest, BazDoStuffAndReturnAStringMethodTest) { 407 std::string expected = "Hello, world!"; 408 EXPECT_OK( 409 baz->doStuffAndReturnAString( 410 [&](const auto &result) { 411 EXPECT_EQ(expected, result); 412 })); 413 } 414 415 TEST_F(HidlTest, BazMapThisVectorMethodTest) { 416 hidl_vec<int32_t> vec_param, expected; 417 vec_param.resize(15); 418 expected.resize(15); 419 420 for (size_t i = 0; i < 15; ++i) { 421 vec_param[i] = i; 422 expected[i] = 2 * i; 423 } 424 425 EXPECT_OK( 426 baz->mapThisVector( 427 vec_param, 428 [&](const auto &result) { 429 EXPECT_EQ(expected, result); 430 })); 431 } 432 433 TEST_F(HidlTest, BazCallMeMethodTest) { 434 EXPECT_OK(baz->callMe(new BazCallback())); 435 } 436 437 TEST_F(HidlTest, BazCallMeLaterMethodTest) { 438 EXPECT_OK(baz->callMeLater(new BazCallback())); 439 EXPECT_OK(baz->iAmFreeNow()); 440 } 441 442 TEST_F(HidlTest, BazUseAnEnumMethodTest) { 443 auto result = baz->useAnEnum(IBaz::SomeEnum::bar); 444 445 EXPECT_OK(result); 446 EXPECT_TRUE(result == IBaz::SomeEnum::quux); 447 } 448 449 TEST_F(HidlTest, BazHaveSomeStringsMethodTest) { 450 hidl_array<hidl_string, 3> string_params; 451 string_params[0] = "one"; 452 string_params[1] = "two"; 453 string_params[2] = "three"; 454 455 hidl_array<hidl_string, 2> expected; 456 expected[0] = "Hello"; 457 expected[1] = "World"; 458 459 EXPECT_OK( 460 baz->haveSomeStrings( 461 string_params, 462 [&](const auto &result) { 463 EXPECT_EQ(expected, result); 464 })); 465 } 466 467 TEST_F(HidlTest, BazHaveAStringVecMethodTest) { 468 hidl_vec<hidl_string> string_vec{ "Uno", "Dos", "Tres", "Cuatro" }; 469 hidl_vec<hidl_string> expected{"Hello", "World"}; 470 471 EXPECT_OK( 472 baz->haveAStringVec( 473 string_vec, 474 [&](const auto &result) { 475 EXPECT_EQ(expected, result); 476 })); 477 } 478 479 TEST_F(HidlTest, BazReturnABunchOfStringsMethodTest) { 480 std::string expectedA = "Eins"; 481 std::string expectedB = "Zwei"; 482 std::string expectedC = "Drei"; 483 EXPECT_OK( 484 baz->returnABunchOfStrings( 485 [&](const auto &a, const auto &b, const auto &c) { 486 EXPECT_EQ(a, expectedA); 487 EXPECT_EQ(b, expectedB); 488 EXPECT_EQ(c, expectedC); 489 })); 490 } 491 492 int main(int argc, char **argv) { 493 setenv("TREBLE_TESTING_OVERRIDE", "true", true); 494 495 using namespace android::hardware; 496 497 const char *me = argv[0]; 498 499 bool wantClient = false; 500 bool wantServer = false; 501 502 int res; 503 while ((res = getopt(argc, argv, "chs")) >= 0) { 504 switch (res) { 505 case 'c': 506 { 507 wantClient = true; 508 break; 509 } 510 511 case 's': 512 { 513 wantServer = true; 514 break; 515 } 516 517 case '?': 518 case 'h': 519 default: 520 { 521 usage(me); 522 exit(1); 523 break; 524 } 525 } 526 } 527 528 if ((!wantClient && !wantServer) || (wantClient && wantServer)) { 529 usage(me); 530 exit(1); 531 } 532 533 if (wantClient) { 534 ::testing::AddGlobalTestEnvironment(new HidlEnvironment); 535 ::testing::InitGoogleTest(&argc, argv); 536 int status = RUN_ALL_TESTS(); 537 return status; 538 } 539 540 return defaultPassthroughServiceImplementation<IBaz>("baz"); 541 542 } 543