nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp

   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 INVALID_COMMAND \
  46   { 0x20, 0x00, 0x00 }
  47 #define FAULTY_DATA_PACKET \
  48   { 0x00, 0x00, 0xFF }
  49
  50 #define LOOP_BACK_HEADER_SIZE 3
  51 #define SYNTAX_ERROR 5
  52 #define NUMBER_LOOPS 3922
  53 #define VERSION 0x11
  54 #define TIMEOUT_PERIOD 5
  55
  56 constexpr char kCallbackNameSendEvent[] = "sendEvent";
  57 constexpr char kCallbackNameSendData[] = "sendData";
  58
  59 class NfcClientCallbackArgs {
  60    public:
  61     NfcEvent last_event_;
  62     NfcStatus last_status_;
  63     NfcData last_data_;
  64 };
  65
  66 /* Callback class for data & Event. */
  67 class NfcClientCallback
  68     : public ::testing::VtsHalHidlTargetCallbackBase<NfcClientCallbackArgs>,
  69       public INfcClientCallback {
  70    public:
  71     virtual ~NfcClientCallback() = default;
  72
  73     /* sendEvent callback function - Records the Event & Status
  74      * and notifies the TEST
  75      **/
  76     Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
  77         NfcClientCallbackArgs args;
  78         args.last_event_ = event;
  79         args.last_status_ = event_status;
  80         NotifyFromCallback(kCallbackNameSendEvent, args);
  81         return Void();
  82     };
  83
  84     /* sendData callback function. Records the data and notifies the TEST*/
  85     Return<void> sendData(const NfcData& data) override {
  86         NfcClientCallbackArgs args;
  87         args.last_data_ = data;
  88         NotifyFromCallback(kCallbackNameSendData, args);
  89         return Void();
  90     };
  91 };
  92
  93 // The main test class for NFC HIDL HAL.
  94 class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
  95  public:
  96   virtual void SetUp() override {
  97     nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
  98     ASSERT_NE(nfc_, nullptr);
  99
 100     nfc_cb_ = new NfcClientCallback();
 101     ASSERT_NE(nfc_cb_, nullptr);
 102
 103     EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
 104     // Wait for OPEN_CPLT event
 105     auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 106     EXPECT_TRUE(res.no_timeout);
 107     EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
 108     EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 109   }
 110
 111   virtual void TearDown() override {
 112     EXPECT_EQ(NfcStatus::OK, nfc_->close());
 113     // Wait for CLOSE_CPLT event
 114     auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 115     EXPECT_TRUE(res.no_timeout);
 116     EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
 117     EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 118   }
 119
 120   sp<INfc> nfc_;
 121   sp<NfcClientCallback> nfc_cb_;
 122 };
 123
 124 // A class for test environment setup (kept since this file is a template).
 125 class NfcHidlEnvironment : public ::testing::Environment {
 126  public:
 127   virtual void SetUp() {}
 128   virtual void TearDown() {}
 129
 130  private:
 131 };
 132
 133 /*
 134  * OpenAndClose:
 135  * Makes an open call, waits for NfcEvent.OPEN_CPLT
 136  * Immediately calls close() and waits for NfcEvent.CLOSE_CPLT
 137  * Since open and close calls are a part of SetUp() and TearDown(),
 138  * the function definition is intentionally kept empty
 139  */
 140 TEST_F(NfcHidlTest, OpenAndClose) {}
 141
 142 /*
 143  * WriteCoreReset:
 144  * Sends CORE_RESET_CMD
 145  * Waits for CORE_RESET_RSP
 146  * Checks the status, version number and configuration status
 147  */
 148 TEST_F(NfcHidlTest, WriteCoreReset) {
 149   std::vector<uint8_t> cmd = CORE_RESET_CMD;
 150   NfcData data = cmd;
 151   EXPECT_EQ(data.size(), nfc_->write(data));
 152   // Wait for CORE_RESET_RSP
 153   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 154   EXPECT_TRUE(res.no_timeout);
 155   EXPECT_EQ(6ul, res.args->last_data_.size());
 156   EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
 157   EXPECT_GE(VERSION, res.args->last_data_[4]);
 158   EXPECT_EQ(0ul, res.args->last_data_[5]);
 159 }
 160
 161 /*
 162  * WriteCoreResetConfigReset:
 163  * Sends CORE_RESET_CMD_CONFIG_RESET
 164  * Waits for CORE_RESET_RSP
 165  * Checks the status, version number and configuration status
 166  */
 167 TEST_F(NfcHidlTest, WriteCoreResetConfigReset) {
 168   std::vector<uint8_t> cmd = CORE_RESET_CMD_CONFIG_RESET;
 169   NfcData data = cmd;
 170   EXPECT_EQ(data.size(), nfc_->write(data));
 171   // Wait for CORE_RESET_RSP
 172   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 173   EXPECT_TRUE(res.no_timeout);
 174   EXPECT_EQ(6ul, res.args->last_data_.size());
 175   EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
 176   EXPECT_GE(VERSION, res.args->last_data_[4]);
 177   EXPECT_EQ(1ul, res.args->last_data_[5]);
 178 }
 179
 180 /*
 181  * WriteInvalidCommand:
 182  * Sends an invalid command
 183  * Waits for response
 184  * Checks SYNTAX_ERROR status
 185  */
 186 TEST_F(NfcHidlTest, WriteInvalidCommand) {
 187   // Send an Error Command
 188   std::vector<uint8_t> cmd = INVALID_COMMAND;
 189   NfcData data = cmd;
 190   EXPECT_EQ(data.size(), nfc_->write(data));
 191   // Wait for RSP
 192   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 193   EXPECT_TRUE(res.no_timeout);
 194   EXPECT_EQ(4ul, res.args->last_data_.size());
 195   EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
 196 }
 197
 198 /*
 199  * WriteInvalidAndThenValidCommand:
 200  * Sends an Faulty Data Packet
 201  * Waits for CORE_INTERFACE_ERROR_NTF
 202  * Checks SYNTAX_ERROR status
 203  * Repeat for 100 times appending 0xFF each time to the packet
 204  * Send CORE_CONN_CREATE_CMD for loop-back mode
 205  * Check the response
 206  */
 207 TEST_F(NfcHidlTest, WriteInvalidAndThenValidCommand) {
 208   // Send an Error Data Packet
 209   std::vector<uint8_t> cmd = FAULTY_DATA_PACKET;
 210   NfcData data = cmd;
 211   size_t size = data.size();
 212
 213   for (int i = 0; i < 100; i++) {
 214     data.resize(++size);
 215     data[size - 1] = 0xFF;
 216     EXPECT_EQ(data.size(), nfc_->write(data));
 217     // Wait for CORE_INTERFACE_ERROR_NTF
 218     auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 219     EXPECT_TRUE(res.no_timeout);
 220     EXPECT_EQ(5ul, res.args->last_data_.size());
 221     EXPECT_EQ(0x60, res.args->last_data_[0]);
 222     EXPECT_EQ(0x08, res.args->last_data_[1]);
 223     EXPECT_EQ(0x02, res.args->last_data_[2]);
 224     EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
 225   }
 226
 227   cmd = CORE_CONN_CREATE_CMD;
 228   data = cmd;
 229   EXPECT_EQ(data.size(), nfc_->write(data));
 230   // Wait for CORE_CONN_CREATE_RSP
 231   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 232   EXPECT_TRUE(res.no_timeout);
 233   EXPECT_EQ(7ul, res.args->last_data_.size());
 234   EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
 235 }
 236 /*
 237  * Bandwidth:
 238  * Sets the loop-back mode using CORE_CONN_CREATE_CMD
 239  * Sends max payload size data
 240  * Waits for the response
 241  * Checks the data received
 242  * Repeat to send total of 1Mb data
 243  */
 244 TEST_F(NfcHidlTest, Bandwidth) {
 245   std::vector<uint8_t> cmd = CORE_CONN_CREATE_CMD;
 246   NfcData data = cmd;
 247   EXPECT_EQ(data.size(), nfc_->write(data));
 248   // Wait for CORE_CONN_CREATE_RSP
 249   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 250   EXPECT_TRUE(res.no_timeout);
 251   EXPECT_EQ(7ul, res.args->last_data_.size());
 252   EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
 253   uint8_t conn_id = res.args->last_data_[6];
 254   uint32_t max_payload_size = res.args->last_data_[4];
 255
 256   for (int loops = 0; loops < NUMBER_LOOPS; loops++) {
 257       res.args->last_data_.resize(0);
 258       data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
 259       data[0] = conn_id;
 260       data[1] = 0x00;
 261       data[2] = max_payload_size;
 262       for (uint32_t i = 0; i < max_payload_size; i++) {
 263           data[i + LOOP_BACK_HEADER_SIZE] = i;
 264     }
 265     EXPECT_EQ(max_payload_size + LOOP_BACK_HEADER_SIZE, nfc_->write(data));
 266     // Wait for data and CORE_CONN_CREDITS_NTF
 267     auto res1 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 268     EXPECT_TRUE(res1.no_timeout);
 269     auto res2 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
 270     EXPECT_TRUE(res2.no_timeout);
 271     // Check if the same data was received back
 272     EXPECT_TRUE(res1.args);
 273     EXPECT_TRUE(res2.args);
 274
 275     NfcData credits_ntf = res1.args->last_data_;
 276     NfcData received_data = res2.args->last_data_;
 277     /* It is possible that CORE_CONN_CREDITS_NTF is received before data,
 278      * Find the order and do further checks depending on that */
 279     if (received_data.size() != data.size()) {
 280         credits_ntf = res2.args->last_data_;
 281         received_data = res1.args->last_data_;
 282     }
 283     EXPECT_EQ(data.size(), received_data.size());
 284     for (size_t i = 0; i < data.size(); i++) {
 285         EXPECT_EQ(data[i], received_data[i]);
 286     }
 287
 288     EXPECT_EQ(6ul, credits_ntf.size());
 289     // Check if the credit is refilled to 1
 290     EXPECT_EQ(1, credits_ntf[5]);
 291   }
 292 }
 293
 294 /*
 295  * PowerCycle:
 296  * Calls powerCycle()
 297  * Waits for NfcEvent.OPEN_CPLT
 298  * Checks status
 299  */
 300 TEST_F(NfcHidlTest, PowerCycle) {
 301   EXPECT_EQ(NfcStatus::OK, nfc_->powerCycle());
 302   // Wait for NfcEvent.OPEN_CPLT
 303   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 304   EXPECT_TRUE(res.no_timeout);
 305   EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
 306   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 307 }
 308
 309 /*
 310  * PowerCycleAfterClose:
 311  * Calls powerCycle() after close()
 312  * Checks status
 313  */
 314 TEST_F(NfcHidlTest, PowerCycleAfterClose) {
 315   EXPECT_EQ(NfcStatus::OK, nfc_->close());
 316   // Wait for CLOSE_CPLT event
 317   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 318   EXPECT_TRUE(res.no_timeout);
 319   EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
 320   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 321
 322   EXPECT_EQ(NfcStatus::FAILED, nfc_->powerCycle());
 323
 324   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
 325   // Wait for OPEN_CPLT event
 326   res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 327   EXPECT_TRUE(res.no_timeout);
 328   EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
 329   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 330 }
 331
 332 /*
 333  * CoreInitialized:
 334  * Calls coreInitialized() with different data
 335  * Waits for NfcEvent.POST_INIT_CPLT
 336  */
 337 TEST_F(NfcHidlTest, CoreInitialized) {
 338   NfcData data;
 339   data.resize(1);
 340   // These parameters might lead to device specific proprietary behavior
 341   // Using > 10 values should result in predictable and common results for
 342   // most devices.
 343   for (int i = 10; i <= 16; i++) {
 344       data[0] = i;
 345       EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
 346       // Wait for NfcEvent.POST_INIT_CPLT
 347       auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 348       EXPECT_TRUE(res.no_timeout);
 349       EXPECT_EQ(NfcEvent::POST_INIT_CPLT, res.args->last_event_);
 350   }
 351 }
 352
 353 /*
 354  * ControlGranted:
 355  * Calls controlGranted()
 356  * Checks the return value
 357  */
 358 TEST_F(NfcHidlTest, ControlGranted) {
 359   EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted());
 360 }
 361
 362 /*
 363  * ControlGrantedAfterClose:
 364  * Call controlGranted() after close
 365  * Checks the return value
 366  */
 367 TEST_F(NfcHidlTest, ControlGrantedAfterClose) {
 368   EXPECT_EQ(NfcStatus::OK, nfc_->close());
 369   // Wait for CLOSE_CPLT event
 370   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 371   EXPECT_TRUE(res.no_timeout);
 372   EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
 373   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 374
 375   EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted());
 376
 377   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
 378   // Wait for OPEN_CPLT event
 379   res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 380   EXPECT_TRUE(res.no_timeout);
 381   EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
 382   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 383 }
 384
 385 /* PreDiscover:
 386  * Calls prediscover()
 387  * Checks the return value
 388  */
 389 TEST_F(NfcHidlTest, PreDiscover) {
 390   EXPECT_EQ(NfcStatus::OK, nfc_->prediscover());
 391 }
 392
 393 /*
 394  * PreDiscoverAfterClose:
 395  * Call prediscover() after close
 396  * Checks the return value
 397  */
 398 TEST_F(NfcHidlTest, PreDiscoverAfterClose) {
 399   EXPECT_EQ(NfcStatus::OK, nfc_->close());
 400   // Wait for CLOSE_CPLT event
 401   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 402   EXPECT_TRUE(res.no_timeout);
 403   EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
 404   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 405
 406   EXPECT_EQ(NfcStatus::OK, nfc_->prediscover());
 407
 408   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
 409   // Wait for OPEN_CPLT event
 410   res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 411   EXPECT_TRUE(res.no_timeout);
 412   EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
 413   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 414 }
 415
 416 /*
 417  * CloseAfterClose:
 418  * Calls close() multiple times
 419  * Checks status
 420  */
 421 TEST_F(NfcHidlTest, CloseAfterClose) {
 422   EXPECT_EQ(NfcStatus::OK, nfc_->close());
 423   // Wait for CLOSE_CPLT event
 424   auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 425   EXPECT_TRUE(res.no_timeout);
 426   EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
 427   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 428
 429   EXPECT_EQ(NfcStatus::FAILED, nfc_->close());
 430
 431   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
 432   // Wait for OPEN_CPLT event
 433   res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
 434   EXPECT_TRUE(res.no_timeout);
 435   EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
 436   EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
 437 }
 438
 439 /*
 440  * OpenAfterOpen:
 441  * Calls open() multiple times
 442  * Checks status
 443  */
 444 TEST_F(NfcHidlTest, OpenAfterOpen) {
 445   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
 446   EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
 447 }
 448
 449 int main(int argc, char** argv) {
 450   ::testing::AddGlobalTestEnvironment(new NfcHidlEnvironment);
 451   ::testing::InitGoogleTest(&argc, argv);
 452
 453   std::system("svc nfc disable"); /* Turn off NFC */
 454   sleep(5);
 455
 456   int status = RUN_ALL_TESTS();
 457   LOG(INFO) << "Test result = " << status;
 458
 459   std::system("svc nfc enable"); /* Turn on NFC */
 460   sleep(5);
 461
 462   return status;
 463 }