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 <gtest/gtest.h>
20
21 #include <algorithm>
22 #include <chrono>
23 #include <future>
24 #include <map>
25 #include <memory>
26
27 #include "common/bind.h"
28 #include "common/callback.h"
29 #include "common/init_flags.h"
30 #include "hci/address.h"
31 #include "hci/hci_layer.h"
32 #include "os/thread.h"
33 #include "packet/raw_builder.h"
34
35 using namespace bluetooth;
36 using namespace std::chrono_literals;
37
38 using common::BidiQueue;
39 using common::BidiQueueEnd;
40 using packet::kLittleEndian;
41 using packet::PacketView;
42 using packet::RawBuilder;
43
44 namespace bluetooth {
45 namespace hci {
46
47 namespace {
48
49 constexpr uint16_t kHandle1 = 0x123;
50 constexpr uint16_t kCredits1 = 0x78;
51 constexpr uint16_t kHandle2 = 0x456;
52 constexpr uint16_t kCredits2 = 0x9a;
53 constexpr uint64_t kRandomNumber = 0x123456789abcdef0;
54 uint16_t feature_spec_version = 55;
55 constexpr char title[] = "hci_controller_test";
56
GetPacketView(std::unique_ptr<packet::BasePacketBuilder> packet)57 PacketView<kLittleEndian> GetPacketView(std::unique_ptr<packet::BasePacketBuilder> packet) {
58 auto bytes = std::make_shared<std::vector<uint8_t>>();
59 BitInserter i(*bytes);
60 bytes->reserve(packet->size());
61 packet->Serialize(i);
62 return packet::PacketView<packet::kLittleEndian>(bytes);
63 }
64
65 } // namespace
66
67 namespace {
68
69 class TestHciLayer : public HciLayer {
70 public:
EnqueueCommand(std::unique_ptr<CommandBuilder> command,common::ContextualOnceCallback<void (CommandCompleteView)> on_complete)71 void EnqueueCommand(
72 std::unique_ptr<CommandBuilder> command,
73 common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) override {
74 GetHandler()->Post(common::BindOnce(&TestHciLayer::HandleCommand, common::Unretained(this), std::move(command),
75 std::move(on_complete)));
76 }
77
EnqueueCommand(std::unique_ptr<CommandBuilder> command,common::ContextualOnceCallback<void (CommandStatusView)> on_status)78 void EnqueueCommand(
79 std::unique_ptr<CommandBuilder> command,
80 common::ContextualOnceCallback<void(CommandStatusView)> on_status) override {
81 FAIL() << "Controller properties should not generate Command Status";
82 }
83
HandleCommand(std::unique_ptr<CommandBuilder> command_builder,common::ContextualOnceCallback<void (CommandCompleteView)> on_complete)84 void HandleCommand(
85 std::unique_ptr<CommandBuilder> command_builder,
86 common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) {
87 auto packet_view = GetPacketView(std::move(command_builder));
88 CommandView command = CommandView::Create(packet_view);
89 ASSERT_TRUE(command.IsValid());
90
91 uint8_t num_packets = 1;
92 std::unique_ptr<packet::BasePacketBuilder> event_builder;
93 switch (command.GetOpCode()) {
94 case (OpCode::READ_LOCAL_NAME): {
95 std::array<uint8_t, 248> local_name = {'D', 'U', 'T', '\0'};
96 event_builder = ReadLocalNameCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, local_name);
97 } break;
98 case (OpCode::READ_LOCAL_VERSION_INFORMATION): {
99 LocalVersionInformation local_version_information;
100 local_version_information.hci_version_ = HciVersion::V_5_0;
101 local_version_information.hci_revision_ = 0x1234;
102 local_version_information.lmp_version_ = LmpVersion::V_4_2;
103 local_version_information.manufacturer_name_ = 0xBAD;
104 local_version_information.lmp_subversion_ = 0x5678;
105 event_builder = ReadLocalVersionInformationCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS,
106 local_version_information);
107 } break;
108 case (OpCode::READ_LOCAL_SUPPORTED_COMMANDS): {
109 std::array<uint8_t, 64> supported_commands;
110 for (int i = 0; i < 37; i++) {
111 supported_commands[i] = 0xff;
112 }
113 for (int i = 37; i < 64; i++) {
114 supported_commands[i] = 0x00;
115 }
116 event_builder =
117 ReadLocalSupportedCommandsCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, supported_commands);
118 } break;
119 case (OpCode::READ_LOCAL_EXTENDED_FEATURES): {
120 ReadLocalExtendedFeaturesView read_command = ReadLocalExtendedFeaturesView::Create(command);
121 ASSERT_TRUE(read_command.IsValid());
122 uint8_t page_bumber = read_command.GetPageNumber();
123 uint64_t lmp_features = 0x012345678abcdef;
124 lmp_features += page_bumber;
125 event_builder = ReadLocalExtendedFeaturesCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, page_bumber,
126 0x02, lmp_features);
127 } break;
128 case (OpCode::READ_BUFFER_SIZE): {
129 event_builder = ReadBufferSizeCompleteBuilder::Create(
130 num_packets, ErrorCode::SUCCESS, acl_data_packet_length, synchronous_data_packet_length,
131 total_num_acl_data_packets, total_num_synchronous_data_packets);
132 } break;
133 case (OpCode::READ_BD_ADDR): {
134 event_builder = ReadBdAddrCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, Address::kAny);
135 } break;
136 case (OpCode::LE_READ_BUFFER_SIZE_V1): {
137 LeBufferSize le_buffer_size;
138 le_buffer_size.le_data_packet_length_ = 0x16;
139 le_buffer_size.total_num_le_packets_ = 0x08;
140 event_builder = LeReadBufferSizeV1CompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, le_buffer_size);
141 } break;
142 case (OpCode::LE_READ_LOCAL_SUPPORTED_FEATURES): {
143 event_builder =
144 LeReadLocalSupportedFeaturesCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, 0x001f123456789abc);
145 } break;
146 case (OpCode::LE_READ_SUPPORTED_STATES): {
147 event_builder =
148 LeReadSupportedStatesCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, 0x001f123456789abe);
149 } break;
150 case (OpCode::LE_READ_MAXIMUM_DATA_LENGTH): {
151 LeMaximumDataLength le_maximum_data_length;
152 le_maximum_data_length.supported_max_tx_octets_ = 0x12;
153 le_maximum_data_length.supported_max_tx_time_ = 0x34;
154 le_maximum_data_length.supported_max_rx_octets_ = 0x56;
155 le_maximum_data_length.supported_max_rx_time_ = 0x78;
156 event_builder =
157 LeReadMaximumDataLengthCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, le_maximum_data_length);
158 } break;
159 case (OpCode::LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH): {
160 event_builder =
161 LeReadMaximumAdvertisingDataLengthCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, 0x0672);
162 } break;
163 case (OpCode::LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS): {
164 event_builder =
165 LeReadNumberOfSupportedAdvertisingSetsCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, 0xF0);
166 } break;
167 case (OpCode::LE_GET_VENDOR_CAPABILITIES): {
168 BaseVendorCapabilities base_vendor_capabilities;
169 base_vendor_capabilities.max_advt_instances_ = 0x10;
170 base_vendor_capabilities.offloaded_resolution_of_private_address_ = 0x01;
171 base_vendor_capabilities.total_scan_results_storage_ = 0x2800;
172 base_vendor_capabilities.max_irk_list_sz_ = 0x20;
173 base_vendor_capabilities.filtering_support_ = 0x01;
174 base_vendor_capabilities.max_filter_ = 0x10;
175 base_vendor_capabilities.activity_energy_info_support_ = 0x01;
176
177 auto payload = std::make_unique<RawBuilder>();
178 if (feature_spec_version > 55) {
179 std::vector<uint8_t> payload_bytes = {0x20, 0x00, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00};
180 payload->AddOctets2(feature_spec_version);
181 payload->AddOctets(payload_bytes);
182 }
183 event_builder = LeGetVendorCapabilitiesCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS,
184 base_vendor_capabilities, std::move(payload));
185 } break;
186 case (OpCode::SET_EVENT_MASK): {
187 auto view = SetEventMaskView::Create(command);
188 ASSERT_TRUE(view.IsValid());
189 event_mask = view.GetEventMask();
190 event_builder = SetEventMaskCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS);
191 } break;
192 case (OpCode::LE_SET_EVENT_MASK): {
193 auto view = LeSetEventMaskView::Create(command);
194 ASSERT_TRUE(view.IsValid());
195 le_event_mask = view.GetLeEventMask();
196 event_builder = LeSetEventMaskCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS);
197 } break;
198
199 case (OpCode::LE_RAND): {
200 auto view = LeRandView::Create(LeSecurityCommandView::Create(command));
201 ASSERT_TRUE(view.IsValid());
202 event_builder = LeRandCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, kRandomNumber);
203 } break;
204
205 case (OpCode::RESET):
206 case (OpCode::SET_EVENT_FILTER):
207 case (OpCode::HOST_BUFFER_SIZE):
208 command_queue_.push(command);
209 not_empty_.notify_all();
210 return;
211 default:
212 LOG_INFO("Dropping unhandled packet");
213 return;
214 }
215 auto packet = GetPacketView(std::move(event_builder));
216 EventView event = EventView::Create(packet);
217 ASSERT_TRUE(event.IsValid());
218 CommandCompleteView command_complete = CommandCompleteView::Create(event);
219 ASSERT_TRUE(command_complete.IsValid());
220 on_complete.Invoke(std::move(command_complete));
221 }
222
RegisterEventHandler(EventCode event_code,common::ContextualCallback<void (EventView)> event_handler)223 void RegisterEventHandler(EventCode event_code, common::ContextualCallback<void(EventView)> event_handler) override {
224 ASSERT_EQ(event_code, EventCode::NUMBER_OF_COMPLETED_PACKETS) << "Only NUMBER_OF_COMPLETED_PACKETS is needed";
225 number_of_completed_packets_callback_ = event_handler;
226 }
227
UnregisterEventHandler(EventCode event_code)228 void UnregisterEventHandler(EventCode event_code) override {
229 ASSERT_EQ(event_code, EventCode::NUMBER_OF_COMPLETED_PACKETS) << "Only NUMBER_OF_COMPLETED_PACKETS is needed";
230 number_of_completed_packets_callback_ = {};
231 }
232
IncomingCredit()233 void IncomingCredit() {
234 std::vector<CompletedPackets> completed_packets;
235 CompletedPackets cp;
236 cp.host_num_of_completed_packets_ = kCredits1;
237 cp.connection_handle_ = kHandle1;
238 completed_packets.push_back(cp);
239 cp.host_num_of_completed_packets_ = kCredits2;
240 cp.connection_handle_ = kHandle2;
241 completed_packets.push_back(cp);
242 auto event_builder = NumberOfCompletedPacketsBuilder::Create(completed_packets);
243 auto packet = GetPacketView(std::move(event_builder));
244 EventView event = EventView::Create(packet);
245 ASSERT_TRUE(event.IsValid());
246 number_of_completed_packets_callback_.Invoke(event);
247 }
248
GetCommand(OpCode op_code)249 CommandView GetCommand(OpCode op_code) {
250 std::unique_lock<std::mutex> lock(mutex_);
251 std::chrono::milliseconds time = std::chrono::milliseconds(3000);
252
253 // wait for command
254 while (command_queue_.size() == 0UL) {
255 if (not_empty_.wait_for(lock, time) == std::cv_status::timeout) {
256 break;
257 }
258 }
259 if (command_queue_.empty()) {
260 return CommandView::Create(PacketView<kLittleEndian>(std::make_shared<std::vector<uint8_t>>()));
261 }
262 CommandView command = command_queue_.front();
263 command_queue_.pop();
264 return command;
265 }
266
ListDependencies(ModuleList * list) const267 void ListDependencies(ModuleList* list) const {}
Start()268 void Start() override {}
Stop()269 void Stop() override {}
270
271 constexpr static uint16_t acl_data_packet_length = 1024;
272 constexpr static uint8_t synchronous_data_packet_length = 60;
273 constexpr static uint16_t total_num_acl_data_packets = 10;
274 constexpr static uint16_t total_num_synchronous_data_packets = 12;
275 uint64_t event_mask = 0;
276 uint64_t le_event_mask = 0;
277
278 private:
279 common::ContextualCallback<void(EventView)> number_of_completed_packets_callback_;
280 std::queue<CommandView> command_queue_;
281 mutable std::mutex mutex_;
282 std::condition_variable not_empty_;
283 };
284
285 } // namespace
286 class ControllerTest : public ::testing::Test {
287 protected:
SetUp()288 void SetUp() override {
289 feature_spec_version = feature_spec_version_;
290 bluetooth::common::InitFlags::SetAllForTesting();
291 test_hci_layer_ = new TestHciLayer;
292 fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);
293 client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
294 fake_registry_.Start<Controller>(&thread_);
295 controller_ = static_cast<Controller*>(fake_registry_.GetModuleUnderTest(&Controller::Factory));
296 }
297
TearDown()298 void TearDown() override {
299 fake_registry_.StopAll();
300 }
301
302 TestModuleRegistry fake_registry_;
303 TestHciLayer* test_hci_layer_ = nullptr;
304 os::Thread& thread_ = fake_registry_.GetTestThread();
305 Controller* controller_ = nullptr;
306 os::Handler* client_handler_ = nullptr;
307 uint16_t feature_spec_version_ = 98;
308 };
309
310 class Controller055Test : public ControllerTest {
311 protected:
SetUp()312 void SetUp() override {
313 feature_spec_version_ = 55;
314 ControllerTest::SetUp();
315 }
316 };
317
318 class Controller095Test : public ControllerTest {
319 protected:
SetUp()320 void SetUp() override {
321 feature_spec_version_ = 95;
322 ControllerTest::SetUp();
323 }
324 };
325
326 class Controller096Test : public ControllerTest {
327 protected:
SetUp()328 void SetUp() override {
329 feature_spec_version_ = 96;
330 ControllerTest::SetUp();
331 }
332 };
333
TEST_F(ControllerTest,startup_teardown)334 TEST_F(ControllerTest, startup_teardown) {}
335
TEST_F(ControllerTest,read_controller_info)336 TEST_F(ControllerTest, read_controller_info) {
337 ASSERT_EQ(controller_->GetAclPacketLength(), test_hci_layer_->acl_data_packet_length);
338 ASSERT_EQ(controller_->GetNumAclPacketBuffers(), test_hci_layer_->total_num_acl_data_packets);
339 ASSERT_EQ(controller_->GetScoPacketLength(), test_hci_layer_->synchronous_data_packet_length);
340 ASSERT_EQ(controller_->GetNumScoPacketBuffers(), test_hci_layer_->total_num_synchronous_data_packets);
341 ASSERT_EQ(controller_->GetMacAddress(), Address::kAny);
342 LocalVersionInformation local_version_information = controller_->GetLocalVersionInformation();
343 ASSERT_EQ(local_version_information.hci_version_, HciVersion::V_5_0);
344 ASSERT_EQ(local_version_information.hci_revision_, 0x1234);
345 ASSERT_EQ(local_version_information.lmp_version_, LmpVersion::V_4_2);
346 ASSERT_EQ(local_version_information.manufacturer_name_, 0xBAD);
347 ASSERT_EQ(local_version_information.lmp_subversion_, 0x5678);
348 ASSERT_EQ(controller_->GetLeBufferSize().le_data_packet_length_, 0x16);
349 ASSERT_EQ(controller_->GetLeBufferSize().total_num_le_packets_, 0x08);
350 ASSERT_EQ(controller_->GetLeSupportedStates(), 0x001f123456789abeUL);
351 ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_tx_octets_, 0x12);
352 ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_tx_time_, 0x34);
353 ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_rx_octets_, 0x56);
354 ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_rx_time_, 0x78);
355 ASSERT_EQ(controller_->GetLeMaximumAdvertisingDataLength(), 0x0672);
356 ASSERT_EQ(controller_->GetLeNumberOfSupportedAdverisingSets(), 0xF0);
357 }
358
TEST_F(ControllerTest,read_write_local_name)359 TEST_F(ControllerTest, read_write_local_name) {
360 ASSERT_EQ(controller_->GetLocalName(), "DUT");
361 controller_->WriteLocalName("New name");
362 ASSERT_EQ(controller_->GetLocalName(), "New name");
363 }
364
TEST_F(ControllerTest,send_set_event_mask_command)365 TEST_F(ControllerTest, send_set_event_mask_command) {
366 uint64_t new_event_mask = test_hci_layer_->event_mask - 1;
367 controller_->SetEventMask(new_event_mask);
368 // Send another command to make sure it was applied
369 controller_->Reset();
370 auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
371 ASSERT_EQ(new_event_mask, test_hci_layer_->event_mask);
372 }
373
TEST_F(ControllerTest,send_reset_command)374 TEST_F(ControllerTest, send_reset_command) {
375 controller_->Reset();
376 auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
377 auto command = ResetView::Create(packet);
378 ASSERT_TRUE(command.IsValid());
379 }
380
TEST_F(ControllerTest,send_set_event_filter_command)381 TEST_F(ControllerTest, send_set_event_filter_command) {
382 controller_->SetEventFilterInquiryResultAllDevices();
383 auto packet = test_hci_layer_->GetCommand(OpCode::SET_EVENT_FILTER);
384 auto set_event_filter_view1 = SetEventFilterView::Create(packet);
385 auto set_event_filter_inquiry_result_view1 = SetEventFilterInquiryResultView::Create(set_event_filter_view1);
386 auto command1 = SetEventFilterInquiryResultAllDevicesView::Create(set_event_filter_inquiry_result_view1);
387 ASSERT_TRUE(command1.IsValid());
388
389 ClassOfDevice class_of_device({0xab, 0xcd, 0xef});
390 ClassOfDevice class_of_device_mask({0x12, 0x34, 0x56});
391 controller_->SetEventFilterInquiryResultClassOfDevice(class_of_device, class_of_device_mask);
392 packet = test_hci_layer_->GetCommand(OpCode::SET_EVENT_FILTER);
393 auto set_event_filter_view2 = SetEventFilterView::Create(packet);
394 auto set_event_filter_inquiry_result_view2 = SetEventFilterInquiryResultView::Create(set_event_filter_view2);
395 auto command2 = SetEventFilterInquiryResultClassOfDeviceView::Create(set_event_filter_inquiry_result_view2);
396 ASSERT_TRUE(command2.IsValid());
397 ASSERT_EQ(command2.GetClassOfDevice(), class_of_device);
398
399 Address bdaddr({0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc});
400 controller_->SetEventFilterConnectionSetupAddress(bdaddr, AutoAcceptFlag::AUTO_ACCEPT_ON_ROLE_SWITCH_ENABLED);
401 packet = test_hci_layer_->GetCommand(OpCode::SET_EVENT_FILTER);
402 auto set_event_filter_view3 = SetEventFilterView::Create(packet);
403 auto set_event_filter_connection_setup_view = SetEventFilterConnectionSetupView::Create(set_event_filter_view3);
404 auto command3 = SetEventFilterConnectionSetupAddressView::Create(set_event_filter_connection_setup_view);
405 ASSERT_TRUE(command3.IsValid());
406 ASSERT_EQ(command3.GetAddress(), bdaddr);
407 }
408
TEST_F(ControllerTest,send_host_buffer_size_command)409 TEST_F(ControllerTest, send_host_buffer_size_command) {
410 controller_->HostBufferSize(0xFF00, 0xF1, 0xFF02, 0xFF03);
411 auto packet = test_hci_layer_->GetCommand(OpCode::HOST_BUFFER_SIZE);
412 auto command = HostBufferSizeView::Create(packet);
413 ASSERT_TRUE(command.IsValid());
414 ASSERT_EQ(command.GetHostAclDataPacketLength(), 0xFF00);
415 ASSERT_EQ(command.GetHostSynchronousDataPacketLength(), 0xF1);
416 ASSERT_EQ(command.GetHostTotalNumAclDataPackets(), 0xFF02);
417 ASSERT_EQ(command.GetHostTotalNumSynchronousDataPackets(), 0xFF03);
418 }
419
TEST_F(ControllerTest,send_le_set_event_mask_command)420 TEST_F(ControllerTest, send_le_set_event_mask_command) {
421 uint64_t new_le_event_mask = test_hci_layer_->event_mask - 1;
422 controller_->LeSetEventMask(new_le_event_mask);
423 // Send another command to make sure it was applied
424 controller_->Reset();
425 auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
426 ASSERT_EQ(new_le_event_mask, test_hci_layer_->le_event_mask);
427 }
428
TEST_F(ControllerTest,is_supported_test)429 TEST_F(ControllerTest, is_supported_test) {
430 ASSERT_TRUE(controller_->IsSupported(OpCode::INQUIRY));
431 ASSERT_TRUE(controller_->IsSupported(OpCode::REJECT_CONNECTION_REQUEST));
432 ASSERT_TRUE(controller_->IsSupported(OpCode::ACCEPT_CONNECTION_REQUEST));
433 ASSERT_FALSE(controller_->IsSupported(OpCode::LE_REMOVE_ADVERTISING_SET));
434 ASSERT_FALSE(controller_->IsSupported(OpCode::LE_CLEAR_ADVERTISING_SETS));
435 ASSERT_FALSE(controller_->IsSupported(OpCode::LE_SET_PERIODIC_ADVERTISING_PARAM));
436 }
437
TEST_F(Controller055Test,feature_spec_version_055_test)438 TEST_F(Controller055Test, feature_spec_version_055_test) {
439 ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 55);
440 ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
441 ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
442 ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
443 }
444
TEST_F(Controller095Test,feature_spec_version_095_test)445 TEST_F(Controller095Test, feature_spec_version_095_test) {
446 ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 95);
447 ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
448 ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
449 ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
450 }
451
TEST_F(Controller096Test,feature_spec_version_096_test)452 TEST_F(Controller096Test, feature_spec_version_096_test) {
453 ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 96);
454 ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
455 ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
456 ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
457 }
458
TEST_F(ControllerTest,feature_spec_version_098_test)459 TEST_F(ControllerTest, feature_spec_version_098_test) {
460 ASSERT_EQ(controller_->GetVendorCapabilities().version_supported_, 98);
461 ASSERT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
462 ASSERT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
463 ASSERT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
464 }
465
466 std::promise<void> credits1_set;
467 std::promise<void> credits2_set;
468
CheckReceivedCredits(uint16_t handle,uint16_t credits)469 void CheckReceivedCredits(uint16_t handle, uint16_t credits) {
470 switch (handle) {
471 case (kHandle1):
472 ASSERT_EQ(kCredits1, credits);
473 credits1_set.set_value();
474 break;
475 case (kHandle2):
476 ASSERT_EQ(kCredits2, credits);
477 credits2_set.set_value();
478 break;
479 default:
480 ASSERT_LOG(false, "Unknown handle 0x%0hx with 0x%0hx credits", handle, credits);
481 }
482 }
483
TEST_F(ControllerTest,aclCreditCallbacksTest)484 TEST_F(ControllerTest, aclCreditCallbacksTest) {
485 credits1_set = std::promise<void>();
486 credits2_set = std::promise<void>();
487
488 auto credits1_set_future = credits1_set.get_future();
489 auto credits2_set_future = credits2_set.get_future();
490
491 controller_->RegisterCompletedAclPacketsCallback(client_handler_->Bind(&CheckReceivedCredits));
492
493 test_hci_layer_->IncomingCredit();
494
495 ASSERT_EQ(std::future_status::ready, credits1_set_future.wait_for(2s));
496 ASSERT_EQ(std::future_status::ready, credits2_set_future.wait_for(2s));
497 }
498
TEST_F(ControllerTest,aclCreditCallbackListenerUnregistered)499 TEST_F(ControllerTest, aclCreditCallbackListenerUnregistered) {
500 os::Thread thread("test_thread", os::Thread::Priority::NORMAL);
501 os::Handler handler(&thread);
502 controller_->RegisterCompletedAclPacketsCallback(handler.Bind(&CheckReceivedCredits));
503
504 handler.Clear();
505 handler.WaitUntilStopped(std::chrono::milliseconds(100));
506 controller_->UnregisterCompletedAclPacketsCallback();
507
508 test_hci_layer_->IncomingCredit();
509 }
510
511 std::promise<uint64_t> le_rand_set;
512
le_rand_callback(uint64_t random)513 void le_rand_callback(uint64_t random) {
514 le_rand_set.set_value(random);
515 }
516
TEST_F(ControllerTest,Dumpsys)517 TEST_F(ControllerTest, Dumpsys) {
518 ModuleDumper dumper(fake_registry_, title);
519
520 std::string output;
521 dumper.DumpState(&output);
522
523 ASSERT_TRUE(output.find("Hci Controller Dumpsys") != std::string::npos);
524 }
525
526 } // namespace hci
527 } // namespace bluetooth
528