NFC VTS test use VtsHalHidlCallbackBase for callback wait and notify (bfefc5ef) · Commits · e / os / android_hardware_interfaces

nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp

+153 −160

Original line number	Original line	Diff line number	Diff line
	@@ -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,95 +53,72 @@ using ::android::sp;
	#define VERSION 0x11		#define VERSION 0x11
	#define TIMEOUT_PERIOD 5		#define TIMEOUT_PERIOD 5

	// The main test class for NFC HIDL HAL.		constexpr char kCallbackNameSendEvent[] = "sendEvent";
	class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {		constexpr char kCallbackNameSendData[] = "sendData";
	public:
	virtual void SetUp() override {
	nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
	ASSERT_NE(nfc_, nullptr);

	nfc_cb_ = new NfcClientCallback(*this);
	ASSERT_NE(nfc_cb_, nullptr);

	count = 0;		class NfcClientCallbackArgs {
	last_event_ = NfcEvent::ERROR;		public:
	last_status_ = NfcStatus::FAILED;		NfcEvent last_event_;
			NfcStatus last_status_;
	EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));		NfcData last_data_;
	// Wait for OPEN_CPLT event		};
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
	EXPECT_EQ(NfcStatus::OK, last_status_);
	}

	virtual void TearDown() override {
	EXPECT_EQ(NfcStatus::OK, nfc_->close());
	// Wait for CLOSE_CPLT event
	EXPECT_EQ(std::cv_status::no_timeout, wait());
	EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
	EXPECT_EQ(NfcStatus::OK, 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. */		/* Callback class for data & Event. */
	class NfcClientCallback : public INfcClientCallback {		class NfcClientCallback
	NfcHidlTest& parent_;		: public ::testing::VtsHalHidlTargetCallbackBase<NfcClientCallbackArgs>,
			public INfcClientCallback {
	public:		public:
	NfcClientCallback(NfcHidlTest& parent) : parent_(parent){};

	virtual ~NfcClientCallback() = default;		virtual ~NfcClientCallback() = default;

	/* sendEvent callback function - Records the Event & Status		/* sendEvent callback function - Records the Event & Status
	* and notifies the TEST		* and notifies the TEST
	**/		**/
	Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {		Return<void> sendEvent(NfcEvent event, NfcStatus event_status) override {
	parent_.last_event_ = event;		NfcClientCallbackArgs args;
	parent_.last_status_ = event_status;		args.last_event_ = event;
	parent_.notify();		args.last_status_ = event_status;
			NotifyFromCallback(kCallbackNameSendEvent, args);
	return Void();		return Void();
	};		};

	/* sendData callback function. Records the data and notifies the TEST*/		/* sendData callback function. Records the data and notifies the TEST*/
	Return<void> sendData(const NfcData& data) override {		Return<void> sendData(const NfcData& data) override {
	size_t size = parent_.last_data_.size();		NfcClientCallbackArgs args;
	parent_.last_data_.resize(size + 1);		args.last_data_ = data;
	parent_.last_data_[size] = data;		NotifyFromCallback(kCallbackNameSendData, args);
	parent_.notify();
	return Void();		return Void();
	};		};
	};		};

	sp<INfc> nfc_;		// The main test class for NFC HIDL HAL.
	sp<INfcClientCallback> nfc_cb_;		class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
	NfcEvent last_event_;		public:
	NfcStatus last_status_;		virtual void SetUp() override {
	hidl_vec<NfcData> last_data_;		nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
			ASSERT_NE(nfc_, nullptr);

	private:		nfc_cb_ = new NfcClientCallback();
	std::mutex mtx;		ASSERT_NE(nfc_cb_, nullptr);
	std::condition_variable cv;
	int count;		EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
			// Wait for OPEN_CPLT event
			auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
			EXPECT_TRUE(res.no_timeout);
			EXPECT_EQ(NfcEvent::OPEN_CPLT, res.args->last_event_);
			EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
			}

			virtual void TearDown() override {
			EXPECT_EQ(NfcStatus::OK, nfc_->close());
			// Wait for CLOSE_CPLT event
			auto res = nfc_cb_->WaitForCallback(kCallbackNameSendEvent);
			EXPECT_TRUE(res.no_timeout);
			EXPECT_EQ(NfcEvent::CLOSE_CPLT, res.args->last_event_);
			EXPECT_EQ(NfcStatus::OK, res.args->last_status_);
			}

			sp<INfc> nfc_;
			sp<NfcClientCallback> nfc_cb_;
	};		};

	// 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,15 +246,15 @@ 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;
	@@ -291,22 +264,30 @@ TEST_F(NfcHidlTest, Bandwidth) {
	}		}
	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,12 +337,16 @@ 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();
			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_);		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