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

Merge "VtsBluetooth: Use ASSERT_* to end the test ASAP"

Browse Source
This commit is contained in:
Myles Watson
2021-04-02 16:36:16 +00:00
committed by Gerrit Code Review
parent 1a9bbebbca 244ad3663f
commit 21927e2ddd
1 changed files with 50 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
View File

@@ -179,7 +179,7 @@ class BluetoothHidlTest : public ::testing::TestWithParam<std::string> {
bluetooth_cb->SetWaitTimeout(kCallbackNameScoEventReceived,
WAIT_FOR_SCO_DATA_TIMEOUT);
EXPECT_TRUE(
ASSERT_TRUE(
bluetooth_cb->WaitForCallback(kCallbackNameInitializationComplete)
.no_timeout);
@@ -289,7 +289,7 @@ class BluetoothHidlTest : public ::testing::TestWithParam<std::string> {
void BluetoothHidlTest::handle_no_ops() {
while (event_queue.size() > 0) {
hidl_vec<uint8_t> event = event_queue.front();
EXPECT_GE(event.size(),
ASSERT_GE(event.size(),
static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
bool event_is_no_op =
(event[EVENT_CODE_BYTE] == EVENT_COMMAND_COMPLETE) &&
@@ -327,7 +327,7 @@ void BluetoothHidlTest::wait_for_event(bool timeout_is_error = true) {
bluetooth_cb->WaitForCallback(kCallbackNameHciEventReceived).no_timeout;
EXPECT_TRUE(no_timeout || !timeout_is_error);
if (no_timeout && timeout_is_error) {
EXPECT_LT(static_cast<size_t>(0), event_queue.size());
ASSERT_LT(static_cast<size_t>(0), event_queue.size());
}
if (event_queue.size() == 0) {
// WaitForCallback timed out.
@@ -343,12 +343,12 @@ void BluetoothHidlTest::wait_for_command_complete_event(hidl_vec<uint8_t> cmd) {
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
EXPECT_GT(event.size(),
ASSERT_GT(event.size(),
static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
EXPECT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
EXPECT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
EXPECT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
EXPECT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
ASSERT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
ASSERT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
ASSERT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
ASSERT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
}
// Send the command to read the controller's buffer sizes.
@@ -362,10 +362,10 @@ void BluetoothHidlTest::setBufferSizes() {
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
EXPECT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
EXPECT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
EXPECT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
EXPECT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
ASSERT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
ASSERT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
ASSERT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
ASSERT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
max_acl_data_packet_length =
event[EVENT_COMMAND_COMPLETE_STATUS_BYTE + 1] +
@@ -415,10 +415,10 @@ void BluetoothHidlTest::sendAndCheckHCI(int num_packets) {
size_t compare_length =
(cmd.size() > static_cast<size_t>(0xff) ? static_cast<size_t>(0xff)
: cmd.size());
EXPECT_GT(event.size(), compare_length + EVENT_FIRST_PAYLOAD_BYTE - 1);
ASSERT_GT(event.size(), compare_length + EVENT_FIRST_PAYLOAD_BYTE - 1);
EXPECT_EQ(EVENT_LOOPBACK_COMMAND, event[EVENT_CODE_BYTE]);
EXPECT_EQ(compare_length, event[EVENT_LENGTH_BYTE]);
ASSERT_EQ(EVENT_LOOPBACK_COMMAND, event[EVENT_CODE_BYTE]);
ASSERT_EQ(compare_length, event[EVENT_LENGTH_BYTE]);
// Don't compare past the end of the event.
if (compare_length + EVENT_FIRST_PAYLOAD_BYTE > event.size()) {
@@ -455,12 +455,12 @@ void BluetoothHidlTest::sendAndCheckSCO(int num_packets, size_t size,
bluetooth->sendScoData(sco_vector);
// Check the loopback of the SCO packet
EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameScoEventReceived)
ASSERT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameScoEventReceived)
.no_timeout);
hidl_vec<uint8_t> sco_loopback = sco_queue.front();
sco_queue.pop();
EXPECT_EQ(sco_packet.size(), sco_loopback.size());
ASSERT_EQ(sco_packet.size(), sco_loopback.size());
size_t successful_bytes = 0;
for (size_t i = 0; i < sco_packet.size(); i++) {
@@ -474,7 +474,7 @@ void BluetoothHidlTest::sendAndCheckSCO(int num_packets, size_t size,
break;
}
}
EXPECT_EQ(sco_packet.size(), successful_bytes + 1);
ASSERT_EQ(sco_packet.size(), successful_bytes + 1);
}
logger.setTotalBytes(num_packets * size * 2);
}
@@ -500,26 +500,15 @@ void BluetoothHidlTest::sendAndCheckACL(int num_packets, size_t size,
bluetooth->sendAclData(acl_vector);
// Check the loopback of the ACL packet
EXPECT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameAclEventReceived)
ASSERT_TRUE(bluetooth_cb->WaitForCallback(kCallbackNameAclEventReceived)
.no_timeout);
hidl_vec<uint8_t> acl_loopback = acl_queue.front();
acl_queue.pop();
EXPECT_EQ(acl_packet.size(), acl_loopback.size());
size_t successful_bytes = 0;
for (size_t i = 0; i < acl_packet.size(); i++) {
if (acl_packet[i] == acl_loopback[i]) {
successful_bytes = i;
} else {
ALOGE("Miscompare at %d (expected %x, got %x)", static_cast<int>(i),
acl_packet[i], acl_loopback[i]);
ALOGE("At %d (expected %x, got %x)", static_cast<int>(i + 1),
acl_packet[i + 1], acl_loopback[i + 1]);
break;
}
for (size_t i = 0; i < acl_packet.size() && i < acl_loopback.size(); i++) {
EXPECT_EQ(acl_packet[i], acl_loopback[i]) << " at byte number " << i;
}
EXPECT_EQ(acl_packet.size(), successful_bytes + 1);
}
logger.setTotalBytes(num_packets * size * 2);
}
@@ -560,22 +549,22 @@ void BluetoothHidlTest::enterLoopbackMode(std::vector<uint16_t>& sco_handles,
wait_for_event(false);
if (event_queue.size() == 0) {
// Fail if there was no event received or no connections completed.
EXPECT_TRUE(command_complete_received);
EXPECT_LT(0, connection_event_count);
ASSERT_TRUE(command_complete_received);
ASSERT_LT(0, connection_event_count);
return;
}
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
EXPECT_GT(event.size(),
ASSERT_GT(event.size(),
static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
if (event[EVENT_CODE_BYTE] == EVENT_CONNECTION_COMPLETE) {
EXPECT_GT(event.size(),
ASSERT_GT(event.size(),
static_cast<size_t>(EVENT_CONNECTION_COMPLETE_TYPE));
EXPECT_EQ(event[EVENT_LENGTH_BYTE],
ASSERT_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 ||
ASSERT_TRUE(connection_type == EVENT_CONNECTION_COMPLETE_TYPE_SCO ||
connection_type == EVENT_CONNECTION_COMPLETE_TYPE_ACL);
// Save handles
@@ -590,10 +579,10 @@ void BluetoothHidlTest::enterLoopbackMode(std::vector<uint16_t>& sco_handles,
event[EVENT_CONNECTION_COMPLETE_TYPE], handle);
connection_event_count++;
} else {
EXPECT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
EXPECT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
EXPECT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
EXPECT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
ASSERT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
ASSERT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
ASSERT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
ASSERT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
command_complete_received = true;
}
}
@@ -620,15 +609,15 @@ TEST_P(BluetoothHidlTest, HciVersionTest) {
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
EXPECT_GT(event.size(), static_cast<size_t>(EVENT_LOCAL_LMP_VERSION_BYTE));
ASSERT_GT(event.size(), static_cast<size_t>(EVENT_LOCAL_LMP_VERSION_BYTE));
EXPECT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
EXPECT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
EXPECT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
EXPECT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
ASSERT_EQ(EVENT_COMMAND_COMPLETE, event[EVENT_CODE_BYTE]);
ASSERT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
ASSERT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
ASSERT_EQ(HCI_STATUS_SUCCESS, event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
EXPECT_LE(HCI_MINIMUM_HCI_VERSION, event[EVENT_LOCAL_HCI_VERSION_BYTE]);
EXPECT_LE(HCI_MINIMUM_LMP_VERSION, event[EVENT_LOCAL_LMP_VERSION_BYTE]);
ASSERT_LE(HCI_MINIMUM_HCI_VERSION, event[EVENT_LOCAL_HCI_VERSION_BYTE]);
ASSERT_LE(HCI_MINIMUM_LMP_VERSION, event[EVENT_LOCAL_LMP_VERSION_BYTE]);
}
// Send an unknown HCI command and wait for the error message.
@@ -642,18 +631,18 @@ TEST_P(BluetoothHidlTest, HciUnknownCommand) {
hidl_vec<uint8_t> event = event_queue.front();
event_queue.pop();
EXPECT_GT(event.size(),
ASSERT_GT(event.size(),
static_cast<size_t>(EVENT_COMMAND_COMPLETE_STATUS_BYTE));
if (event[EVENT_CODE_BYTE] == EVENT_COMMAND_COMPLETE) {
EXPECT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
EXPECT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
EXPECT_EQ(HCI_STATUS_UNKNOWN_HCI_COMMAND,
ASSERT_EQ(cmd[0], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE]);
ASSERT_EQ(cmd[1], event[EVENT_COMMAND_COMPLETE_OPCODE_LSBYTE + 1]);
ASSERT_EQ(HCI_STATUS_UNKNOWN_HCI_COMMAND,
event[EVENT_COMMAND_COMPLETE_STATUS_BYTE]);
} else {
EXPECT_EQ(EVENT_COMMAND_STATUS, event[EVENT_CODE_BYTE]);
EXPECT_EQ(cmd[0], event[EVENT_COMMAND_STATUS_OPCODE_LSBYTE]);
EXPECT_EQ(cmd[1], event[EVENT_COMMAND_STATUS_OPCODE_LSBYTE + 1]);
EXPECT_EQ(HCI_STATUS_UNKNOWN_HCI_COMMAND,
ASSERT_EQ(EVENT_COMMAND_STATUS, event[EVENT_CODE_BYTE]);
ASSERT_EQ(cmd[0], event[EVENT_COMMAND_STATUS_OPCODE_LSBYTE]);
ASSERT_EQ(cmd[1], event[EVENT_COMMAND_STATUS_OPCODE_LSBYTE + 1]);
ASSERT_EQ(HCI_STATUS_UNKNOWN_HCI_COMMAND,
event[EVENT_COMMAND_STATUS_STATUS_BYTE]);
}
}
@@ -678,7 +667,7 @@ TEST_P(BluetoothHidlTest, LoopbackModeSinglePackets) {
// This should work, but breaks on some current platforms. Figure out how to
// grandfather older devices but test new ones.
if (0 && sco_connection_handles.size() > 0) {
EXPECT_LT(0, max_sco_data_packet_length);
ASSERT_LT(0, max_sco_data_packet_length);
sendAndCheckSCO(1, max_sco_data_packet_length, sco_connection_handles[0]);
int sco_packets_sent = 1;
int completed_packets =
@@ -690,7 +679,7 @@ TEST_P(BluetoothHidlTest, LoopbackModeSinglePackets) {
}
if (acl_connection_handles.size() > 0) {
EXPECT_LT(0, max_acl_data_packet_length);
ASSERT_LT(0, max_acl_data_packet_length);
sendAndCheckACL(1, max_acl_data_packet_length, acl_connection_handles[0]);
int acl_packets_sent = 1;
int completed_packets =
@@ -715,7 +704,7 @@ TEST_P(BluetoothHidlTest, LoopbackModeBandwidth) {
// This should work, but breaks on some current platforms. Figure out how to
// grandfather older devices but test new ones.
if (0 && sco_connection_handles.size() > 0) {
EXPECT_LT(0, max_sco_data_packet_length);
ASSERT_LT(0, max_sco_data_packet_length);
sendAndCheckSCO(NUM_SCO_PACKETS_BANDWIDTH, max_sco_data_packet_length,
sco_connection_handles[0]);
int sco_packets_sent = NUM_SCO_PACKETS_BANDWIDTH;
@@ -728,7 +717,7 @@ TEST_P(BluetoothHidlTest, LoopbackModeBandwidth) {
}
if (acl_connection_handles.size() > 0) {
EXPECT_LT(0, max_acl_data_packet_length);
ASSERT_LT(0, max_acl_data_packet_length);
sendAndCheckACL(NUM_ACL_PACKETS_BANDWIDTH, max_acl_data_packet_length,
acl_connection_handles[0]);
int acl_packets_sent = NUM_ACL_PACKETS_BANDWIDTH;