1 /*
2  * Copyright 2019 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "hci/controller.h"
18 
19 #include <bluetooth/log.h>
20 #include <com_android_bluetooth_flags.h>
21 #include <gtest/gtest.h>
22 #include <unistd.h>
23 
24 #include <chrono>
25 #include <future>
26 #include <memory>
27 #include <sstream>
28 
29 #include "common/bind.h"
30 #include "hci/address.h"
31 #include "hci/hci_layer_fake.h"
32 #include "os/thread.h"
33 #include "packet/raw_builder.h"
34 
35 // TODO(b/369381361) Enfore -Wmissing-prototypes
36 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
37 
38 using namespace bluetooth;
39 using namespace std::chrono_literals;
40 
41 using packet::kLittleEndian;
42 using packet::PacketView;
43 using packet::RawBuilder;
44 
45 namespace bluetooth {
46 namespace hci {
47 
48 namespace {
49 
50 constexpr uint16_t kHandle1 = 0x123;
51 constexpr uint16_t kCredits1 = 0x78;
52 constexpr uint16_t kHandle2 = 0x456;
53 constexpr uint16_t kCredits2 = 0x9a;
54 constexpr uint64_t kRandomNumber = 0x123456789abcdef0;
55 /*sbc_supported= 1, aac_supported= 1, aptx_supported= 0, aptx_hd_supported= 0, ldac_supported= 1 */
56 constexpr uint32_t kDynamicAudioBufferSupport = 0x13;
57 uint16_t feature_spec_version = 55;
58 constexpr char title[] = "hci_controller_test";
59 
60 }  // namespace
61 
62 namespace {
63 
64 class HciLayerFakeForController : public HciLayerFake {
65 public:
EnqueueCommand(std::unique_ptr<CommandBuilder> command,common::ContextualOnceCallback<void (CommandCompleteView)> on_complete)66   void EnqueueCommand(
67           std::unique_ptr<CommandBuilder> command,
68           common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) override {
69     GetHandler()->Post(common::BindOnce(&HciLayerFakeForController::HandleCommand,
70                                         common::Unretained(this), std::move(command),
71                                         std::move(on_complete)));
72   }
73 
EnqueueCommand(std::unique_ptr<CommandBuilder>,common::ContextualOnceCallback<void (CommandStatusView)>)74   void EnqueueCommand(
75           std::unique_ptr<CommandBuilder> /* command */,
76           common::ContextualOnceCallback<void(CommandStatusView)> /* on_status */) override {
77     FAIL() << "Controller properties should not generate Command Status";
78   }
79 
EnqueueCommand(std::unique_ptr<CommandBuilder>,common::ContextualOnceCallback<void (CommandStatusOrCompleteView)>)80   void EnqueueCommand(std::unique_ptr<CommandBuilder> /* command */,
81                       common::ContextualOnceCallback<void(
82                               CommandStatusOrCompleteView)> /* on_status_or_complete */) override {
83     FAIL() << "Controller properties should not generate Command Status";
84   }
85 
HandleCommand(std::unique_ptr<CommandBuilder> command_builder,common::ContextualOnceCallback<void (CommandCompleteView)> on_complete)86   void HandleCommand(std::unique_ptr<CommandBuilder> command_builder,
87                      common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) {
88     auto bytes = std::make_shared<std::vector<uint8_t>>();
89     BitInserter i(*bytes);
90     bytes->reserve((command_builder)->size());
91     command_builder->Serialize(i);
92     auto packet_view = packet::PacketView<packet::kLittleEndian>(bytes);
93     CommandView command = CommandView::Create(packet_view);
94     ASSERT_TRUE(command.IsValid());
95 
96     uint8_t num_packets = 1;
97     std::unique_ptr<packet::BasePacketBuilder> event_builder;
98     switch (command.GetOpCode()) {
99       case (OpCode::READ_LOCAL_NAME): {
100         std::array<uint8_t, 248> local_name = {'D', 'U', 'T', '\0'};
101         event_builder =
102                 ReadLocalNameCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, local_name);
103       } break;
104       case (OpCode::READ_LOCAL_VERSION_INFORMATION): {
105         LocalVersionInformation local_version_information;
106         local_version_information.hci_version_ = HciVersion::V_5_0;
107         local_version_information.hci_revision_ = 0x1234;
108         local_version_information.lmp_version_ = LmpVersion::V_4_2;
109         local_version_information.manufacturer_name_ = 0xBAD;
110         local_version_information.lmp_subversion_ = 0x5678;
111         event_builder = ReadLocalVersionInformationCompleteBuilder::Create(
112                 num_packets, ErrorCode::SUCCESS, local_version_information);
113       } break;
114       case (OpCode::READ_LOCAL_SUPPORTED_COMMANDS): {
115         std::array<uint8_t, 64> supported_commands;
116         for (int i = 0; i < 37; i++) {
117           supported_commands[i] = 0xff;
118         }
119         for (int i = 37; i < 64; i++) {
120           supported_commands[i] = 0x00;
121         }
122         event_builder = ReadLocalSupportedCommandsCompleteBuilder::Create(
123                 num_packets, ErrorCode::SUCCESS, supported_commands);
124       } break;
125       case (OpCode::READ_LOCAL_SUPPORTED_CODECS_V1): {
126         std::vector<uint8_t> supported_codecs{0, 1, 2, 3, 4, 5, 6};
127         std::vector<uint32_t> supported_vendor_codecs;
128         event_builder = ReadLocalSupportedCodecsV1CompleteBuilder::Create(
129                 num_packets, ErrorCode::SUCCESS, supported_codecs, supported_vendor_codecs);
130       } break;
131       case (OpCode::READ_LOCAL_EXTENDED_FEATURES): {
132         ReadLocalExtendedFeaturesView read_command = ReadLocalExtendedFeaturesView::Create(command);
133         ASSERT_TRUE(read_command.IsValid());
134         uint8_t page_bumber = read_command.GetPageNumber();
135         uint64_t lmp_features = 0x012345678abcdef;
136         lmp_features += page_bumber;
137         event_builder = ReadLocalExtendedFeaturesCompleteBuilder::Create(
138                 num_packets, ErrorCode::SUCCESS, page_bumber, 0x02, lmp_features);
139       } break;
140       case (OpCode::READ_BUFFER_SIZE): {
141         event_builder = ReadBufferSizeCompleteBuilder::Create(
142                 num_packets, ErrorCode::SUCCESS, acl_data_packet_length,
143                 synchronous_data_packet_length, total_num_acl_data_packets,
144                 total_num_synchronous_data_packets);
145       } break;
146       case (OpCode::READ_BD_ADDR): {
147         event_builder =
148                 ReadBdAddrCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, Address::kAny);
149       } break;
150       case (OpCode::LE_READ_BUFFER_SIZE_V1): {
151         LeBufferSize le_buffer_size;
152         le_buffer_size.le_data_packet_length_ = 0x16;
153         le_buffer_size.total_num_le_packets_ = 0x08;
154         event_builder = LeReadBufferSizeV1CompleteBuilder::Create(num_packets, ErrorCode::SUCCESS,
155                                                                   le_buffer_size);
156       } break;
157       case (OpCode::LE_READ_LOCAL_SUPPORTED_FEATURES): {
158         event_builder = LeReadLocalSupportedFeaturesCompleteBuilder::Create(
159                 num_packets, ErrorCode::SUCCESS, 0x001f123456789abc);
160       } break;
161       case (OpCode::LE_READ_SUPPORTED_STATES): {
162         event_builder = LeReadSupportedStatesCompleteBuilder::Create(
163                 num_packets, ErrorCode::SUCCESS, 0x001f123456789abe);
164       } break;
165       case (OpCode::LE_READ_MAXIMUM_DATA_LENGTH): {
166         LeMaximumDataLength le_maximum_data_length;
167         le_maximum_data_length.supported_max_tx_octets_ = 0x12;
168         le_maximum_data_length.supported_max_tx_time_ = 0x34;
169         le_maximum_data_length.supported_max_rx_octets_ = 0x56;
170         le_maximum_data_length.supported_max_rx_time_ = 0x78;
171         event_builder = LeReadMaximumDataLengthCompleteBuilder::Create(
172                 num_packets, ErrorCode::SUCCESS, le_maximum_data_length);
173       } break;
174       case (OpCode::LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH): {
175         event_builder = LeReadMaximumAdvertisingDataLengthCompleteBuilder::Create(
176                 num_packets, ErrorCode::SUCCESS, 0x0672);
177       } break;
178       case (OpCode::LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS): {
179         event_builder = LeReadNumberOfSupportedAdvertisingSetsCompleteBuilder::Create(
180                 num_packets, ErrorCode::SUCCESS, 0xF0);
181       } break;
182       case (OpCode::LE_GET_VENDOR_CAPABILITIES):
183         if (vendor_capabilities_ == nullptr) {
184           BaseVendorCapabilities base_vendor_capabilities;
185           base_vendor_capabilities.max_advt_instances_ = 0x10;
186           base_vendor_capabilities.offloaded_resolution_of_private_address_ = 0x01;
187           base_vendor_capabilities.total_scan_results_storage_ = 0x2800;
188           base_vendor_capabilities.max_irk_list_sz_ = 0x20;
189           base_vendor_capabilities.filtering_support_ = 0x01;
190           base_vendor_capabilities.max_filter_ = 0x10;
191           base_vendor_capabilities.activity_energy_info_support_ = 0x01;
192 
193           auto payload = std::make_unique<RawBuilder>();
194           if (feature_spec_version > 55) {
195             std::vector<uint8_t> payload_bytes = {0x20, 0x00, 0x01, 0x00, 0x00,
196                                                   0x1f, 0x00, 0x00, 0x00, 0x00};
197             payload->AddOctets2(feature_spec_version);
198             payload->AddOctets(payload_bytes);
199           }
200           event_builder = LeGetVendorCapabilitiesCompleteBuilder::Create(
201                   num_packets, ErrorCode::SUCCESS, base_vendor_capabilities, std::move(payload));
202         } else {
203           event_builder = std::move(vendor_capabilities_);
204           vendor_capabilities_.reset();
205         }
206         break;
207       case (OpCode::DYNAMIC_AUDIO_BUFFER): {
208         auto dab_command =
209                 DynamicAudioBufferView::CreateOptional(VendorCommandView::Create(command));
210         if (dab_command->GetDabCommand() == DabCommand::GET_AUDIO_BUFFER_TIME_CAPABILITY) {
211           std::array<DynamicAudioBufferCodecCapability, 32> capabilities{};
212           capabilities[0] =
213                   DynamicAudioBufferCodecCapability(0x123, 0x103, 0x1234);  // sbc_capabilities
214           capabilities[1] =
215                   DynamicAudioBufferCodecCapability(0x223, 0x123, 0x2340);  // aac_capabilities
216           capabilities[4] =
217                   DynamicAudioBufferCodecCapability(0x323, 0x223, 0x3456);  // ldac_capabilities
218           event_builder = DabGetAudioBufferTimeCapabilityCompleteBuilder::Create(
219                   1, ErrorCode::SUCCESS, kDynamicAudioBufferSupport, capabilities);
220         } else {
221           auto set_command = DabSetAudioBufferTimeView::CreateOptional(*dab_command);
222           dynamic_audio_buffer_time = set_command->GetBufferTimeMs();
223           event_builder = DabSetAudioBufferTimeCompleteBuilder::Create(1, ErrorCode::SUCCESS,
224                                                                        dynamic_audio_buffer_time);
225         }
226       } break;
227       case (OpCode::SET_EVENT_MASK): {
228         auto view = SetEventMaskView::Create(command);
229         ASSERT_TRUE(view.IsValid());
230         event_mask = view.GetEventMask();
231         event_builder = SetEventMaskCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS);
232       } break;
233       case (OpCode::LE_SET_EVENT_MASK): {
234         auto view = LeSetEventMaskView::Create(command);
235         ASSERT_TRUE(view.IsValid());
236         le_event_mask = view.GetLeEventMask();
237         event_builder = LeSetEventMaskCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS);
238       } break;
239 
240       case (OpCode::LE_RAND): {
241         auto view = LeRandView::Create(LeSecurityCommandView::Create(command));
242         ASSERT_TRUE(view.IsValid());
243         event_builder =
244                 LeRandCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, kRandomNumber);
245       } break;
246 
247       // Let the test check and handle these commands.
248       case (OpCode::RESET):
249       case (OpCode::SET_EVENT_FILTER):
250       case (OpCode::HOST_BUFFER_SIZE):
251         HciLayerFake::EnqueueCommand(std::move(command_builder), std::move(on_complete));
252         return;
253 
254       default:
255         log::info("Dropping unhandled packet ({})", OpCodeText(command.GetOpCode()));
256         return;
257     }
258     auto packet = GetPacketView(std::move(event_builder));
259     EventView event = EventView::Create(packet);
260     ASSERT_TRUE(event.IsValid());
261     CommandCompleteView command_complete = CommandCompleteView::Create(event);
262     ASSERT_TRUE(command_complete.IsValid());
263     on_complete(std::move(command_complete));
264   }
265 
IncomingCredit()266   void IncomingCredit() {
267     std::vector<CompletedPackets> completed_packets;
268     CompletedPackets cp;
269     cp.host_num_of_completed_packets_ = kCredits1;
270     cp.connection_handle_ = kHandle1;
271     completed_packets.push_back(cp);
272     cp.host_num_of_completed_packets_ = kCredits2;
273     cp.connection_handle_ = kHandle2;
274     completed_packets.push_back(cp);
275     IncomingEvent(NumberOfCompletedPacketsBuilder::Create(completed_packets));
276   }
277 
278   std::unique_ptr<EventBuilder> vendor_capabilities_ = nullptr;
279   constexpr static uint16_t acl_data_packet_length = 1024;
280   constexpr static uint8_t synchronous_data_packet_length = 60;
281   constexpr static uint16_t total_num_acl_data_packets = 10;
282   constexpr static uint16_t total_num_synchronous_data_packets = 12;
283   uint64_t event_mask = 0;
284   uint64_t le_event_mask = 0;
285   uint16_t dynamic_audio_buffer_time = 0;
286 };
287 
288 class ControllerTest : public ::testing::Test {
289 protected:
SetUp()290   void SetUp() override {
291     feature_spec_version = feature_spec_version_;
292     test_hci_layer_ = new HciLayerFakeForController;
293     test_hci_layer_->vendor_capabilities_ = std::move(vendor_capabilities_);
294     vendor_capabilities_.reset();
295     fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);
296     client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
297     fake_registry_.Start<Controller>(&thread_);
298     controller_ = static_cast<Controller*>(fake_registry_.GetModuleUnderTest(&Controller::Factory));
299   }
300 
TearDown()301   void TearDown() override { fake_registry_.StopAll(); }
302 
303   TestModuleRegistry fake_registry_;
304   HciLayerFakeForController* test_hci_layer_ = nullptr;
305   os::Thread& thread_ = fake_registry_.GetTestThread();
306   Controller* controller_ = nullptr;
307   os::Handler* client_handler_ = nullptr;
308   uint16_t feature_spec_version_ = 98;
309   std::unique_ptr<EventBuilder> vendor_capabilities_ = nullptr;
310 };
311 }  // namespace
312 
313 class Controller055Test : public ControllerTest {
314 protected:
SetUp()315   void SetUp() override {
316     feature_spec_version_ = 55;
317     ControllerTest::SetUp();
318   }
319 };
320 
321 class Controller095Test : public ControllerTest {
322 protected:
SetUp()323   void SetUp() override {
324     feature_spec_version_ = 95;
325     ControllerTest::SetUp();
326   }
327 };
328 
329 class Controller096Test : public ControllerTest {
330 protected:
SetUp()331   void SetUp() override {
332     feature_spec_version_ = 96;
333     ControllerTest::SetUp();
334   }
335 };
336 
337 class Controller103Test : public ControllerTest {
338 protected:
SetUp()339   void SetUp() override {
340     feature_spec_version_ = 0x100 + 0x03;
341     BaseVendorCapabilities base_vendor_capabilities;
342     base_vendor_capabilities.max_advt_instances_ = 0x10;
343     base_vendor_capabilities.offloaded_resolution_of_private_address_ = 0x01;
344     base_vendor_capabilities.total_scan_results_storage_ = 0x2800;
345     base_vendor_capabilities.max_irk_list_sz_ = 0x20;
346     base_vendor_capabilities.filtering_support_ = 0x01;
347     base_vendor_capabilities.max_filter_ = 0x10;
348     base_vendor_capabilities.activity_energy_info_support_ = 0x01;
349     vendor_capabilities_ = LeGetVendorCapabilitiesComplete103Builder::Create(
350             1, ErrorCode::SUCCESS, base_vendor_capabilities, feature_spec_version_, 0x102,
351             /*extended_scan_support=*/1,
352             /*debug_logging_supported=*/1,
353             /*le_address_generation_offloading_support=*/0,
354             /*a2dp_source_offload_capability_mask=*/0x4,
355             /*bluetooth_quality_report_support=*/1, kDynamicAudioBufferSupport,
356             std::make_unique<RawBuilder>());
357     ControllerTest::SetUp();
358   }
359 };
360 
361 class Controller104Test : public ControllerTest {
362 protected:
SetUp()363   void SetUp() override {
364     feature_spec_version_ = 0x100 + 0x04;
365     BaseVendorCapabilities base_vendor_capabilities;
366     base_vendor_capabilities.max_advt_instances_ = 0x10;
367     base_vendor_capabilities.offloaded_resolution_of_private_address_ = 0x01;
368     base_vendor_capabilities.total_scan_results_storage_ = 0x2800;
369     base_vendor_capabilities.max_irk_list_sz_ = 0x20;
370     base_vendor_capabilities.filtering_support_ = 0x01;
371     base_vendor_capabilities.max_filter_ = 0x10;
372     base_vendor_capabilities.activity_energy_info_support_ = 0x01;
373     vendor_capabilities_ = LeGetVendorCapabilitiesComplete104Builder::Create(
374             1, ErrorCode::SUCCESS, base_vendor_capabilities, feature_spec_version_, 0x102,
375             /*extended_scan_support=*/1,
376             /*debug_logging_supported=*/1,
377             /*le_address_generation_offloading_support=*/0,
378             /*a2dp_source_offload_capability_mask=*/0x4,
379             /*bluetooth_quality_report_support=*/1, kDynamicAudioBufferSupport,
380             /*a2dp_offload_v2_support=*/1, std::make_unique<RawBuilder>());
381     ControllerTest::SetUp();
382   }
383 };
384 
TEST_F(ControllerTest,startup_teardown)385 TEST_F(ControllerTest, startup_teardown) {}
386 
TEST_F(ControllerTest,read_controller_info)387 TEST_F(ControllerTest, read_controller_info) {
388   ASSERT_EQ(controller_->GetAclPacketLength(), test_hci_layer_->acl_data_packet_length);
389   ASSERT_EQ(controller_->GetNumAclPacketBuffers(), test_hci_layer_->total_num_acl_data_packets);
390   ASSERT_EQ(controller_->GetScoPacketLength(), test_hci_layer_->synchronous_data_packet_length);
391   ASSERT_EQ(controller_->GetNumScoPacketBuffers(),
392             test_hci_layer_->total_num_synchronous_data_packets);
393   ASSERT_EQ(controller_->GetMacAddress(), Address::kAny);
394   LocalVersionInformation local_version_information = controller_->GetLocalVersionInformation();
395   ASSERT_EQ(HciVersion::V_5_0, local_version_information.hci_version_);
396   ASSERT_EQ(0x1234, local_version_information.hci_revision_);
397   ASSERT_EQ(LmpVersion::V_4_2, local_version_information.lmp_version_);
398   ASSERT_EQ(0xBAD, local_version_information.manufacturer_name_);
399   ASSERT_EQ(0x5678, local_version_information.lmp_subversion_);
400   ASSERT_EQ(0x16, controller_->GetLeBufferSize().le_data_packet_length_);
401   ASSERT_EQ(0x08, controller_->GetLeBufferSize().total_num_le_packets_);
402   ASSERT_EQ(0x001f123456789abeUL, controller_->GetLeSupportedStates());
403   ASSERT_EQ(0x12, controller_->GetLeMaximumDataLength().supported_max_tx_octets_);
404   ASSERT_EQ(0x34, controller_->GetLeMaximumDataLength().supported_max_tx_time_);
405   ASSERT_EQ(0x56, controller_->GetLeMaximumDataLength().supported_max_rx_octets_);
406   ASSERT_EQ(0x78, controller_->GetLeMaximumDataLength().supported_max_rx_time_);
407   ASSERT_EQ(0x0672, controller_->GetLeMaximumAdvertisingDataLength());
408   ASSERT_EQ(0xF0, controller_->GetLeNumberOfSupportedAdverisingSets());
409   ASSERT_GT(controller_->GetLocalSupportedBrEdrCodecIds().size(), 0u);
410 }
411 
TEST_F(ControllerTest,read_write_local_name)412 TEST_F(ControllerTest, read_write_local_name) {
413   ASSERT_EQ(controller_->GetLocalName(), "DUT");
414   controller_->WriteLocalName("New name");
415   ASSERT_EQ(controller_->GetLocalName(), "New name");
416 }
417 
TEST_F(ControllerTest,send_set_event_mask_command)418 TEST_F(ControllerTest, send_set_event_mask_command) {
419   uint64_t new_event_mask = test_hci_layer_->event_mask - 1;
420   controller_->SetEventMask(new_event_mask);
421   // Send another command to make sure it was applied
422   controller_->Reset();
423   auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
424   ASSERT_EQ(new_event_mask, test_hci_layer_->event_mask);
425 }
426 
TEST_F(ControllerTest,send_reset_command)427 TEST_F(ControllerTest, send_reset_command) {
428   controller_->Reset();
429   auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
430   auto command = ResetView::Create(packet);
431   ASSERT_TRUE(command.IsValid());
432 }
433 
TEST_F(ControllerTest,send_set_event_filter_command)434 TEST_F(ControllerTest, send_set_event_filter_command) {
435   controller_->SetEventFilterInquiryResultAllDevices();
436   auto packet = test_hci_layer_->GetCommand(OpCode::SET_EVENT_FILTER);
437   auto set_event_filter_view1 = SetEventFilterView::Create(packet);
438   auto set_event_filter_inquiry_result_view1 =
439           SetEventFilterInquiryResultView::Create(set_event_filter_view1);
440   auto command1 =
441           SetEventFilterInquiryResultAllDevicesView::Create(set_event_filter_inquiry_result_view1);
442   ASSERT_TRUE(command1.IsValid());
443 
444   ClassOfDevice class_of_device({0xab, 0xcd, 0xef});
445   ClassOfDevice class_of_device_mask({0x12, 0x34, 0x56});
446   controller_->SetEventFilterInquiryResultClassOfDevice(class_of_device, class_of_device_mask);
447   packet = test_hci_layer_->GetCommand(OpCode::SET_EVENT_FILTER);
448   auto set_event_filter_view2 = SetEventFilterView::Create(packet);
449   auto set_event_filter_inquiry_result_view2 =
450           SetEventFilterInquiryResultView::Create(set_event_filter_view2);
451   auto command2 = SetEventFilterInquiryResultClassOfDeviceView::Create(
452           set_event_filter_inquiry_result_view2);
453   ASSERT_TRUE(command2.IsValid());
454   ASSERT_EQ(command2.GetClassOfDevice(), class_of_device);
455 
456   Address bdaddr({0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc});
457   controller_->SetEventFilterConnectionSetupAddress(
458           bdaddr, AutoAcceptFlag::AUTO_ACCEPT_ON_ROLE_SWITCH_ENABLED);
459   packet = test_hci_layer_->GetCommand(OpCode::SET_EVENT_FILTER);
460   auto set_event_filter_view3 = SetEventFilterView::Create(packet);
461   auto set_event_filter_connection_setup_view =
462           SetEventFilterConnectionSetupView::Create(set_event_filter_view3);
463   auto command3 =
464           SetEventFilterConnectionSetupAddressView::Create(set_event_filter_connection_setup_view);
465   ASSERT_TRUE(command3.IsValid());
466   ASSERT_EQ(command3.GetAddress(), bdaddr);
467 }
468 
TEST_F(ControllerTest,send_host_buffer_size_command)469 TEST_F(ControllerTest, send_host_buffer_size_command) {
470   controller_->HostBufferSize(0xFF00, 0xF1, 0xFF02, 0xFF03);
471   auto packet = test_hci_layer_->GetCommand(OpCode::HOST_BUFFER_SIZE);
472   auto command = HostBufferSizeView::Create(packet);
473   ASSERT_TRUE(command.IsValid());
474   ASSERT_EQ(command.GetHostAclDataPacketLength(), 0xFF00);
475   ASSERT_EQ(command.GetHostSynchronousDataPacketLength(), 0xF1);
476   ASSERT_EQ(command.GetHostTotalNumAclDataPackets(), 0xFF02);
477   ASSERT_EQ(command.GetHostTotalNumSynchronousDataPackets(), 0xFF03);
478 }
479 
TEST_F(ControllerTest,send_le_set_event_mask_command)480 TEST_F(ControllerTest, send_le_set_event_mask_command) {
481   uint64_t new_le_event_mask = test_hci_layer_->event_mask - 1;
482   controller_->LeSetEventMask(new_le_event_mask);
483   // Send another command to make sure it was applied
484   controller_->Reset();
485   auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
486   ASSERT_EQ(new_le_event_mask, test_hci_layer_->le_event_mask);
487 }
488 
TEST_F(ControllerTest,is_supported_test)489 TEST_F(ControllerTest, is_supported_test) {
490   ASSERT_TRUE(controller_->IsSupported(OpCode::INQUIRY));
491   ASSERT_TRUE(controller_->IsSupported(OpCode::REJECT_CONNECTION_REQUEST));
492   ASSERT_TRUE(controller_->IsSupported(OpCode::ACCEPT_CONNECTION_REQUEST));
493   ASSERT_FALSE(controller_->IsSupported(OpCode::LE_REMOVE_ADVERTISING_SET));
494   ASSERT_FALSE(controller_->IsSupported(OpCode::LE_CLEAR_ADVERTISING_SETS));
495   ASSERT_FALSE(controller_->IsSupported(OpCode::LE_SET_PERIODIC_ADVERTISING_PARAMETERS));
496 }
497 
TEST_F(Controller055Test,feature_spec_version_055_test)498 TEST_F(Controller055Test, feature_spec_version_055_test) {
499   ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 55);
500   ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
501   ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
502   ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
503 }
504 
TEST_F(Controller095Test,feature_spec_version_095_test)505 TEST_F(Controller095Test, feature_spec_version_095_test) {
506   ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 95);
507   ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
508   ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
509   ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
510 }
511 
TEST_F(Controller096Test,feature_spec_version_096_test)512 TEST_F(Controller096Test, feature_spec_version_096_test) {
513   ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 96);
514   ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
515   ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
516   ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
517 }
518 
TEST_F(ControllerTest,feature_spec_version_098_test)519 TEST_F(ControllerTest, feature_spec_version_098_test) {
520   ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 98);
521   ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
522   ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
523   ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
524 }
525 
TEST_F(ControllerTest,feature_spec_version_098_no_dab_test)526 TEST_F(ControllerTest, feature_spec_version_098_no_dab_test) {
527   ASSERT_FALSE(controller_->IsSupported(OpCode::DYNAMIC_AUDIO_BUFFER));
528 }
529 
TEST_F(ControllerTest,set_dynamic_audio_buffer_time)530 TEST_F(ControllerTest, set_dynamic_audio_buffer_time) {
531   controller_->SetDabAudioBufferTime(123);
532   thread_.GetReactor()->WaitForIdle(std::chrono::seconds(1));
533   ASSERT_EQ(0, test_hci_layer_->dynamic_audio_buffer_time);
534 }
535 
TEST_F(Controller103Test,feature_spec_version_103_dab_test)536 TEST_F(Controller103Test, feature_spec_version_103_dab_test) {
537   ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 0x100 + 3);
538   ASSERT_FALSE(controller_->GetVendorCapabilities().a2dp_offload_v2_support_);
539   ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
540   ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
541   ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
542   ASSERT_TRUE(controller_->IsSupported(OpCode::DYNAMIC_AUDIO_BUFFER));
543   ASSERT_EQ(controller_->GetDabSupportedCodecs(), kDynamicAudioBufferSupport);
544   for (size_t bit = 0; bit < 32; bit++) {
545     if (kDynamicAudioBufferSupport & (1u << bit)) {
546       ASSERT_GT(controller_->GetDabCodecCapabilities()[bit].maximum_time_ms_, 0) << " bit " << bit;
547     } else {
548       ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].maximum_time_ms_, 0);
549       ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].minimum_time_ms_, 0);
550       ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].default_time_ms_, 0);
551     }
552   }
553 }
554 
TEST_F(Controller103Test,set_dynamic_audio_buffer_time)555 TEST_F(Controller103Test, set_dynamic_audio_buffer_time) {
556   controller_->SetDabAudioBufferTime(123);
557   thread_.GetReactor()->WaitForIdle(std::chrono::seconds(1));
558   ASSERT_EQ(123, test_hci_layer_->dynamic_audio_buffer_time);
559 }
560 
TEST_F(Controller104Test,feature_spec_version_104_test)561 TEST_F(Controller104Test, feature_spec_version_104_test) {
562   ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 0x100 + 4);
563   ASSERT_TRUE(controller_->GetVendorCapabilities().a2dp_offload_v2_support_);
564   ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
565   ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
566   ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
567   ASSERT_TRUE(controller_->IsSupported(OpCode::DYNAMIC_AUDIO_BUFFER));
568   ASSERT_EQ(controller_->GetDabSupportedCodecs(), kDynamicAudioBufferSupport);
569   for (size_t bit = 0; bit < 32; bit++) {
570     if (kDynamicAudioBufferSupport & (1u << bit)) {
571       ASSERT_GT(controller_->GetDabCodecCapabilities()[bit].maximum_time_ms_, 0) << " bit " << bit;
572     } else {
573       ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].maximum_time_ms_, 0);
574       ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].minimum_time_ms_, 0);
575       ASSERT_EQ(controller_->GetDabCodecCapabilities()[bit].default_time_ms_, 0);
576     }
577   }
578 }
579 
580 std::promise<void> credits1_set;
581 std::promise<void> credits2_set;
582 
CheckReceivedCredits(uint16_t handle,uint16_t credits)583 void CheckReceivedCredits(uint16_t handle, uint16_t credits) {
584   switch (handle) {
585     case (kHandle1):
586       ASSERT_EQ(kCredits1, credits);
587       credits1_set.set_value();
588       break;
589     case (kHandle2):
590       ASSERT_EQ(kCredits2, credits);
591       credits2_set.set_value();
592       break;
593     default:
594       log::fatal("Unknown handle 0x{:0x} with 0x{:0x} credits", handle, credits);
595   }
596 }
597 
TEST_F(ControllerTest,aclCreditCallbacksTest)598 TEST_F(ControllerTest, aclCreditCallbacksTest) {
599   credits1_set = std::promise<void>();
600   credits2_set = std::promise<void>();
601 
602   auto credits1_set_future = credits1_set.get_future();
603   auto credits2_set_future = credits2_set.get_future();
604 
605   controller_->RegisterCompletedAclPacketsCallback(client_handler_->Bind(&CheckReceivedCredits));
606 
607   test_hci_layer_->IncomingCredit();
608 
609   ASSERT_EQ(std::future_status::ready, credits1_set_future.wait_for(2s));
610   ASSERT_EQ(std::future_status::ready, credits2_set_future.wait_for(2s));
611 }
612 
TEST_F(ControllerTest,aclCreditCallbackListenerUnregistered)613 TEST_F(ControllerTest, aclCreditCallbackListenerUnregistered) {
614   os::Thread thread("test_thread", os::Thread::Priority::NORMAL);
615   os::Handler handler(&thread);
616   controller_->RegisterCompletedAclPacketsCallback(handler.Bind(&CheckReceivedCredits));
617 
618   handler.Clear();
619   handler.WaitUntilStopped(std::chrono::milliseconds(100));
620   controller_->UnregisterCompletedAclPacketsCallback();
621 
622   test_hci_layer_->IncomingCredit();
623 }
624 
625 std::promise<uint64_t> le_rand_set;
626 
le_rand_callback(uint64_t random)627 void le_rand_callback(uint64_t random) { le_rand_set.set_value(random); }
628 
TEST_F(ControllerTest,leRandTest)629 TEST_F(ControllerTest, leRandTest) {
630   le_rand_set = std::promise<uint64_t>();
631   auto le_rand_set_future = le_rand_set.get_future();
632 
633   controller_->LeRand(client_handler_->BindOnce(le_rand_callback));
634 
635   ASSERT_EQ(std::future_status::ready, le_rand_set_future.wait_for(2s));
636   ASSERT_EQ(kRandomNumber, le_rand_set_future.get());
637 }
638 
639 }  // namespace hci
640 }  // namespace bluetooth
641