Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 21927e2d authored by Myles Watson's avatar Myles Watson Committed by Gerrit Code Review
Browse files

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

parents 1a9bbebb 244ad366

bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp

+50 −61
Original line number Diff line number Diff line
@@ -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;