Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

NFC VTS test use VtsHalHidlCallbackBase for callback wait and notify

Browse Source 
VtsHalNfcV1_0TargetTest uses VtsHalHidlCallbackBase.
Callback class extends VtsHalHidlCallbackBase and use waitForCallback and notifyFromCallback

The original NFC test contains the following use cases:
  * Callback notify happens before wait
  * Multiple waiting in serial
The modified version added the following use cases:
  * Wait for specific callback function
  * Passing callback arg data along wait and notify functions

Bug: 36036059
Test: make VtsHalNfcV1_0TargetTest, adb push & adb shell
Change-Id: Ic6668a18254661d07c4ff37309cd96ea5f786d29
This commit is contained in:
Yuexi Ma
2017-03-29 18:11:01 -07:00
parent 3b9e23513e
commit bfefc5ef10
1 changed files with 152 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

311
nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
View File

@@ -22,10 +22,8 @@
#include <android/hardware/nfc/1.0/types.h> #include <android/hardware/nfc/1.0/types.h>
#include <hardware/nfc.h> #include <hardware/nfc.h>
#include <VtsHalHidlTargetCallbackBase.h>
#include <VtsHalHidlTargetTestBase.h> #include <VtsHalHidlTargetTestBase.h>
#include <chrono>
#include <condition_variable>
#include <mutex>
using ::android::hardware::nfc::V1_0::INfc; using ::android::hardware::nfc::V1_0::INfc;
using ::android::hardware::nfc::V1_0::INfcClientCallback; using ::android::hardware::nfc::V1_0::INfcClientCallback;
@@ -55,6 +53,43 @@ using ::android::sp;
#define VERSION 0x11 #define VERSION 0x11
#define TIMEOUT_PERIOD 5 #define TIMEOUT_PERIOD 5
constexpr char kCallbackNameSendEvent[] = "sendEvent";
constexpr char kCallbackNameSendData[] = "sendData";
class NfcClientCallbackArgs {
public:
NfcEvent last_event_;
NfcStatus last_status_;
NfcData last_data_;
};
/* Callback class for data & Event. */
class NfcClientCallback
: public ::testing::VtsHalHidlTargetCallbackBase<NfcClientCallbackArgs>,
public INfcClientCallback {
public:
virtual ~NfcClientCallback() = default;
/* sendEvent callback function - Records the Event & Status
* and notifies the TEST
**/
Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
NfcClientCallbackArgs args;
args.last_event_ = event;
args.last_status_ = event_status;
NotifyFromCallback(kCallbackNameSendEvent, args);
return Void();
};
/* sendData callback function. Records the data and notifies the TEST*/
Return<void> sendData(const NfcData& data) override {
NfcClientCallbackArgs args;
args.last_data_ = data;
NotifyFromCallback(kCallbackNameSendData, args);
return Void();
};
};
// The main test class for NFC HIDL HAL. // The main test class for NFC HIDL HAL.
class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase { class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
public: public:
@@ -62,88 +97,28 @@ class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>(); nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
ASSERT_NE(nfc_, nullptr); ASSERT_NE(nfc_, nullptr);
nfc_cb_ = new NfcClientCallback(*this); nfc_cb_ = new NfcClientCallback();
ASSERT_NE(nfc_cb_, nullptr); ASSERT_NE(nfc_cb_, nullptr);
count = 0;
last_event_ = NfcEvent::ERROR;
last_status_ = NfcStatus::FAILED;
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event // Wait for OPEN_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
} }
virtual void TearDown() override { virtual void TearDown() override {
EXPECT_EQ(NfcStatus::OK, nfc_->close()); EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event // Wait for CLOSE_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
} }
/* Used as a mechanism to inform the test about data/event callback */
inline void notify() {
std::unique_lock<std::mutex> lock(mtx);
count++;
cv.notify_one();
}
/* Test code calls this function to wait for data/event callback */
inline std::cv_status wait() {
std::unique_lock<std::mutex> lock(mtx);
std::cv_status status = std::cv_status::no_timeout;
auto now = std::chrono::system_clock::now();
while (count == 0) {
status = cv.wait_until(lock, now + std::chrono::seconds(TIMEOUT_PERIOD));
if (status == std::cv_status::timeout) return status;
}
count--;
return status;
}
/* Callback class for data & Event. */
class NfcClientCallback : public INfcClientCallback {
NfcHidlTest& parent_;
public:
NfcClientCallback(NfcHidlTest& parent) : parent_(parent){};
virtual ~NfcClientCallback() = default;
/* sendEvent callback function - Records the Event & Status
* and notifies the TEST
**/
Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
parent_.last_event_ = event;
parent_.last_status_ = event_status;
parent_.notify();
return Void();
};
/* sendData callback function. Records the data and notifies the TEST*/
Return<void> sendData(const NfcData& data) override {
size_t size = parent_.last_data_.size();
parent_.last_data_.resize(size + 1);
parent_.last_data_[size] = data;
parent_.notify();
return Void();
};
};
sp<INfc> nfc_; sp<INfc> nfc_;
sp<INfcClientCallback> nfc_cb_; sp<NfcClientCallback> nfc_cb_;
NfcEvent last_event_;
NfcStatus last_status_;
hidl_vec<NfcData> last_data_;
private:
std::mutex mtx;
std::condition_variable cv;
int count;
}; };
// A class for test environment setup (kept since this file is a template). // A class for test environment setup (kept since this file is a template).
@@ -175,12 +150,12 @@ TEST_F(NfcHidlTest, WriteCoreReset) {
NfcData data = cmd; NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data)); EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_RESET_RSP // Wait for CORE_RESET_RSP
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(1ul, last_data_.size()); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(6ul, last_data_[0].size()); EXPECT_EQ(6ul, res.args->last_data_.size());
EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]); EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
EXPECT_GE(VERSION, last_data_[0][4]); EXPECT_GE(VERSION, res.args->last_data_[4]);
EXPECT_EQ(0ul, last_data_[0][5]); EXPECT_EQ(0ul, res.args->last_data_[5]);
} }
/* /*
@@ -194,12 +169,12 @@ TEST_F(NfcHidlTest, WriteCoreResetConfigReset) {
NfcData data = cmd; NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data)); EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_RESET_RSP // Wait for CORE_RESET_RSP
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(1ul, last_data_.size()); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(6ul, last_data_[0].size()); EXPECT_EQ(6ul, res.args->last_data_.size());
EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]); EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
EXPECT_GE(VERSION, last_data_[0][4]); EXPECT_GE(VERSION, res.args->last_data_[4]);
EXPECT_EQ(1ul, last_data_[0][5]); EXPECT_EQ(1ul, res.args->last_data_[5]);
} }
/* /*
@@ -214,10 +189,10 @@ TEST_F(NfcHidlTest, WriteInvalidCommand) {
NfcData data = cmd; NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data)); EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for RSP // Wait for RSP
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(1ul, last_data_.size()); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(4ul, last_data_[0].size()); EXPECT_EQ(4ul, res.args->last_data_.size());
EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]); EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
} }
/* /*
@@ -236,29 +211,27 @@ TEST_F(NfcHidlTest, WriteInvalidAndThenValidCommand) {
size_t size = data.size(); size_t size = data.size();
for (int i = 0; i < 100; i++) { for (int i = 0; i < 100; i++) {
last_data_.resize(0);
data.resize(++size); data.resize(++size);
data[size - 1] = 0xFF; data[size - 1] = 0xFF;
EXPECT_EQ(data.size(), nfc_->write(data)); EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_INTERFACE_ERROR_NTF // Wait for CORE_INTERFACE_ERROR_NTF
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(1ul, last_data_.size()); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(5ul, last_data_[0].size()); EXPECT_EQ(5ul, res.args->last_data_.size());
EXPECT_EQ(0x60, last_data_[0][0]); EXPECT_EQ(0x60, res.args->last_data_[0]);
EXPECT_EQ(0x08, last_data_[0][1]); EXPECT_EQ(0x08, res.args->last_data_[1]);
EXPECT_EQ(0x02, last_data_[0][2]); EXPECT_EQ(0x02, res.args->last_data_[2]);
EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]); EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
} }
cmd = CORE_CONN_CREATE_CMD; cmd = CORE_CONN_CREATE_CMD;
data = cmd; data = cmd;
last_data_.resize(0);
EXPECT_EQ(data.size(), nfc_->write(data)); EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_CONN_CREATE_RSP // Wait for CORE_CONN_CREATE_RSP
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(1ul, last_data_.size()); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(7ul, last_data_[0].size()); EXPECT_EQ(7ul, res.args->last_data_.size());
EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]); EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
} }
/* /*
* Bandwidth: * Bandwidth:
@@ -273,40 +246,48 @@ TEST_F(NfcHidlTest, Bandwidth) {
NfcData data = cmd; NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data)); EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_CONN_CREATE_RSP // Wait for CORE_CONN_CREATE_RSP
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(1ul, last_data_.size()); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(7ul, last_data_[0].size()); EXPECT_EQ(7ul, res.args->last_data_.size());
EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]); EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
uint8_t conn_id = last_data_[0][6]; uint8_t conn_id = res.args->last_data_[6];
uint32_t max_payload_size = last_data_[0][4]; uint32_t max_payload_size = res.args->last_data_[4];
for (int loops = 0; loops < NUMBER_LOOPS; loops++) { for (int loops = 0; loops < NUMBER_LOOPS; loops++) {
last_data_.resize(0); res.args->last_data_.resize(0);
data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE); data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
data[0] = conn_id; data[0] = conn_id;
data[1] = 0x00; data[1] = 0x00;
data[2] = max_payload_size; data[2] = max_payload_size;
for (uint32_t i = 0; i < max_payload_size; i++) { for (uint32_t i = 0; i < max_payload_size; i++) {
data[i + LOOP_BACK_HEADER_SIZE] = i; data[i + LOOP_BACK_HEADER_SIZE] = i;
} }
EXPECT_EQ(max_payload_size + LOOP_BACK_HEADER_SIZE, nfc_->write(data)); EXPECT_EQ(max_payload_size + LOOP_BACK_HEADER_SIZE, nfc_->write(data));
// Wait for data and CORE_CONN_CREDITS_NTF // Wait for data and CORE_CONN_CREDITS_NTF
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res1 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(std::cv_status::no_timeout, wait()); EXPECT_TRUE(res1.no_timeout);
// Check if the same data was recieved back auto res2 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
EXPECT_EQ(2ul, last_data_.size()); EXPECT_TRUE(res2.no_timeout);
// Check if the same data was received back
EXPECT_TRUE(res1.args);
EXPECT_TRUE(res2.args);
NfcData credits_ntf = res1.args->last_data_;
NfcData received_data = res2.args->last_data_;
/* It is possible that CORE_CONN_CREDITS_NTF is received before data, /* It is possible that CORE_CONN_CREDITS_NTF is received before data,
* Find the order and do further checks depending on that */ * Find the order and do further checks depending on that */
uint8_t data_index = last_data_[0].size() == data.size() ? 0 : 1; if (received_data.size() != data.size()) {
EXPECT_EQ(data.size(), last_data_[data_index].size()); credits_ntf = res2.args->last_data_;
received_data = res1.args->last_data_;
}
EXPECT_EQ(data.size(), received_data.size());
for (size_t i = 0; i < data.size(); i++) { for (size_t i = 0; i < data.size(); i++) {
EXPECT_EQ(data[i], last_data_[data_index][i]); EXPECT_EQ(data[i], received_data[i]);
} }
EXPECT_EQ(6ul, last_data_[!data_index].size()); EXPECT_EQ(6ul, credits_ntf.size());
// Check if the credit is refilled to 1 // Check if the credit is refilled to 1
EXPECT_EQ(1, last_data_[!data_index][5]); EXPECT_EQ(1, credits_ntf[5]);
} }
} }
@@ -319,9 +300,10 @@ TEST_F(NfcHidlTest, Bandwidth) {
TEST_F(NfcHidlTest, PowerCycle) { TEST_F(NfcHidlTest, PowerCycle) {
EXPECT_EQ(NfcStatus::OK, nfc_->powerCycle()); EXPECT_EQ(NfcStatus::OK, nfc_->powerCycle());
// Wait for NfcEvent.OPEN_CPLT // Wait for NfcEvent.OPEN_CPLT
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
} }
/* /*
@@ -332,17 +314,19 @@ TEST_F(NfcHidlTest, PowerCycle) {
TEST_F(NfcHidlTest, PowerCycleAfterClose) { TEST_F(NfcHidlTest, PowerCycleAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close()); EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event // Wait for CLOSE_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::FAILED, nfc_->powerCycle()); EXPECT_EQ(NfcStatus::FAILED, nfc_->powerCycle());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event // Wait for OPEN_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
} }
/* /*
@@ -353,13 +337,17 @@ TEST_F(NfcHidlTest, PowerCycleAfterClose) {
TEST_F(NfcHidlTest, CoreInitialized) { TEST_F(NfcHidlTest, CoreInitialized) {
NfcData data; NfcData data;
data.resize(1); data.resize(1);
for (int i = 0; i <= 6; i++) NfcEvent last_event_;
{ for (int i = 0; i <= 6; i++) {
data[0] = i; data[0] = i;
EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data)); EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
// Wait for NfcEvent.POST_INIT_CPLT // Wait for NfcEvent.POST_INIT_CPLT
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallbackAny();
EXPECT_EQ(NfcEvent::POST_INIT_CPLT, last_event_); if (res.name.compare(kCallbackNameSendEvent) == 0) {
last_event_ = res.args->last_event_;
}
EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcEvent::POST_INIT_CPLT, last_event_);
} }
} }
@@ -380,17 +368,19 @@ TEST_F(NfcHidlTest, ControlGranted) {
TEST_F(NfcHidlTest, ControlGrantedAfterClose) { TEST_F(NfcHidlTest, ControlGrantedAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close()); EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event // Wait for CLOSE_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted()); EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event // Wait for OPEN_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
} }
/* PreDiscover: /* PreDiscover:
@@ -409,17 +399,19 @@ TEST_F(NfcHidlTest, PreDiscover) {
TEST_F(NfcHidlTest, PreDiscoverAfterClose) { TEST_F(NfcHidlTest, PreDiscoverAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close()); EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event // Wait for CLOSE_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::OK, nfc_->prediscover()); EXPECT_EQ(NfcStatus::OK, nfc_->prediscover());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event // Wait for OPEN_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
} }
/* /*
@@ -430,20 +422,21 @@ TEST_F(NfcHidlTest, PreDiscoverAfterClose) {
TEST_F(NfcHidlTest, CloseAfterClose) { TEST_F(NfcHidlTest, CloseAfterClose) {
EXPECT_EQ(NfcStatus::OK, nfc_->close()); EXPECT_EQ(NfcStatus::OK, nfc_->close());
// Wait for CLOSE_CPLT event // Wait for CLOSE_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
EXPECT_EQ(NfcStatus::FAILED, nfc_->close()); EXPECT_EQ(NfcStatus::FAILED, nfc_->close());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_)); EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// Wait for OPEN_CPLT event // Wait for OPEN_CPLT event
EXPECT_EQ(std::cv_status::no_timeout, wait()); res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_); EXPECT_TRUE(res.no_timeout);
EXPECT_EQ(NfcStatus::OK, last_status_); EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
} }
/* /*
* OpenAfterOpen: * OpenAfterOpen:
* Calls open() multiple times * Calls open() multiple times