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

Commit f991cd07 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge changes Ic1f5b589,I34e05959 am: 57c11d9f 

Original change: https://android-review.googlesource.com/c/platform/system/bt/+/1646072

Change-Id: I32dedbc0b37ce6bfa06eacfd6f742b109511bf37
parents f30d3420 57c11d9f

system/gd/Android.bp

+0 −2
Original line number Diff line number Diff line
@@ -377,7 +377,6 @@ cc_test { 
    },

    srcs: [

        "hci/address.cc",

        ":BluetoothCommonSources",

        ":BluetoothPacketSources",

        ":BluetoothPacketParserTestPacketTestSources",

    ],
@@ -389,7 +388,6 @@ cc_test { 
        cfi: true,

    },

    static_libs: [

        "libbluetooth_rust_interop",

        "libchrome",

        "libbt-platform-protos-lite",

    ],

system/gd/common/stop_watch.cc

+1 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <sstream>

#include <utility>



#include "common/init_flags.h"

#include "os/log.h"



namespace bluetooth {

system/gd/hal/snoop_logger.cc

+1 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include <sstream>



#include "common/circular_buffer.h"

#include "common/init_flags.h"

#include "common/strings.h"

#include "os/files.h"

#include "os/log.h"

system/gd/hci/hci_packets.pdl

+5 −9
Original line number Diff line number Diff line
@@ -2309,10 +2309,6 @@ packet WriteExtendedInquiryResponse : Command (op_code = WRITE_EXTENDED_INQUIRY_ 
  _padding_[240], // Zero padding GapData[] to be 240 octets

}



test WriteExtendedInquiryResponse {

  "\x52\x0c\xf1\x01\x0b\x09\x50\x69\x78\x65\x6c\x20\x33\x20\x58\x4c\x19\x03\x05\x11\x0a\x11\x0c\x11\x0e\x11\x12\x11\x15\x11\x16\x11\x1f\x11\x2d\x11\x2f\x11\x00\x12\x32\x11\x01\x05\x81\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",

}



packet WriteExtendedInquiryResponseComplete : CommandComplete (command_op_code = WRITE_EXTENDED_INQUIRY_RESPONSE) {

  status : ErrorCode,

}
@@ -3532,6 +3528,11 @@ packet LeSetExtendedAdvertisingLegacyParameters : LeAdvertisingCommand (op_code 
  scan_request_notification_enable : Enable,

}



test LeSetExtendedAdvertisingLegacyParameters {

  "\x36\x20\x19\x00\x13\x00\x90\x01\x00\xc2\x01\x00\x07\x01\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x01\x00\x01\x01\x00",

  "\x36\x20\x19\x01\x13\x00\x90\x01\x00\xc2\x01\x00\x07\x01\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x01\x00\x01\x01\x00",

}



packet LeSetExtendedAdvertisingParameters : LeAdvertisingCommand (op_code = LE_SET_EXTENDED_ADVERTISING_PARAMETERS) {

  advertising_handle : 8,

  advertising_event_legacy_properties : 4,
@@ -3555,11 +3556,6 @@ packet LeSetExtendedAdvertisingParameters : LeAdvertisingCommand (op_code = LE_S 
  scan_request_notification_enable : Enable,

}



test LeSetExtendedAdvertisingParameters {

  "\x36\x20\x19\x00\x13\x00\x90\x01\x00\xc2\x01\x00\x07\x01\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x01\x00\x01\x01\x00",

  "\x36\x20\x19\x01\x13\x00\x90\x01\x00\xc2\x01\x00\x07\x01\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x01\x00\x01\x01\x00",

}



packet LeSetExtendedAdvertisingParametersComplete : CommandComplete (command_op_code = LE_SET_EXTENDED_ADVERTISING_PARAMETERS) {

  status : ErrorCode,

  selected_tx_power : 8, // -127 to +20

system/gd/hci/hci_packets_test.cc

+3 −271
Original line number Diff line number Diff line
@@ -14,13 +14,12 @@ 
 * limitations under the License.

 */



#define PACKET_TESTING

#include "hci/hci_packets.h"



#include <gtest/gtest.h>

#include <forward_list>

#include <memory>



#define PACKET_TESTING  // Instantiate the tests in the packet files

#include "hci/hci_packets.h"



#include "os/log.h"

#include "packet/bit_inserter.h"

#include "packet/raw_builder.h"
@@ -32,168 +31,6 @@ using std::vector; 
namespace bluetooth {

namespace hci {



std::vector<uint8_t> reset = {0x03, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_ResetReflectionTest(reset);



std::vector<uint8_t> reset_complete = {0x0e, 0x04, 0x01, 0x03, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_ResetCompleteReflectionTest(reset_complete);



std::vector<uint8_t> read_buffer_size = {0x05, 0x10, 0x00};

DEFINE_AND_INSTANTIATE_ReadBufferSizeReflectionTest(read_buffer_size);



std::vector<uint8_t> read_buffer_size_complete = {0x0e, 0x0b, 0x01, 0x05, 0x10, 0x00, 0x00,

                                                  0x04, 0x3c, 0x07, 0x00, 0x08, 0x00};

DEFINE_AND_INSTANTIATE_ReadBufferSizeCompleteReflectionTest(read_buffer_size_complete);



std::vector<uint8_t> host_buffer_size = {0x33, 0x0c, 0x07, 0x9b, 0x06, 0xff, 0x14, 0x00, 0x0a, 0x00};

DEFINE_AND_INSTANTIATE_HostBufferSizeReflectionTest(host_buffer_size);



std::vector<uint8_t> host_buffer_size_complete = {0x0e, 0x04, 0x01, 0x33, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_HostBufferSizeCompleteReflectionTest(host_buffer_size_complete);



std::vector<uint8_t> read_local_version_information = {0x01, 0x10, 0x00};

DEFINE_AND_INSTANTIATE_ReadLocalVersionInformationReflectionTest(read_local_version_information);



std::vector<uint8_t> read_local_version_information_complete = {0x0e, 0x0c, 0x01, 0x01, 0x10, 0x00, 0x09,

                                                                0x00, 0x00, 0x09, 0x1d, 0x00, 0xbe, 0x02};

DEFINE_AND_INSTANTIATE_ReadLocalVersionInformationCompleteReflectionTest(read_local_version_information_complete);



std::vector<uint8_t> read_bd_addr = {0x09, 0x10, 0x00};

DEFINE_AND_INSTANTIATE_ReadBdAddrReflectionTest(read_bd_addr);



std::vector<uint8_t> read_bd_addr_complete = {0x0e, 0x0a, 0x01, 0x09, 0x10, 0x00, 0x14, 0x8e, 0x61, 0x5f, 0x36, 0x88};

DEFINE_AND_INSTANTIATE_ReadBdAddrCompleteReflectionTest(read_bd_addr_complete);



std::vector<uint8_t> read_local_supported_commands = {0x02, 0x10, 0x00};

DEFINE_AND_INSTANTIATE_ReadLocalSupportedCommandsReflectionTest(read_local_supported_commands);



std::vector<uint8_t> read_local_supported_commands_complete = {

    0x0e, 0x44, 0x01, 0x02, 0x10, 0x00, /* Supported commands start here (total 64 bytes) */

    0xff, 0xff, 0xff, 0x03, 0xce, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xf2, 0x0f, 0xe8, 0xfe,

    0x3f, 0xf7, 0x83, 0xff, 0x1c, 0x00, 0x00, 0x00, 0x61, 0xff, 0xff, 0xff, 0x7f, 0xbe, 0x20, 0xf5,

    0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

DEFINE_AND_INSTANTIATE_ReadLocalSupportedCommandsCompleteReflectionTest(read_local_supported_commands_complete);



std::vector<uint8_t> read_local_extended_features_0 = {0x04, 0x10, 0x01, 0x00};



std::vector<uint8_t> read_local_extended_features_complete_0 = {0x0e, 0x0e, 0x01, 0x04, 0x10, 0x00, 0x00, 0x02,

                                                                0xff, 0xfe, 0x8f, 0xfe, 0xd8, 0x3f, 0x5b, 0x87};



std::vector<uint8_t> write_simple_paring_mode = {0x56, 0x0c, 0x01, 0x01};

DEFINE_AND_INSTANTIATE_WriteSimplePairingModeReflectionTest(write_simple_paring_mode);



std::vector<uint8_t> write_simple_paring_mode_complete = {0x0e, 0x04, 0x01, 0x56, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_WriteSimplePairingModeCompleteReflectionTest(write_simple_paring_mode_complete);



std::vector<uint8_t> write_le_host_supported = {0x6d, 0x0c, 0x02, 0x01, 0x01};

DEFINE_AND_INSTANTIATE_WriteLeHostSupportReflectionTest(write_le_host_supported);



std::vector<uint8_t> write_le_host_supported_complete = {0x0e, 0x04, 0x01, 0x6d, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_WriteLeHostSupportCompleteReflectionTest(write_le_host_supported_complete);



std::vector<uint8_t> read_local_extended_features_1 = {0x04, 0x10, 0x01, 0x01};



std::vector<uint8_t> read_local_extended_features_complete_1 = {0x0e, 0x0e, 0x01, 0x04, 0x10, 0x00, 0x01, 0x02,

                                                                0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};



std::vector<uint8_t> read_local_extended_features_2 = {0x04, 0x10, 0x01, 0x02};

DEFINE_AND_INSTANTIATE_ReadLocalExtendedFeaturesReflectionTest(read_local_extended_features_0,

                                                               read_local_extended_features_1,

                                                               read_local_extended_features_2);



std::vector<uint8_t> read_local_extended_features_complete_2 = {0x0e, 0x0e, 0x01, 0x04, 0x10, 0x00, 0x02, 0x02,

                                                                0x45, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

DEFINE_AND_INSTANTIATE_ReadLocalExtendedFeaturesCompleteReflectionTest(read_local_extended_features_complete_0,

                                                                       read_local_extended_features_complete_1,

                                                                       read_local_extended_features_complete_2);



std::vector<uint8_t> write_secure_connections_host_support = {0x7a, 0x0c, 0x01, 0x01};

DEFINE_AND_INSTANTIATE_WriteSecureConnectionsHostSupportReflectionTest(write_secure_connections_host_support);



std::vector<uint8_t> write_secure_connections_host_support_complete = {0x0e, 0x04, 0x01, 0x7a, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_WriteSecureConnectionsHostSupportCompleteReflectionTest(

    write_secure_connections_host_support_complete);



std::vector<uint8_t> le_read_connect_list_size = {0x0f, 0x20, 0x00};

DEFINE_AND_INSTANTIATE_LeReadConnectListSizeReflectionTest(le_read_connect_list_size);



std::vector<uint8_t> le_read_connect_list_size_complete = {0x0e, 0x05, 0x01, 0x0f, 0x20, 0x00, 0x80};

DEFINE_AND_INSTANTIATE_LeReadConnectListSizeCompleteReflectionTest(le_read_connect_list_size_complete);



std::vector<uint8_t> le_read_buffer_size = {0x02, 0x20, 0x00};

DEFINE_AND_INSTANTIATE_LeReadBufferSizeV1ReflectionTest(le_read_buffer_size);



std::vector<uint8_t> le_read_buffer_size_complete = {0x0e, 0x07, 0x01, 0x02, 0x20, 0x00, 0xfb, 0x00, 0x10};

DEFINE_AND_INSTANTIATE_LeReadBufferSizeV1CompleteReflectionTest(le_read_buffer_size_complete);



std::vector<uint8_t> write_current_iac_laps = {0x3a, 0x0c, 0x07, 0x02, 0x11, 0x8b, 0x9e, 0x22, 0x8b, 0x9e};

DEFINE_AND_INSTANTIATE_WriteCurrentIacLapReflectionTest(write_current_iac_laps);



std::vector<uint8_t> write_current_iac_laps_complete = {0x0e, 0x04, 0x01, 0x3a, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_WriteCurrentIacLapCompleteReflectionTest(write_current_iac_laps_complete);



std::vector<uint8_t> write_inquiry_scan_activity = {0x1e, 0x0c, 0x04, 0x00, 0x08, 0x12, 0x00};

DEFINE_AND_INSTANTIATE_WriteInquiryScanActivityReflectionTest(write_inquiry_scan_activity);



std::vector<uint8_t> write_inquiry_scan_activity_complete = {0x0e, 0x04, 0x01, 0x1e, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_WriteInquiryScanActivityCompleteReflectionTest(write_inquiry_scan_activity_complete);



std::vector<uint8_t> read_inquiry_scan_activity = {0x1d, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_ReadInquiryScanActivityReflectionTest(read_inquiry_scan_activity);



std::vector<uint8_t> read_inquiry_scan_activity_complete = {0x0e, 0x08, 0x01, 0x1d, 0x0c, 0x00, 0xaa, 0xbb, 0xcc, 0xdd};

DEFINE_AND_INSTANTIATE_ReadInquiryScanActivityCompleteReflectionTest(read_inquiry_scan_activity_complete);



std::vector<uint8_t> read_current_iac_lap = {0x39, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_ReadCurrentIacLapReflectionTest(read_current_iac_lap);



std::vector<uint8_t> read_current_iac_lap_complete = {0x0e, 0x0b, 0x01, 0x39, 0x0c, 0x00, 0x02,

                                                      0x11, 0x8b, 0x9e, 0x22, 0x8b, 0x9e};

DEFINE_AND_INSTANTIATE_ReadCurrentIacLapCompleteReflectionTest(read_current_iac_lap_complete);



std::vector<uint8_t> read_number_of_supported_iac = {0x38, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_ReadNumberOfSupportedIacReflectionTest(read_number_of_supported_iac);



std::vector<uint8_t> read_number_of_supported_iac_complete = {0x0e, 0x05, 0x01, 0x38, 0x0c, 0x00, 0x99};

DEFINE_AND_INSTANTIATE_ReadNumberOfSupportedIacCompleteReflectionTest(read_number_of_supported_iac_complete);



std::vector<uint8_t> read_page_timeout = {0x17, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_ReadPageTimeoutReflectionTest(read_page_timeout);



std::vector<uint8_t> read_page_timeout_complete = {0x0e, 0x06, 0x01, 0x17, 0x0c, 0x00, 0x11, 0x22};

DEFINE_AND_INSTANTIATE_ReadPageTimeoutCompleteReflectionTest(read_page_timeout_complete);



std::vector<uint8_t> write_page_timeout = {0x18, 0x0c, 0x02, 0x00, 0x20};

DEFINE_AND_INSTANTIATE_WritePageTimeoutReflectionTest(write_page_timeout);



std::vector<uint8_t> write_page_timeout_complete = {0x0e, 0x04, 0x01, 0x18, 0x0c, 0x00};

DEFINE_AND_INSTANTIATE_WritePageTimeoutCompleteReflectionTest(write_page_timeout_complete);



std::vector<uint8_t> inquiry = {0x01, 0x04, 0x05, 0x33, 0x8b, 0x9e, 0xaa, 0xbb};

DEFINE_AND_INSTANTIATE_InquiryReflectionTest(inquiry);



std::vector<uint8_t> inquiry_status = {0x0f, 0x04, 0x00, 0x01, 0x01, 0x04};

DEFINE_AND_INSTANTIATE_InquiryStatusReflectionTest(inquiry_status);



std::vector<uint8_t> inquiry_cancel = {0x02, 0x04, 0x00};

DEFINE_AND_INSTANTIATE_InquiryCancelReflectionTest(inquiry_cancel);



std::vector<uint8_t> inquiry_cancel_complete = {0x0e, 0x04, 0x01, 0x02, 0x04, 0x00};

DEFINE_AND_INSTANTIATE_InquiryCancelCompleteReflectionTest(inquiry_cancel_complete);



std::vector<uint8_t> periodic_inquiry_mode = {0x03, 0x04, 0x09, 0x12, 0x34, 0x56, 0x78, 0x11, 0x8b, 0x9e, 0x9a, 0xbc};

DEFINE_AND_INSTANTIATE_PeriodicInquiryModeReflectionTest(periodic_inquiry_mode);



std::vector<uint8_t> periodic_inquiry_mode_complete = {0x0e, 0x04, 0x01, 0x03, 0x04, 0x00};

DEFINE_AND_INSTANTIATE_PeriodicInquiryModeCompleteReflectionTest(periodic_inquiry_mode_complete);



std::vector<uint8_t> exit_periodic_inquiry_mode = {0x04, 0x04, 0x00};

DEFINE_AND_INSTANTIATE_ExitPeriodicInquiryModeReflectionTest(exit_periodic_inquiry_mode);



std::vector<uint8_t> exit_periodic_inquiry_mode_complete = {0x0e, 0x04, 0x01, 0x04, 0x04, 0x00};

DEFINE_AND_INSTANTIATE_ExitPeriodicInquiryModeCompleteReflectionTest(exit_periodic_inquiry_mode_complete);



std::vector<uint8_t> pixel_3_xl_write_extended_inquiry_response{

    0x52, 0x0c, 0xf1, 0x01, 0x0b, 0x09, 0x50, 0x69, 0x78, 0x65, 0x6c, 0x20, 0x33, 0x20, 0x58, 0x4c, 0x19, 0x03, 0x05,

    0x11, 0x0a, 0x11, 0x0c, 0x11, 0x0e, 0x11, 0x12, 0x11, 0x15, 0x11, 0x16, 0x11, 0x1f, 0x11, 0x2d, 0x11, 0x2f, 0x11,
@@ -278,8 +115,6 @@ TEST(HciPacketsTest, testLeSetScanParameters) { 
  ASSERT_EQ(LeScanningFilterPolicy::ACCEPT_ALL, view.GetScanningFilterPolicy());

}



DEFINE_AND_INSTANTIATE_LeSetScanParametersReflectionTest(le_set_scan_parameters);



std::vector<uint8_t> le_set_scan_enable{

    0x0c, 0x20, 0x02, 0x01, 0x00,

};
@@ -292,8 +127,6 @@ TEST(HciPacketsTest, testLeSetScanEnable) { 
  ASSERT_EQ(Enable::DISABLED, view.GetFilterDuplicates());

}



DEFINE_AND_INSTANTIATE_LeSetScanEnableReflectionTest(le_set_scan_enable);



std::vector<uint8_t> le_get_vendor_capabilities{

    0x53,

    0xfd,
@@ -306,8 +139,6 @@ TEST(HciPacketsTest, testLeGetVendorCapabilities) { 
  ASSERT_TRUE(view.IsValid());

}



DEFINE_AND_INSTANTIATE_LeGetVendorCapabilitiesReflectionTest(le_get_vendor_capabilities);



std::vector<uint8_t> le_get_vendor_capabilities_complete{

    0x0e, 0x0c, 0x01, 0x53, 0xfd, 0x00, 0x05, 0x01, 0x00, 0x04, 0x80, 0x01, 0x10, 0x01,

};
@@ -328,8 +159,6 @@ TEST(HciPacketsTest, testLeGetVendorCapabilitiesComplete) { 
  ASSERT_EQ(1, base_capabilities.activity_energy_info_support_);

}



DEFINE_AND_INSTANTIATE_LeGetVendorCapabilitiesCompleteReflectionTest(le_get_vendor_capabilities_complete);



std::vector<uint8_t> le_set_extended_scan_parameters{

    0x41, 0x20, 0x08, 0x01, 0x00, 0x01, 0x01, 0x12, 0x00, 0x12, 0x00,

};
@@ -367,14 +196,6 @@ TEST(HciPacketsTest, testLeSetExtendedScanParameters_6553) { 
  ASSERT_EQ(6553, params[0].le_scan_window_);

}



DEFINE_AND_INSTANTIATE_LeSetExtendedScanParametersReflectionTest(le_set_extended_scan_parameters,

                                                                 le_set_extended_scan_parameters_6553);



std::vector<uint8_t> le_set_extended_scan_parameters_complete{

    0x0e, 0x04, 0x01, 0x41, 0x20, 0x00,

};

DEFINE_AND_INSTANTIATE_LeSetExtendedScanParametersCompleteReflectionTest(le_set_extended_scan_parameters_complete);



std::vector<uint8_t> le_set_extended_scan_enable{

    0x42, 0x20, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,

};
@@ -408,19 +229,10 @@ TEST(HciPacketsTest, testLeSetExtendedScanEnableDisable) { 
  ASSERT_EQ(0, view.GetPeriod());

}



DEFINE_AND_INSTANTIATE_LeSetExtendedScanEnableReflectionTest(le_set_extended_scan_enable,

                                                             le_set_extended_scan_enable_disable);



std::vector<uint8_t> le_set_extended_scan_enable_complete{

    0x0e, 0x04, 0x01, 0x42, 0x20, 0x00,

};

DEFINE_AND_INSTANTIATE_LeSetExtendedScanEnableCompleteReflectionTest(le_set_extended_scan_enable_complete);



std::vector<uint8_t> le_extended_create_connection = {

    0x43, 0x20, 0x2a, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x08,

    0x30, 0x00, 0x18, 0x00, 0x28, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x08, 0x30, 0x00, 0x18, 0x00, 0x28, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00, 0x00, 0x00};

DEFINE_AND_INSTANTIATE_LeExtendedCreateConnectionReflectionTest(le_extended_create_connection);



TEST(HciPacketsTest, testLeExtendedCreateConnection) {

  std::shared_ptr<std::vector<uint8_t>> packet_bytes =
@@ -446,13 +258,6 @@ TEST(HciPacketsTest, testLeSetExtendedAdvertisingRandomAddress) { 
  ASSERT_EQ(0, view.GetAdvertisingHandle());

  ASSERT_EQ(Address(random_address_bytes), view.GetAdvertisingRandomAddress());

}

DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingRandomAddressReflectionTest(le_set_extended_advertising_random_address);



std::vector<uint8_t> le_set_extended_advertising_random_address_complete{

    0x0e, 0x04, 0x01, 0x35, 0x20, 0x00,

};

DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingRandomAddressCompleteReflectionTest(

    le_set_extended_advertising_random_address_complete);



std::vector<uint8_t> le_set_extended_advertising_data{

    0x37, 0x20, 0x12, 0x00, 0x03, 0x01, 0x0e, 0x02, 0x01, 0x02, 0x0a,
@@ -474,13 +279,6 @@ TEST(HciPacketsTest, testLeSetExtendedAdvertisingData) { 
  ASSERT_EQ(advertising_data, view.GetAdvertisingData());

}



DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingDataRawReflectionTest(le_set_extended_advertising_data);



std::vector<uint8_t> le_set_extended_advertising_data_complete{

    0x0e, 0x04, 0x01, 0x37, 0x20, 0x00,

};

DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingDataCompleteReflectionTest(le_set_extended_advertising_data_complete);



std::vector<uint8_t> le_set_extended_advertising_parameters_set_0{

    0x36, 0x20, 0x19, 0x00, 0x13, 0x00, 0x90, 0x01, 0x00, 0xc2, 0x01, 0x00, 0x07, 0x01,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x01, 0x00, 0x01, 0x01, 0x00,
@@ -527,9 +325,6 @@ TEST(HciPacketsTest, testLeSetExtendedAdvertisingParametersSet1) { 
  ASSERT_EQ(Enable::DISABLED, view.GetScanRequestNotificationEnable());

}



DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingLegacyParametersReflectionTest(

    le_set_extended_advertising_parameters_set_0, le_set_extended_advertising_parameters_set_1);



std::vector<uint8_t> le_set_extended_advertising_parameters_complete{0x0e, 0x05, 0x01, 0x36, 0x20, 0x00, 0xf5};

TEST(HciPacketsTest, testLeSetExtendedAdvertisingParametersComplete) {

  std::shared_ptr<std::vector<uint8_t>> packet_bytes =
@@ -541,9 +336,6 @@ TEST(HciPacketsTest, testLeSetExtendedAdvertisingParametersComplete) { 
  ASSERT_EQ(static_cast<uint8_t>(-11), view.GetSelectedTxPower());

}



DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingParametersCompleteReflectionTest(

    le_set_extended_advertising_parameters_complete);



std::vector<uint8_t> le_remove_advertising_set_1{

    0x3c,

    0x20,
@@ -560,13 +352,6 @@ TEST(HciPacketsTest, testLeRemoveAdvertisingSet1) { 
  ASSERT_EQ(1, view.GetAdvertisingHandle());

}



DEFINE_AND_INSTANTIATE_LeRemoveAdvertisingSetReflectionTest(le_remove_advertising_set_1);



std::vector<uint8_t> le_remove_advertising_set_complete{

    0x0e, 0x04, 0x01, 0x3c, 0x20, 0x00,

};

DEFINE_AND_INSTANTIATE_LeRemoveAdvertisingSetCompleteReflectionTest(le_remove_advertising_set_complete);



std::vector<uint8_t> le_set_extended_advertising_disable_1{

    0x39, 0x20, 0x06, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,

};
@@ -582,14 +367,6 @@ TEST(HciPacketsTest, testLeSetExtendedAdvertisingDisable1) { 
  ASSERT_EQ(1, disabled_set[0].advertising_handle_);

}



DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingDisableReflectionTest(le_set_extended_advertising_disable_1);



std::vector<uint8_t> le_set_extended_advertising_enable_complete{

    0x0e, 0x04, 0x01, 0x39, 0x20, 0x00,

};

DEFINE_AND_INSTANTIATE_LeSetExtendedAdvertisingEnableCompleteReflectionTest(

    le_set_extended_advertising_enable_complete);



TEST(HciPacketsTest, testLeSetAdvertisingDataBuilderLength) {

  GapData gap_data;

  gap_data.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
@@ -667,50 +444,5 @@ TEST(HciPacketsTest, testLeMultiAdvSetScanResponseDataBuilderLength) { 
  ASSERT_EQ(view.GetAdvertisingInstance(), 3);

}



std::vector<uint8_t> controller_bqr = {0x5e, 0xfd, 0x07, 0x00, 0x1f, 0x00, 0x07, 0x00, 0x88, 0x13};

DEFINE_AND_INSTANTIATE_ControllerBqrReflectionTest(controller_bqr);



std::vector<uint8_t> controller_bqr_complete = {0x0e, 0x08, 0x01, 0x5e, 0xfd, 0x00, 0x1f, 0x00, 0x07, 0x00};

DEFINE_AND_INSTANTIATE_ControllerBqrCompleteReflectionTest(controller_bqr_complete);



std::vector<uint8_t> bqr_monitor_mode_event = {

    0xff, 0x31, 0x58, 0x01, 0x10, 0x02, 0x00, 0x00, 0x07, 0xd5, 0x00, 0x14, 0x00, 0x40, 0x1f, 0xed, 0x41,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x3c, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

DEFINE_AND_INSTANTIATE_BqrMonitorModeEventReflectionTest(bqr_monitor_mode_event);



std::vector<uint8_t> bqr_approach_lsto_event = {

    0xff, 0x48, 0x58, 0x02, 0x10, 0x02, 0x00, 0x01, 0x09, 0xaf, 0x00, 0x2d, 0x00, 0x00, 0x7d, 0x94, 0xe9, 0x03, 0x01,

    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x30, 0xa8, 0x0f, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x81, 0x9b, 0xf2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xcc, 0xcc, 0xcc, 0xcc, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x4e, 0x11, 0x00, 0x0c, 0x54, 0x10, 0x00};

DEFINE_AND_INSTANTIATE_BqrApproachLstoEventReflectionTest(bqr_approach_lsto_event);



std::vector<uint8_t> bqr_a2dp_audio_choppy_event = {

    0xff, 0x41, 0x58, 0x03, 0x19, 0x09, 0x00, 0x00, 0x07, 0xcb, 0x00, 0x3a, 0x01, 0x40, 0x1f, 0x7e, 0xce,

    0x58, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x7e, 0xce, 0x58,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0xd1, 0x57, 0x00, 0x30, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x0d, 0xce, 0x58, 0x00, 0x3a, 0xce, 0x58, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x01};

DEFINE_AND_INSTANTIATE_BqrA2dpAudioChoppyEventReflectionTest(bqr_a2dp_audio_choppy_event);



std::vector<uint8_t> bqr_sco_voice_choppy_event = {

    0xff, 0x4a, 0x58, 0x04, 0x09, 0x08, 0x00, 0x00, 0x08, 0xbf, 0x00, 0x03, 0x00, 0x40, 0x1f, 0x92, 0x6c, 0x0a, 0x0d,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x06, 0x02, 0x02, 0x0b,

    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00};

DEFINE_AND_INSTANTIATE_BqrScoVoiceChoppyEventReflectionTest(bqr_sco_voice_choppy_event);



std::vector<uint8_t> bqr_root_inflammation_event = {0xff, 0x04, 0x58, 0x05, 0x00, 0xfe};

DEFINE_AND_INSTANTIATE_BqrRootInflammationEventReflectionTest(bqr_root_inflammation_event);



std::vector<uint8_t> bqr_lmp_ll_message_trace_event = {0xff, 0x11, 0x58, 0x11, 0x03, 0x00, 0x01, 0xff, 0x11, 0x55,

                                                       0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};

DEFINE_AND_INSTANTIATE_BqrLmpLlMessageTraceEventReflectionTest(bqr_lmp_ll_message_trace_event);



std::vector<uint8_t> bqr_bt_scheduling_trace_event = {0xff, 0x1d, 0x58, 0x12, 0x05, 0x00, 0x02, 0xd9, 0xae, 0x08, 0x01,

                                                      0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,

                                                      0x00, 0x01, 0x0c, 0x00, 0x36, 0x3c, 0x00, 0x00, 0x00};

DEFINE_AND_INSTANTIATE_BqrBtSchedulingTraceEventReflectionTest(bqr_bt_scheduling_trace_event);



}  // namespace hci

}  // namespace bluetooth