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 "nfc_hidl_hal_test" 18 #include <android-base/logging.h> 19 20 #include <android/hardware/nfc/1.0/INfc.h> 21 #include <android/hardware/nfc/1.0/INfcClientCallback.h> 22 #include <android/hardware/nfc/1.0/types.h> 23 #include <hardware/nfc.h> 24 25 #include <VtsHalHidlTargetCallbackBase.h> 26 #include <VtsHalHidlTargetTestBase.h> 27 28 using ::android::hardware::nfc::V1_0::INfc; 29 using ::android::hardware::nfc::V1_0::INfcClientCallback; 30 using ::android::hardware::nfc::V1_0::NfcEvent; 31 using ::android::hardware::nfc::V1_0::NfcStatus; 32 using ::android::hardware::nfc::V1_0::NfcData; 33 using ::android::hardware::Return; 34 using ::android::hardware::Void; 35 using ::android::hardware::hidl_vec; 36 using ::android::sp; 37 38 /* NCI Commands */ 39 #define CORE_RESET_CMD \ 40 { 0x20, 0x00, 0x01, 0x00 } 41 #define CORE_RESET_CMD_CONFIG_RESET \ 42 { 0x20, 0x00, 0x01, 0x01 } 43 #define CORE_CONN_CREATE_CMD \ 44 { 0x20, 0x04, 0x02, 0x01, 0x00 } 45 #define CORE_INIT_CMD \ 46 { 0x20, 0x01, 0x00 } 47 #define INVALID_COMMAND \ 48 { 0x20, 0x00, 0x00 } 49 50 #define LOOP_BACK_HEADER_SIZE 3 51 #define SYNTAX_ERROR 5 52 #define NUMBER_LOOPS 3922 53 #define NCI_VERSION_1_1 0x11 54 #define NCI_VERSION_2 0x20 55 #define TIMEOUT_PERIOD 5 56 57 constexpr char kCallbackNameSendEvent[] = "sendEvent"; 58 constexpr char kCallbackNameSendData[] = "sendData"; 59 60 class NfcClientCallbackArgs { 61 public: 62 NfcEvent last_event_; 63 NfcStatus last_status_; 64 NfcData last_data_; 65 }; 66 67 /* Callback class for data & Event. */ 68 class NfcClientCallback 69 : public ::testing::VtsHalHidlTargetCallbackBase<NfcClientCallbackArgs>, 70 public INfcClientCallback { 71 public: 72 virtual ~NfcClientCallback() = default; 73 74 /* sendEvent callback function - Records the Event & Status 75 * and notifies the TEST 76 **/ 77 Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override { 78 NfcClientCallbackArgs args; 79 args.last_event_ = event; 80 args.last_status_ = event_status; 81 NotifyFromCallback(kCallbackNameSendEvent, args); 82 return Void(); 83 }; 84 85 /* sendData callback function. Records the data and notifies the TEST*/ 86 Return<void> sendData(const NfcData& data) override { 87 NfcClientCallbackArgs args; 88 args.last_data_ = data; 89 NotifyFromCallback(kCallbackNameSendData, args); 90 return Void(); 91 }; 92 }; 93 94 // The main test class for NFC HIDL HAL. 95 class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase { 96 public: 97 virtual void SetUp() override { 98 nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>(); 99 ASSERT_NE(nfc_, nullptr); 100 101 nfc_cb_ = new NfcClientCallback(); 102 ASSERT_NE(nfc_cb_, nullptr); 103 104 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 105 // Wait for OPEN_CPLT event 106 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 107 EXPECT_TRUE(res.no_timeout); 108 EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_); 109 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 110 111 /* Get the NCI version that the device supports */ 112 std::vector<uint8_t> cmd = CORE_RESET_CMD; 113 NfcData data = cmd; 114 EXPECT_EQ(data.size(), nfc_->write(data)); 115 // Wait for CORE_RESET_RSP 116 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 117 EXPECT_TRUE(res.no_timeout); 118 EXPECT_GE(6ul, res.args->last_data_.size()); 119 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 120 if (res.args->last_data_.size() == 6) { 121 nci_version = res.args->last_data_[4]; 122 } else { 123 EXPECT_EQ(4ul, res.args->last_data_.size()); 124 nci_version = NCI_VERSION_2; 125 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 126 EXPECT_TRUE(res.no_timeout); 127 } 128 129 /* 130 * Close the hal and then re-open to make sure we are in a predictable 131 * state for all the tests. 132 */ 133 EXPECT_EQ(NfcStatus::OK, nfc_->close()); 134 // Wait for CLOSE_CPLT event 135 res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 136 EXPECT_TRUE(res.no_timeout); 137 EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_); 138 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 139 140 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 141 // Wait for OPEN_CPLT event 142 res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 143 EXPECT_TRUE(res.no_timeout); 144 EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_); 145 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 146 } 147 148 virtual void TearDown() override { 149 EXPECT_EQ(NfcStatus::OK, nfc_->close()); 150 // Wait for CLOSE_CPLT event 151 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 152 EXPECT_TRUE(res.no_timeout); 153 EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_); 154 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 155 } 156 157 /* NCI version the device supports 158 * 0x11 for NCI 1.1, 0x20 for NCI 2.0 and so forth */ 159 uint8_t nci_version; 160 sp<INfc> nfc_; 161 sp<NfcClientCallback> nfc_cb_; 162 }; 163 164 // A class for test environment setup (kept since this file is a template). 165 class NfcHidlEnvironment : public ::testing::Environment { 166 public: 167 virtual void SetUp() {} 168 virtual void TearDown() {} 169 170 private: 171 }; 172 173 /* 174 * OpenAndClose: 175 * Makes an open call, waits for NfcEvent.OPEN_CPLT 176 * Immediately calls close() and waits for NfcEvent.CLOSE_CPLT 177 * Since open and close calls are a part of SetUp() and TearDown(), 178 * the function definition is intentionally kept empty 179 */ 180 TEST_F(NfcHidlTest, OpenAndClose) {} 181 182 /* 183 * WriteCoreReset: 184 * Sends CORE_RESET_CMD 185 * Waits for CORE_RESET_RSP 186 * Checks the status, version number and configuration status 187 */ 188 TEST_F(NfcHidlTest, WriteCoreReset) { 189 std::vector<uint8_t> cmd = CORE_RESET_CMD; 190 NfcData data = cmd; 191 EXPECT_EQ(data.size(), nfc_->write(data)); 192 // Wait for CORE_RESET_RSP 193 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 194 EXPECT_TRUE(res.no_timeout); 195 196 /* The response/notification format for CORE_RESET_CMD differs 197 * with NCI 1.0 and 2.0. */ 198 if (nci_version <= NCI_VERSION_1_1) { 199 EXPECT_EQ(6ul, res.args->last_data_.size()); 200 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 201 EXPECT_GE(NCI_VERSION_1_1, res.args->last_data_[4]); 202 EXPECT_GE(1ul, res.args->last_data_[5]); 203 } else { 204 EXPECT_EQ(4ul, res.args->last_data_.size()); 205 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 206 // Wait for CORE_RESET_NTF 207 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 208 EXPECT_TRUE(res.no_timeout); 209 // Check if reset trigger was due to CORE_RESET_CMD 210 EXPECT_LE(8ul, res.args->last_data_.size()); 211 EXPECT_EQ(2ul, res.args->last_data_[3]); 212 EXPECT_GE(1ul, res.args->last_data_[4]); 213 EXPECT_EQ(NCI_VERSION_2, res.args->last_data_[5]); 214 } 215 } 216 217 /* 218 * WriteCoreResetConfigReset: 219 * Sends CORE_RESET_CMD_CONFIG_RESET 220 * Waits for CORE_RESET_RSP 221 * Checks the status, version number and configuration status 222 */ 223 TEST_F(NfcHidlTest, WriteCoreResetConfigReset) { 224 std::vector<uint8_t> cmd = CORE_RESET_CMD_CONFIG_RESET; 225 NfcData data = cmd; 226 EXPECT_EQ(data.size(), nfc_->write(data)); 227 // Wait for CORE_RESET_RSP 228 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 229 EXPECT_TRUE(res.no_timeout); 230 231 /* The response/notification format for CORE_RESET_CMD differs 232 * with NCI 1.0 and 2.0. */ 233 if (nci_version <= NCI_VERSION_1_1) { 234 EXPECT_EQ(6ul, res.args->last_data_.size()); 235 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 236 EXPECT_GE(NCI_VERSION_1_1, res.args->last_data_[4]); 237 EXPECT_EQ(1ul, res.args->last_data_[5]); 238 } else { 239 EXPECT_EQ(4ul, res.args->last_data_.size()); 240 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 241 // Wait for CORE_RESET_NTF 242 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 243 EXPECT_TRUE(res.no_timeout); 244 // Check if reset trigger was due to CORE_RESET_CMD 245 EXPECT_LE(8ul, res.args->last_data_.size()); 246 EXPECT_EQ(2ul, res.args->last_data_[3]); 247 EXPECT_EQ(1ul, res.args->last_data_[4]); 248 EXPECT_EQ(NCI_VERSION_2, res.args->last_data_[5]); 249 } 250 } 251 252 /* 253 * WriteInvalidCommand: 254 * Sends an invalid command 255 * Waits for response 256 * Checks SYNTAX_ERROR status 257 */ 258 TEST_F(NfcHidlTest, WriteInvalidCommand) { 259 // Send an Error Command 260 std::vector<uint8_t> cmd = INVALID_COMMAND; 261 NfcData data = cmd; 262 EXPECT_EQ(data.size(), nfc_->write(data)); 263 // Wait for RSP 264 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 265 EXPECT_TRUE(res.no_timeout); 266 EXPECT_EQ(4ul, res.args->last_data_.size()); 267 EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]); 268 } 269 270 /* 271 * WriteInvalidAndThenValidCommand: 272 * Sends an Invalid command 273 * Waits for response 274 * Checks SYNTAX_ERROR status 275 * Repeat for 100 times appending 0xFF each time to the packet 276 * Send CORE_CONN_CREATE_CMD for loop-back mode 277 * Check the response 278 */ 279 TEST_F(NfcHidlTest, WriteInvalidAndThenValidCommand) { 280 std::vector<uint8_t> cmd = CORE_RESET_CMD; 281 NfcData data = cmd; 282 EXPECT_EQ(data.size(), nfc_->write(data)); 283 // Wait for CORE_RESET_RSP 284 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 285 EXPECT_TRUE(res.no_timeout); 286 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 287 288 /* NCI 2.0 sends CORE_RESET_NTF everytime. */ 289 if (nci_version == NCI_VERSION_2) { 290 // Wait for CORE_RESET_NTF 291 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 292 EXPECT_TRUE(res.no_timeout); 293 } 294 295 cmd = CORE_INIT_CMD; 296 data = cmd; 297 EXPECT_EQ(data.size(), nfc_->write(data)); 298 // Wait for CORE_INIT_RSP 299 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 300 EXPECT_TRUE(res.no_timeout); 301 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 302 303 // Send an Error Data Packet 304 cmd = INVALID_COMMAND; 305 data = cmd; 306 size_t size = data.size(); 307 308 for (int i = 0; i < 100; i++) { 309 data.resize(++size); 310 data[size - 1] = 0xFF; 311 EXPECT_EQ(data.size(), nfc_->write(data)); 312 // Wait for response with SYNTAX_ERROR 313 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 314 EXPECT_TRUE(res.no_timeout); 315 EXPECT_EQ(4ul, res.args->last_data_.size()); 316 EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]); 317 } 318 319 cmd = CORE_CONN_CREATE_CMD; 320 data = cmd; 321 EXPECT_EQ(data.size(), nfc_->write(data)); 322 // Wait for CORE_CONN_CREATE_RSP 323 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 324 EXPECT_TRUE(res.no_timeout); 325 EXPECT_EQ(7ul, res.args->last_data_.size()); 326 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 327 } 328 /* 329 * Bandwidth: 330 * Sets the loop-back mode using CORE_CONN_CREATE_CMD 331 * Sends max payload size data 332 * Waits for the response 333 * Checks the data received 334 * Repeat to send total of 1Mb data 335 */ 336 TEST_F(NfcHidlTest, Bandwidth) { 337 std::vector<uint8_t> cmd = CORE_RESET_CMD; 338 NfcData data = cmd; 339 EXPECT_EQ(data.size(), nfc_->write(data)); 340 // Wait for CORE_RESET_RSP 341 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 342 EXPECT_TRUE(res.no_timeout); 343 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 344 345 /* NCI 2.0 sends CORE_RESET_NTF everytime. */ 346 if (nci_version == NCI_VERSION_2) { 347 // Wait for CORE_RESET_NTF 348 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 349 EXPECT_TRUE(res.no_timeout); 350 } 351 352 cmd = CORE_INIT_CMD; 353 data = cmd; 354 EXPECT_EQ(data.size(), nfc_->write(data)); 355 // Wait for CORE_INIT_RSP 356 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 357 EXPECT_TRUE(res.no_timeout); 358 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 359 360 cmd = CORE_CONN_CREATE_CMD; 361 data = cmd; 362 EXPECT_EQ(data.size(), nfc_->write(data)); 363 // Wait for CORE_CONN_CREATE_RSP 364 res = nfc_cb_->WaitForCallback(kCallbackNameSendData); 365 EXPECT_TRUE(res.no_timeout); 366 EXPECT_TRUE(res.no_timeout); 367 EXPECT_EQ(7ul, res.args->last_data_.size()); 368 EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]); 369 uint8_t conn_id = res.args->last_data_[6]; 370 uint32_t max_payload_size = res.args->last_data_[4]; 371 372 for (int loops = 0; loops < NUMBER_LOOPS; loops++) { 373 res.args->last_data_.resize(0); 374 data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE); 375 data[0] = conn_id; 376 data[1] = 0x00; 377 data[2] = max_payload_size; 378 for (uint32_t i = 0; i < max_payload_size; i++) { 379 data[i + LOOP_BACK_HEADER_SIZE] = i; 380 } 381 EXPECT_EQ(max_payload_size + LOOP_BACK_HEADER_SIZE, nfc_->write(data)); 382 // Wait for data and CORE_CONN_CREDITS_NTF 383 auto res1 = nfc_cb_->WaitForCallback(kCallbackNameSendData); 384 EXPECT_TRUE(res1.no_timeout); 385 auto res2 = nfc_cb_->WaitForCallback(kCallbackNameSendData); 386 EXPECT_TRUE(res2.no_timeout); 387 // Check if the same data was received back 388 EXPECT_TRUE(res1.args); 389 EXPECT_TRUE(res2.args); 390 391 NfcData credits_ntf = res1.args->last_data_; 392 NfcData received_data = res2.args->last_data_; 393 /* It is possible that CORE_CONN_CREDITS_NTF is received before data, 394 * Find the order and do further checks depending on that */ 395 if (received_data.size() != data.size()) { 396 credits_ntf = res2.args->last_data_; 397 received_data = res1.args->last_data_; 398 } 399 EXPECT_EQ(data.size(), received_data.size()); 400 for (size_t i = 0; i < data.size(); i++) { 401 EXPECT_EQ(data[i], received_data[i]); 402 } 403 404 EXPECT_EQ(6ul, credits_ntf.size()); 405 // Check if the credit is refilled to 1 406 EXPECT_EQ(1, credits_ntf[5]); 407 } 408 } 409 410 /* 411 * PowerCycle: 412 * Calls powerCycle() 413 * Waits for NfcEvent.OPEN_CPLT 414 * Checks status 415 */ 416 TEST_F(NfcHidlTest, PowerCycle) { 417 EXPECT_EQ(NfcStatus::OK, nfc_->powerCycle()); 418 // Wait for NfcEvent.OPEN_CPLT 419 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 420 EXPECT_TRUE(res.no_timeout); 421 EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_); 422 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 423 } 424 425 /* 426 * PowerCycleAfterClose: 427 * Calls powerCycle() after close() 428 * Checks status 429 */ 430 TEST_F(NfcHidlTest, PowerCycleAfterClose) { 431 EXPECT_EQ(NfcStatus::OK, nfc_->close()); 432 // Wait for CLOSE_CPLT event 433 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 434 EXPECT_TRUE(res.no_timeout); 435 EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_); 436 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 437 438 EXPECT_EQ(NfcStatus::FAILED, nfc_->powerCycle()); 439 440 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 441 // Wait for OPEN_CPLT event 442 res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 443 EXPECT_TRUE(res.no_timeout); 444 EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_); 445 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 446 } 447 448 /* 449 * CoreInitialized: 450 * Calls coreInitialized() with different data 451 * Waits for NfcEvent.POST_INIT_CPLT 452 */ 453 TEST_F(NfcHidlTest, CoreInitialized) { 454 NfcData data; 455 data.resize(1); 456 // These parameters might lead to device specific proprietary behavior 457 // Using > 10 values should result in predictable and common results for 458 // most devices. 459 for (int i = 10; i <= 16; i++) { 460 data[0] = i; 461 NfcStatus status = nfc_->coreInitialized(data); 462 463 /* In case coreInitialized returned FAILED, do not wait for 464 * POST_INIT_CLPT event. */ 465 if (status == NfcStatus::FAILED) continue; 466 467 EXPECT_EQ(NfcStatus::OK, status); 468 // Wait for NfcEvent.POST_INIT_CPLT 469 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 470 EXPECT_TRUE(res.no_timeout); 471 EXPECT_EQ(NfcEvent::POST_INIT_CPLT, res.args->last_event_); 472 } 473 } 474 475 /* 476 * ControlGranted: 477 * Calls controlGranted() 478 * Checks the return value 479 */ 480 TEST_F(NfcHidlTest, ControlGranted) { 481 EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted()); 482 } 483 484 /* 485 * ControlGrantedAfterClose: 486 * Call controlGranted() after close 487 * Checks the return value 488 */ 489 TEST_F(NfcHidlTest, ControlGrantedAfterClose) { 490 EXPECT_EQ(NfcStatus::OK, nfc_->close()); 491 // Wait for CLOSE_CPLT event 492 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 493 EXPECT_TRUE(res.no_timeout); 494 EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_); 495 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 496 497 EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted()); 498 499 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 500 // Wait for OPEN_CPLT event 501 res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 502 EXPECT_TRUE(res.no_timeout); 503 EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_); 504 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 505 } 506 507 /* PreDiscover: 508 * Calls prediscover() 509 * Checks the return value 510 */ 511 TEST_F(NfcHidlTest, PreDiscover) { 512 EXPECT_EQ(NfcStatus::OK, nfc_->prediscover()); 513 } 514 515 /* 516 * PreDiscoverAfterClose: 517 * Call prediscover() after close 518 * Checks the return value 519 */ 520 TEST_F(NfcHidlTest, PreDiscoverAfterClose) { 521 EXPECT_EQ(NfcStatus::OK, nfc_->close()); 522 // Wait for CLOSE_CPLT event 523 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 524 EXPECT_TRUE(res.no_timeout); 525 EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_); 526 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 527 528 EXPECT_EQ(NfcStatus::OK, nfc_->prediscover()); 529 530 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 531 // Wait for OPEN_CPLT event 532 res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 533 EXPECT_TRUE(res.no_timeout); 534 EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_); 535 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 536 } 537 538 /* 539 * CloseAfterClose: 540 * Calls close() multiple times 541 * Checks status 542 */ 543 TEST_F(NfcHidlTest, CloseAfterClose) { 544 EXPECT_EQ(NfcStatus::OK, nfc_->close()); 545 // Wait for CLOSE_CPLT event 546 auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 547 EXPECT_TRUE(res.no_timeout); 548 EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_); 549 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 550 551 EXPECT_EQ(NfcStatus::FAILED, nfc_->close()); 552 553 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 554 // Wait for OPEN_CPLT event 555 res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent); 556 EXPECT_TRUE(res.no_timeout); 557 EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_); 558 EXPECT_EQ(NfcStatus::OK, res.args->last_status_); 559 } 560 561 /* 562 * OpenAfterOpen: 563 * Calls open() multiple times 564 * Checks status 565 */ 566 TEST_F(NfcHidlTest, OpenAfterOpen) { 567 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 568 EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); 569 } 570 571 int main(int argc, char** argv) { 572 ::testing::AddGlobalTestEnvironment(new NfcHidlEnvironment); 573 ::testing::InitGoogleTest(&argc, argv); 574 575 std::system("svc nfc disable"); /* Turn off NFC */ 576 sleep(5); 577 578 int status = RUN_ALL_TESTS(); 579 LOG(INFO) << "Test result = " << status; 580 581 std::system("svc nfc enable"); /* Turn on NFC */ 582 sleep(5); 583 584 return status; 585 } 586
