Merge "Camera: add HAL1 recording batching support" into oc-dev
diff --git a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
index 9a4efae..d699f21 100644
--- a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
+++ b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
@@ -23,9 +23,8 @@
#include <hardware/bluetooth.h>
#include <utils/Log.h>
+#include <VtsHalHidlTargetCallbackBase.h>
#include <VtsHalHidlTargetTestBase.h>
-#include <condition_variable>
-#include <mutex>
#include <queue>
using ::android::hardware::bluetooth::V1_0::IBluetoothHci;
@@ -92,6 +91,11 @@
#define ACL_BROADCAST_ACTIVE_SLAVE (0x1 << 4)
#define ACL_PACKET_BOUNDARY_COMPLETE (0x3 << 6)
+constexpr char kCallbackNameAclEventReceived[] = "aclDataReceived";
+constexpr char kCallbackNameHciEventReceived[] = "hciEventReceived";
+constexpr char kCallbackNameInitializationComplete[] = "initializationComplete";
+constexpr char kCallbackNameScoEventReceived[] = "scoDataReceived";
+
class ThroughputLogger {
public:
ThroughputLogger(std::string task)
@@ -121,7 +125,8 @@
public:
virtual void SetUp() override {
// currently test passthrough mode only
- bluetooth = ::testing::VtsHalHidlTargetTestBase::getService<IBluetoothHci>();
+ bluetooth =
+ ::testing::VtsHalHidlTargetTestBase::getService<IBluetoothHci>();
ASSERT_NE(bluetooth, nullptr);
ALOGI("%s: getService() for bluetooth is %s", __func__,
bluetooth->isRemote() ? "remote" : "local");
@@ -135,10 +140,6 @@
max_sco_data_packets = 0;
initialized = false;
- initialized_count = 0;
- event_count = 0;
- acl_count = 0;
- sco_count = 0;
event_cb_count = 0;
acl_cb_count = 0;
sco_cb_count = 0;
@@ -146,7 +147,18 @@
ASSERT_EQ(initialized, false);
bluetooth->initialize(bluetooth_cb);
- wait_for_init_callback();
+ bluetooth_cb->SetWaitTimeout(kCallbackNameInitializationComplete,
+ WAIT_FOR_INIT_TIMEOUT);
+ bluetooth_cb->SetWaitTimeout(kCallbackNameHciEventReceived,
+ WAIT_FOR_HCI_EVENT_TIMEOUT);
+ bluetooth_cb->SetWaitTimeout(kCallbackNameAclEventReceived,
+ WAIT_FOR_ACL_DATA_TIMEOUT);
+ bluetooth_cb->SetWaitTimeout(kCallbackNameScoEventReceived,
+ WAIT_FOR_SCO_DATA_TIMEOUT);
+
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameInitializationComplete)
+ .no_timeout);
ASSERT_EQ(initialized, true);
}
@@ -171,82 +183,10 @@
void wait_for_command_complete_event(hidl_vec<uint8_t> cmd);
int wait_for_completed_packets_event(uint16_t handle);
- // Inform the test about the initialization callback
- inline void notify_initialized() {
- std::unique_lock<std::mutex> lock(initialized_mutex);
- initialized_count++;
- initialized_condition.notify_one();
- }
-
- // Test code calls this function to wait for the init callback
- inline void wait_for_init_callback() {
- std::unique_lock<std::mutex> lock(initialized_mutex);
-
- auto start_time = std::chrono::steady_clock::now();
- while (initialized_count == 0)
- if (initialized_condition.wait_until(lock,
- start_time + WAIT_FOR_INIT_TIMEOUT) ==
- std::cv_status::timeout)
- return;
- initialized_count--;
- }
-
- // Inform the test about an event callback
- inline void notify_event_received() {
- std::unique_lock<std::mutex> lock(event_mutex);
- event_count++;
- event_condition.notify_one();
- }
-
- // Test code calls this function to wait for an event callback
- inline void wait_for_event() {
- std::unique_lock<std::mutex> lock(event_mutex);
-
- auto start_time = std::chrono::steady_clock::now();
- while (event_count == 0)
- if (event_condition.wait_until(lock,
- start_time + WAIT_FOR_HCI_EVENT_TIMEOUT) ==
- std::cv_status::timeout)
- return;
- event_count--;
- }
-
- // Inform the test about an acl data callback
- inline void notify_acl_data_received() {
- std::unique_lock<std::mutex> lock(acl_mutex);
- acl_count++;
- acl_condition.notify_one();
- }
-
- // Test code calls this function to wait for an acl data callback
- inline void wait_for_acl() {
- std::unique_lock<std::mutex> lock(acl_mutex);
-
- while (acl_count == 0)
- acl_condition.wait_until(
- lock, std::chrono::steady_clock::now() + WAIT_FOR_ACL_DATA_TIMEOUT);
- acl_count--;
- }
-
- // Inform the test about a sco data callback
- inline void notify_sco_data_received() {
- std::unique_lock<std::mutex> lock(sco_mutex);
- sco_count++;
- sco_condition.notify_one();
- }
-
- // Test code calls this function to wait for a sco data callback
- inline void wait_for_sco() {
- std::unique_lock<std::mutex> lock(sco_mutex);
-
- while (sco_count == 0)
- sco_condition.wait_until(
- lock, std::chrono::steady_clock::now() + WAIT_FOR_SCO_DATA_TIMEOUT);
- sco_count--;
- }
-
// A simple test implementation of BluetoothHciCallbacks.
- class BluetoothHciCallbacks : public IBluetoothHciCallbacks {
+ class BluetoothHciCallbacks
+ : public ::testing::VtsHalHidlTargetCallbackBase<BluetoothHidlTest>,
+ public IBluetoothHciCallbacks {
BluetoothHidlTest& parent_;
public:
@@ -256,7 +196,7 @@
Return<void> initializationComplete(Status status) override {
parent_.initialized = (status == Status::SUCCESS);
- parent_.notify_initialized();
+ NotifyFromCallback(kCallbackNameInitializationComplete);
ALOGV("%s (status = %d)", __func__, static_cast<int>(status));
return Void();
};
@@ -265,7 +205,7 @@
const ::android::hardware::hidl_vec<uint8_t>& event) override {
parent_.event_cb_count++;
parent_.event_queue.push(event);
- parent_.notify_event_received();
+ NotifyFromCallback(kCallbackNameHciEventReceived);
ALOGV("Event received (length = %d)", static_cast<int>(event.size()));
return Void();
};
@@ -274,7 +214,7 @@
const ::android::hardware::hidl_vec<uint8_t>& data) override {
parent_.acl_cb_count++;
parent_.acl_queue.push(data);
- parent_.notify_acl_data_received();
+ NotifyFromCallback(kCallbackNameAclEventReceived);
return Void();
};
@@ -282,13 +222,13 @@
const ::android::hardware::hidl_vec<uint8_t>& data) override {
parent_.sco_cb_count++;
parent_.sco_queue.push(data);
- parent_.notify_sco_data_received();
+ NotifyFromCallback(kCallbackNameScoEventReceived);
return Void();
};
};
sp<IBluetoothHci> bluetooth;
- sp<IBluetoothHciCallbacks> bluetooth_cb;
+ sp<BluetoothHciCallbacks> bluetooth_cb;
std::queue<hidl_vec<uint8_t>> event_queue;
std::queue<hidl_vec<uint8_t>> acl_queue;
std::queue<hidl_vec<uint8_t>> sco_queue;
@@ -303,20 +243,6 @@
int max_sco_data_packet_length;
int max_acl_data_packets;
int max_sco_data_packets;
-
- private:
- std::mutex initialized_mutex;
- std::mutex event_mutex;
- std::mutex sco_mutex;
- std::mutex acl_mutex;
- std::condition_variable initialized_condition;
- std::condition_variable event_condition;
- std::condition_variable sco_condition;
- std::condition_variable acl_condition;
- int initialized_count;
- int event_count;
- int sco_count;
- int acl_count;
};
// A class for test environment setup (kept since this file is a template).
@@ -334,11 +260,12 @@
int status_event_count = 0;
hidl_vec<uint8_t> event;
do {
- wait_for_event();
- EXPECT_LT(static_cast<size_t>(0), event_queue.size());
- if (event_queue.size() == 0) {
- event.resize(0);
- break;
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
+ EXPECT_LT(static_cast<size_t>(0), event_queue.size());
+ if (event_queue.size() == 0) {
+ event.resize(0);
+ break;
}
event = event_queue.front();
event_queue.pop();
@@ -366,7 +293,8 @@
hidl_vec<uint8_t> cmd = COMMAND_HCI_READ_BUFFER_SIZE;
bluetooth->sendHciCommand(cmd);
- wait_for_event();
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
EXPECT_LT(static_cast<size_t>(0), event_queue.size());
if (event_queue.size() == 0) return;
@@ -420,7 +348,8 @@
bluetooth->sendHciCommand(cmd);
// Check the loopback of the HCI packet
- wait_for_event();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
size_t compare_length =
@@ -456,7 +385,8 @@
bluetooth->sendScoData(sco_vector);
// Check the loopback of the SCO packet
- wait_for_sco();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameScoEventReceived)
+ .no_timeout);
hidl_vec<uint8_t> sco_loopback = sco_queue.front();
sco_queue.pop();
@@ -501,7 +431,8 @@
bluetooth->sendAclData(acl_vector);
// Check the loopback of the ACL packet
- wait_for_acl();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameAclEventReceived)
+ .no_timeout);
hidl_vec<uint8_t> acl_loopback = acl_queue.front();
acl_queue.pop();
@@ -527,19 +458,20 @@
// Return the number of completed packets reported by the controller.
int BluetoothHidlTest::wait_for_completed_packets_event(uint16_t handle) {
- wait_for_event();
- int packets_processed = 0;
- while (event_queue.size() > 0) {
- hidl_vec<uint8_t> event = event_queue.front();
- event_queue.pop();
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
+ int packets_processed = 0;
+ while (event_queue.size() > 0) {
+ hidl_vec<uint8_t> event = event_queue.front();
+ event_queue.pop();
- EXPECT_EQ(EVENT_NUMBER_OF_COMPLETED_PACKETS, event[EVENT_CODE_BYTE]);
- EXPECT_EQ(1, event[EVENT_NUMBER_OF_COMPLETED_PACKETS_NUM_HANDLES]);
+ EXPECT_EQ(EVENT_NUMBER_OF_COMPLETED_PACKETS, event[EVENT_CODE_BYTE]);
+ EXPECT_EQ(1, event[EVENT_NUMBER_OF_COMPLETED_PACKETS_NUM_HANDLES]);
- uint16_t event_handle = event[3] + (event[4] << 8);
- EXPECT_EQ(handle, event_handle);
+ uint16_t event_handle = event[3] + (event[4] << 8);
+ EXPECT_EQ(handle, event_handle);
- packets_processed += event[5] + (event[6] << 8);
+ packets_processed += event[5] + (event[6] << 8);
}
return packets_processed;
}
@@ -554,32 +486,34 @@
int connection_event_count = 0;
hidl_vec<uint8_t> event;
do {
- wait_for_event();
- event = event_queue.front();
- event_queue.pop();
- EXPECT_GT(event.size(),
- static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
- if (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE) {
+ EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived)
+ .no_timeout);
+ event = event_queue.front();
+ event_queue.pop();
EXPECT_GT(event.size(),
- static_cast<size_t>(EVENT_CONNECTION_COMPLETE_TYPE));
- EXPECT_EQ(event[EVENT_LENGTH_BYTE],
- EVENT_CONNECTION_COMPLETE_PARAM_LENGTH);
- uint8_t connection_type = event[EVENT_CONNECTION_COMPLETE_TYPE];
+ static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
+ if (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE) {
+ EXPECT_GT(event.size(),
+ static_cast<size_t>(EVENT_CONNECTION_COMPLETE_TYPE));
+ EXPECT_EQ(event[EVENT_LENGTH_BYTE],
+ EVENT_CONNECTION_COMPLETE_PARAM_LENGTH);
+ uint8_t connection_type = event[EVENT_CONNECTION_COMPLETE_TYPE];
- EXPECT_TRUE(connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO ||
- connection_type == EVENT_CONNECTION_COMPLETE_TYPE_ACL);
+ EXPECT_TRUE(connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO ||
+ connection_type == EVENT_CONNECTION_COMPLETE_TYPE_ACL);
- // Save handles
- uint16_t handle = event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE] |
- event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE + 1] << 8;
- if (connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO)
- sco_handles.push_back(handle);
- else
- acl_handles.push_back(handle);
+ // Save handles
+ uint16_t handle = event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE] |
+ event[EVENT_CONNECTION_COMPLETE_HANDLE_LSBYTE + 1]
+ << 8;
+ if (connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO)
+ sco_handles.push_back(handle);
+ else
+ acl_handles.push_back(handle);
- ALOGD("Connect complete type = %d handle = %d",
- event[EVENT_CONNECTION_COMPLETE_TYPE], handle);
- connection_event_count++;
+ ALOGD("Connect complete type = %d handle = %d",
+ event[EVENT_CONNECTION_COMPLETE_TYPE], handle);
+ connection_event_count++;
}
} while (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE);
@@ -592,7 +526,7 @@
}
// Empty test: Initialize()/Close() are called in SetUp()/TearDown().
-TEST_F(BluetoothHidlTest, InitializeAndClose) { }
+TEST_F(BluetoothHidlTest, InitializeAndClose) {}
// Send an HCI Reset with sendHciCommand and wait for a command complete event.
TEST_F(BluetoothHidlTest, HciReset) {
@@ -607,7 +541,8 @@
hidl_vec<uint8_t> cmd = COMMAND_HCI_READ_LOCAL_VERSION_INFORMATION;
bluetooth->sendHciCommand(cmd);
- wait_for_event();
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
@@ -627,7 +562,8 @@
hidl_vec<uint8_t> cmd = COMMAND_HCI_SHOULD_BE_UNKNOWN;
bluetooth->sendHciCommand(cmd);
- wait_for_event();
+ EXPECT_TRUE(
+ bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout);
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
diff --git a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
index aa3bc9c..9da58e2 100644
--- a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
+++ b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
@@ -22,10 +22,8 @@
#include <android/hardware/nfc/1.0/types.h>
#include <hardware/nfc.h>
+#include <VtsHalHidlTargetCallbackBase.h>
#include <VtsHalHidlTargetTestBase.h>
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
using ::android::hardware::nfc::V1_0::INfc;
using ::android::hardware::nfc::V1_0::INfcClientCallback;
@@ -55,6 +53,43 @@
#define VERSION 0x11
#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.
class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
public:
@@ -62,88 +97,28 @@
nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
ASSERT_NE(nfc_, nullptr);
- nfc_cb_ = new NfcClientCallback(*this);
+ nfc_cb_ = new NfcClientCallback();
ASSERT_NE(nfc_cb_, nullptr);
- count = 0;
- last_event_ = NfcEvent::ERROR;
- last_status_ = NfcStatus::FAILED;
-
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// 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_);
+ 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
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::CLOSE_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ 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_);
}
- /* 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<INfcClientCallback> nfc_cb_;
- NfcEvent last_event_;
- NfcStatus last_status_;
- hidl_vec<NfcData> last_data_;
-
- private:
- std::mutex mtx;
- std::condition_variable cv;
- int count;
+ sp<NfcClientCallback> nfc_cb_;
};
// A class for test environment setup (kept since this file is a template).
@@ -175,12 +150,12 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_RESET_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(6ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
- EXPECT_GE(VERSION, last_data_[0][4]);
- EXPECT_EQ(0ul, last_data_[0][5]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(6ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+ EXPECT_GE(VERSION, res.args->last_data_[4]);
+ EXPECT_EQ(0ul, res.args->last_data_[5]);
}
/*
@@ -194,12 +169,12 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_RESET_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(6ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
- EXPECT_GE(VERSION, last_data_[0][4]);
- EXPECT_EQ(1ul, last_data_[0][5]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(6ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+ EXPECT_GE(VERSION, res.args->last_data_[4]);
+ EXPECT_EQ(1ul, res.args->last_data_[5]);
}
/*
@@ -214,10 +189,10 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(4ul, last_data_[0].size());
- EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(4ul, res.args->last_data_.size());
+ EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
}
/*
@@ -236,29 +211,27 @@
size_t size = data.size();
for (int i = 0; i < 100; i++) {
- last_data_.resize(0);
data.resize(++size);
data[size - 1] = 0xFF;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_INTERFACE_ERROR_NTF
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(5ul, last_data_[0].size());
- EXPECT_EQ(0x60, last_data_[0][0]);
- EXPECT_EQ(0x08, last_data_[0][1]);
- EXPECT_EQ(0x02, last_data_[0][2]);
- EXPECT_EQ(SYNTAX_ERROR, last_data_[0][3]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(5ul, res.args->last_data_.size());
+ EXPECT_EQ(0x60, res.args->last_data_[0]);
+ EXPECT_EQ(0x08, res.args->last_data_[1]);
+ EXPECT_EQ(0x02, res.args->last_data_[2]);
+ EXPECT_EQ(SYNTAX_ERROR, res.args->last_data_[3]);
}
cmd = CORE_CONN_CREATE_CMD;
data = cmd;
- last_data_.resize(0);
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_CONN_CREATE_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(7ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(7ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
}
/*
* Bandwidth:
@@ -273,40 +246,48 @@
NfcData data = cmd;
EXPECT_EQ(data.size(), nfc_->write(data));
// Wait for CORE_CONN_CREATE_RSP
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(1ul, last_data_.size());
- EXPECT_EQ(7ul, last_data_[0].size());
- EXPECT_EQ((int)NfcStatus::OK, last_data_[0][3]);
- uint8_t conn_id = last_data_[0][6];
- uint32_t max_payload_size = last_data_[0][4];
+ auto res = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res.no_timeout);
+ EXPECT_EQ(7ul, res.args->last_data_.size());
+ EXPECT_EQ((int)NfcStatus::OK, res.args->last_data_[3]);
+ uint8_t conn_id = res.args->last_data_[6];
+ uint32_t max_payload_size = res.args->last_data_[4];
for (int loops = 0; loops < NUMBER_LOOPS; loops++) {
- last_data_.resize(0);
- data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
- data[0] = conn_id;
- data[1] = 0x00;
- data[2] = max_payload_size;
- for (uint32_t i = 0; i < max_payload_size; i++) {
- data[i + LOOP_BACK_HEADER_SIZE] = i;
+ res.args->last_data_.resize(0);
+ data.resize(max_payload_size + LOOP_BACK_HEADER_SIZE);
+ data[0] = conn_id;
+ data[1] = 0x00;
+ data[2] = max_payload_size;
+ for (uint32_t i = 0; i < max_payload_size; i++) {
+ data[i + LOOP_BACK_HEADER_SIZE] = i;
}
EXPECT_EQ(max_payload_size + LOOP_BACK_HEADER_SIZE, nfc_->write(data));
// Wait for data and CORE_CONN_CREDITS_NTF
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- // Check if the same data was recieved back
- EXPECT_EQ(2ul, last_data_.size());
+ auto res1 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ EXPECT_TRUE(res1.no_timeout);
+ auto res2 = nfc_cb_->WaitForCallback(kCallbackNameSendData);
+ 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,
* Find the order and do further checks depending on that */
- uint8_t data_index = last_data_[0].size() == data.size() ? 0 : 1;
- EXPECT_EQ(data.size(), last_data_[data_index].size());
+ if (received_data.size() != data.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++) {
- 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
- EXPECT_EQ(1, last_data_[!data_index][5]);
+ EXPECT_EQ(1, credits_ntf[5]);
}
}
@@ -319,9 +300,10 @@
TEST_F(NfcHidlTest, PowerCycle) {
EXPECT_EQ(NfcStatus::OK, nfc_->powerCycle());
// Wait for NfcEvent.OPEN_CPLT
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::OPEN_CPLT, last_event_);
- EXPECT_EQ(NfcStatus::OK, last_status_);
+ 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_);
}
/*
@@ -332,17 +314,19 @@
TEST_F(NfcHidlTest, PowerCycleAfterClose) {
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_);
+ 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_);
EXPECT_EQ(NfcStatus::FAILED, nfc_->powerCycle());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// 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_);
+ 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_);
}
/*
@@ -353,13 +337,17 @@
TEST_F(NfcHidlTest, CoreInitialized) {
NfcData data;
data.resize(1);
- for (int i = 0; i <= 6; i++)
- {
- data[0] = i;
- EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
- // Wait for NfcEvent.POST_INIT_CPLT
- EXPECT_EQ(std::cv_status::no_timeout, wait());
- EXPECT_EQ(NfcEvent::POST_INIT_CPLT, last_event_);
+ NfcEvent last_event_;
+ for (int i = 0; i <= 6; i++) {
+ data[0] = i;
+ EXPECT_EQ(NfcStatus::OK, nfc_->coreInitialized(data));
+ // Wait for NfcEvent.POST_INIT_CPLT
+ 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_);
}
}
@@ -380,17 +368,19 @@
TEST_F(NfcHidlTest, ControlGrantedAfterClose) {
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_);
+ 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_);
EXPECT_EQ(NfcStatus::OK, nfc_->controlGranted());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// 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_);
+ 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_);
}
/* PreDiscover:
@@ -409,17 +399,19 @@
TEST_F(NfcHidlTest, PreDiscoverAfterClose) {
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_);
+ 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_);
EXPECT_EQ(NfcStatus::OK, nfc_->prediscover());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// 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_);
+ 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_);
}
/*
@@ -430,20 +422,21 @@
TEST_F(NfcHidlTest, CloseAfterClose) {
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_);
+ 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_);
EXPECT_EQ(NfcStatus::FAILED, nfc_->close());
EXPECT_EQ(NfcStatus::OK, nfc_->open(nfc_cb_));
// 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_);
+ 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_);
}
-
/*
* OpenAfterOpen:
* Calls open() multiple times