1 // Copyright 2023 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_bluetooth_sapphire/internal/host/gap/adapter.h"
16
17 #include <memory>
18
19 #include "pw_bluetooth_sapphire/internal/host/gap/bredr_discovery_manager.h"
20 #include "pw_bluetooth_sapphire/internal/host/gap/low_energy_address_manager.h"
21 #include "pw_bluetooth_sapphire/internal/host/gap/low_energy_advertising_manager.h"
22 #include "pw_bluetooth_sapphire/internal/host/gap/low_energy_discovery_manager.h"
23 #include "pw_bluetooth_sapphire/internal/host/gatt/fake_layer.h"
24 #include "pw_bluetooth_sapphire/internal/host/hci-spec/constants.h"
25 #include "pw_bluetooth_sapphire/internal/host/hci-spec/util.h"
26 #include "pw_bluetooth_sapphire/internal/host/l2cap/fake_l2cap.h"
27 #include "pw_bluetooth_sapphire/internal/host/testing/controller_test.h"
28 #include "pw_bluetooth_sapphire/internal/host/testing/fake_controller.h"
29 #include "pw_bluetooth_sapphire/internal/host/testing/fake_peer.h"
30 #include "pw_bluetooth_sapphire/internal/host/testing/inspect.h"
31
32 namespace bt::gap {
33 namespace {
34
35 using namespace inspect::testing;
36 namespace android_hci = hci_spec::vendor::android;
37 using testing::FakeController;
38 using testing::FakePeer;
39 using TestingBase = testing::FakeDispatcherControllerTest<FakeController>;
40
41 using FeaturesBits = pw::bluetooth::Controller::FeaturesBits;
42
43 const DeviceAddress kTestAddr(DeviceAddress::Type::kLEPublic,
44 {0x01, 0, 0, 0, 0, 0});
45 const DeviceAddress kTestAddr2(DeviceAddress::Type::kLEPublic,
46 {2, 0, 0, 0, 0, 0});
47 const DeviceAddress kTestAddrBrEdr(DeviceAddress::Type::kBREDR,
48 {3, 0, 0, 0, 0, 0});
49
50 constexpr FeaturesBits kDefaultFeaturesBits =
51 FeaturesBits::kHciSco | FeaturesBits::kHciIso |
52 FeaturesBits::kSetAclPriorityCommand;
53
54 class AdapterTest : public TestingBase {
55 public:
56 AdapterTest() = default;
57 ~AdapterTest() override = default;
58
SetUp()59 void SetUp() override { SetUp(kDefaultFeaturesBits); }
60
SetUp(FeaturesBits features)61 void SetUp(FeaturesBits features) {
62 // Don't initialize Transport yet because Adapter initializes Transport.
63 TestingBase::SetUp(features, /*initialize_transport=*/false);
64
65 transport_closed_called_ = false;
66
67 auto l2cap = std::make_unique<l2cap::testing::FakeL2cap>(dispatcher());
68 gatt_ = std::make_unique<gatt::testing::FakeLayer>(dispatcher());
69 Adapter::Config config = {
70 .legacy_pairing_enabled = false,
71 };
72 adapter_ = Adapter::Create(dispatcher(),
73 transport()->GetWeakPtr(),
74 gatt_->GetWeakPtr(),
75 config,
76 std::move(l2cap));
77 }
78
TearDown()79 void TearDown() override {
80 if (adapter_->IsInitialized()) {
81 adapter_->ShutDown();
82 }
83
84 adapter_ = nullptr;
85 gatt_ = nullptr;
86 TestingBase::TearDown();
87 }
88
InitializeAdapter(Adapter::InitializeCallback callback)89 void InitializeAdapter(Adapter::InitializeCallback callback) {
90 adapter_->Initialize(std::move(callback),
91 [this] { transport_closed_called_ = true; });
92 RunUntilIdle();
93 }
94
EnsureInitialized()95 bool EnsureInitialized() {
96 bool initialized = false;
97 InitializeAdapter([&](bool success) {
98 EXPECT_TRUE(success);
99 initialized = true;
100 });
101 return initialized;
102 }
103
104 protected:
105 void GetSupportedDelayRangeHelper(
106 bool supported, const std::optional<std::vector<uint8_t>>& codec_config);
107
transport_closed_called() const108 bool transport_closed_called() const { return transport_closed_called_; }
109
adapter() const110 Adapter* adapter() const { return adapter_.get(); }
111
112 private:
113 bool transport_closed_called_;
114 std::unique_ptr<gatt::testing::FakeLayer> gatt_;
115 std::unique_ptr<Adapter> adapter_;
116
117 BT_DISALLOW_COPY_AND_ASSIGN_ALLOW_MOVE(AdapterTest);
118 };
119
120 class AdapterScoAndIsoDisabledTest : public AdapterTest {
121 public:
SetUp()122 void SetUp() override { AdapterTest::SetUp(FeaturesBits{0}); }
123 };
124
TEST_F(AdapterTest,InitializeFailureNoFeaturesSupported)125 TEST_F(AdapterTest, InitializeFailureNoFeaturesSupported) {
126 bool success;
127 int init_cb_count = 0;
128 auto init_cb = [&](bool cb_success) {
129 success = cb_success;
130 init_cb_count++;
131 };
132
133 // The controller supports nothing.
134 InitializeAdapter(std::move(init_cb));
135 EXPECT_FALSE(success);
136 EXPECT_EQ(1, init_cb_count);
137 EXPECT_FALSE(transport_closed_called());
138 }
139
TEST_F(AdapterTest,InitializeFailureNoBufferInfo)140 TEST_F(AdapterTest, InitializeFailureNoBufferInfo) {
141 bool success;
142 int init_cb_count = 0;
143 auto init_cb = [&](bool cb_success) {
144 success = cb_success;
145 init_cb_count++;
146 };
147
148 // Enable LE support.
149 FakeController::Settings settings;
150 settings.lmp_features_page0 |=
151 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
152 test_device()->set_settings(settings);
153
154 InitializeAdapter(std::move(init_cb));
155 EXPECT_FALSE(success);
156 EXPECT_EQ(1, init_cb_count);
157 EXPECT_FALSE(transport_closed_called());
158 }
159
TEST_F(AdapterTest,InitializeNoBREDR)160 TEST_F(AdapterTest, InitializeNoBREDR) {
161 bool success;
162 int init_cb_count = 0;
163 auto init_cb = [&](bool cb_success) {
164 success = cb_success;
165 init_cb_count++;
166 };
167
168 // Enable LE support, disable BR/EDR
169 FakeController::Settings settings;
170 settings.lmp_features_page0 |=
171 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
172 settings.lmp_features_page0 |=
173 static_cast<uint64_t>(hci_spec::LMPFeature::kBREDRNotSupported);
174 settings.le_acl_data_packet_length = 0x1B;
175 settings.le_total_num_acl_data_packets = 1;
176 test_device()->set_settings(settings);
177
178 InitializeAdapter(std::move(init_cb));
179 EXPECT_TRUE(success);
180 EXPECT_EQ(1, init_cb_count);
181 EXPECT_TRUE(adapter()->state().IsLowEnergySupported());
182 EXPECT_FALSE(adapter()->state().IsBREDRSupported());
183 EXPECT_FALSE(adapter()->bredr());
184 EXPECT_EQ(TechnologyType::kLowEnergy, adapter()->state().type());
185 EXPECT_FALSE(transport_closed_called());
186 }
187
TEST_F(AdapterTest,InitializeQueriesAndroidExtensionsCapabilitiesIfSupported)188 TEST_F(AdapterTest, InitializeQueriesAndroidExtensionsCapabilitiesIfSupported) {
189 TearDown();
190 SetUp(FeaturesBits::kAndroidVendorExtensions);
191
192 bool success;
193 int init_cb_count = 0;
194 auto init_cb = [&](bool cb_success) {
195 success = cb_success;
196 init_cb_count++;
197 };
198
199 FakeController::Settings settings;
200 settings.ApplyLEOnlyDefaults();
201 settings.ApplyAndroidVendorExtensionDefaults();
202 test_device()->set_settings(settings);
203
204 InitializeAdapter(std::move(init_cb));
205 EXPECT_TRUE(success);
206 EXPECT_EQ(1, init_cb_count);
207 EXPECT_TRUE(adapter()->state().android_vendor_capabilities.has_value());
208 }
209
TEST_F(AdapterTest,InitializeQueryAndroidExtensionsCapabilitiesFailureHandled)210 TEST_F(AdapterTest,
211 InitializeQueryAndroidExtensionsCapabilitiesFailureHandled) {
212 TearDown();
213 SetUp(FeaturesBits::kAndroidVendorExtensions);
214
215 bool success;
216 int init_cb_count = 0;
217 auto init_cb = [&](bool cb_success) {
218 success = cb_success;
219 init_cb_count++;
220 };
221
222 FakeController::Settings settings;
223 settings.ApplyLEOnlyDefaults();
224 settings.ApplyAndroidVendorExtensionDefaults();
225 test_device()->set_settings(settings);
226
227 test_device()->SetDefaultResponseStatus(
228 android_hci::kLEGetVendorCapabilities,
229 pw::bluetooth::emboss::StatusCode::COMMAND_DISALLOWED);
230 InitializeAdapter(std::move(init_cb));
231 EXPECT_FALSE(success);
232 EXPECT_EQ(1, init_cb_count);
233 EXPECT_FALSE(adapter()->state().android_vendor_capabilities.has_value());
234 }
235
TEST_F(AdapterTest,InitializeSuccess)236 TEST_F(AdapterTest, InitializeSuccess) {
237 bool success;
238 int init_cb_count = 0;
239 auto init_cb = [&](bool cb_success) {
240 success = cb_success;
241 init_cb_count++;
242 };
243
244 // Return valid buffer information and enable LE support. (This should
245 // succeed).
246 FakeController::Settings settings;
247 settings.lmp_features_page0 |=
248 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
249 settings.le_acl_data_packet_length = 0x1B;
250 settings.le_total_num_acl_data_packets = 1;
251 test_device()->set_settings(settings);
252
253 InitializeAdapter(std::move(init_cb));
254 EXPECT_TRUE(success);
255 EXPECT_EQ(1, init_cb_count);
256 EXPECT_TRUE(adapter()->state().IsLowEnergySupported());
257 EXPECT_TRUE(adapter()->state().IsBREDRSupported());
258 EXPECT_TRUE(adapter()->le());
259 EXPECT_TRUE(adapter()->bredr());
260 EXPECT_EQ(TechnologyType::kDualMode, adapter()->state().type());
261 EXPECT_FALSE(transport_closed_called());
262 }
263
TEST_F(AdapterTest,InitializeFailureHCICommandError)264 TEST_F(AdapterTest, InitializeFailureHCICommandError) {
265 bool success;
266 int init_cb_count = 0;
267 auto init_cb = [&](bool cb_success) {
268 success = cb_success;
269 init_cb_count++;
270 };
271
272 // Make all settings valid but make an HCI command fail.
273 FakeController::Settings settings;
274 settings.ApplyLEOnlyDefaults();
275 test_device()->set_settings(settings);
276 test_device()->SetDefaultResponseStatus(
277 hci_spec::kLEReadLocalSupportedFeatures,
278 pw::bluetooth::emboss::StatusCode::HARDWARE_FAILURE);
279
280 InitializeAdapter(std::move(init_cb));
281 EXPECT_FALSE(success);
282 EXPECT_EQ(1, init_cb_count);
283 EXPECT_FALSE(adapter()->state().IsLowEnergySupported());
284 EXPECT_FALSE(transport_closed_called());
285 }
286
TEST_F(AdapterTest,InitializeFailureTransportErrorDuringWriteLocalName)287 TEST_F(AdapterTest, InitializeFailureTransportErrorDuringWriteLocalName) {
288 std::optional<bool> success;
289 int init_cb_count = 0;
290 auto init_cb = [&](bool cb_success) {
291 success = cb_success;
292 init_cb_count++;
293 };
294
295 // Make all settings valid but make an HCI command fail.
296 FakeController::Settings settings;
297 settings.ApplyDualModeDefaults();
298 test_device()->set_settings(settings);
299 fit::closure resume_write_local_name_cb = nullptr;
300 test_device()->pause_responses_for_opcode(
301 hci_spec::kWriteLocalName, [&](fit::closure resume) {
302 resume_write_local_name_cb = std::move(resume);
303 });
304
305 InitializeAdapter(std::move(init_cb));
306 ASSERT_TRUE(resume_write_local_name_cb);
307 EXPECT_EQ(0, init_cb_count);
308
309 // Signaling an error should cause Transport to close, which should cause
310 // initialization to fail.
311 test_device()->SignalError(pw::Status::Unknown());
312 ASSERT_TRUE(success.has_value());
313 EXPECT_FALSE(*success);
314 EXPECT_EQ(1, init_cb_count);
315 EXPECT_FALSE(transport_closed_called());
316 }
317
TEST_F(AdapterTest,TransportClosedCallback)318 TEST_F(AdapterTest, TransportClosedCallback) {
319 bool success;
320 int init_cb_count = 0;
321 auto init_cb = [&](bool cb_success) {
322 success = cb_success;
323 init_cb_count++;
324 };
325
326 FakeController::Settings settings;
327 settings.ApplyLEOnlyDefaults();
328 test_device()->set_settings(settings);
329
330 InitializeAdapter(std::move(init_cb));
331 EXPECT_TRUE(success);
332 EXPECT_EQ(1, init_cb_count);
333 EXPECT_TRUE(adapter()->state().IsLowEnergySupported());
334 EXPECT_FALSE(transport_closed_called());
335
336 test_device()->SignalError(pw::Status::Aborted());
337 RunUntilIdle();
338
339 EXPECT_TRUE(transport_closed_called());
340 EXPECT_EQ(1, init_cb_count);
341 }
342
343 // TODO(fxbug.dev/42088281): Add a unit test for Adapter::ShutDown() and update
344 // ShutDownDuringInitialize() with the same expectations.
345
TEST_F(AdapterTest,ShutDownDuringInitialize)346 TEST_F(AdapterTest, ShutDownDuringInitialize) {
347 bool success;
348 int init_cb_count = 0;
349 auto init_cb = [&](bool result) {
350 success = result;
351 init_cb_count++;
352 };
353
354 FakeController::Settings settings;
355 settings.ApplyLEOnlyDefaults();
356 test_device()->set_settings(settings);
357
358 adapter()->Initialize(std::move(init_cb), [] {});
359 EXPECT_TRUE(adapter()->IsInitializing());
360 adapter()->ShutDown();
361
362 EXPECT_EQ(1, init_cb_count);
363 EXPECT_FALSE(success);
364 EXPECT_FALSE(adapter()->IsInitializing());
365 EXPECT_FALSE(adapter()->IsInitialized());
366
367 // Further calls to ShutDown() should have no effect.
368 adapter()->ShutDown();
369 RunUntilIdle();
370 }
371
TEST_F(AdapterTest,SetNameError)372 TEST_F(AdapterTest, SetNameError) {
373 std::string kNewName = "something";
374
375 // Make all settings valid but make WriteLocalName command fail.
376 FakeController::Settings settings;
377 settings.ApplyDualModeDefaults();
378 test_device()->set_settings(settings);
379 test_device()->SetDefaultResponseStatus(
380 hci_spec::kWriteLocalName,
381 pw::bluetooth::emboss::StatusCode::HARDWARE_FAILURE);
382 ASSERT_TRUE(EnsureInitialized());
383
384 hci::Result<> result = fit::ok();
385 auto name_cb = [&result](const auto& status) { result = status; };
386
387 adapter()->SetLocalName(kNewName, name_cb);
388
389 RunUntilIdle();
390
391 EXPECT_EQ(ToResult(pw::bluetooth::emboss::StatusCode::HARDWARE_FAILURE),
392 result);
393 }
394
TEST_F(AdapterTest,SetNameSuccess)395 TEST_F(AdapterTest, SetNameSuccess) {
396 const std::string kNewName = "Fuchsia BT ��✨";
397
398 FakeController::Settings settings;
399 settings.ApplyDualModeDefaults();
400 test_device()->set_settings(settings);
401 ASSERT_TRUE(EnsureInitialized());
402
403 hci::Result<> result = ToResult(HostError::kFailed);
404 auto name_cb = [&result](const auto& status) { result = status; };
405 adapter()->SetLocalName(kNewName, name_cb);
406
407 RunUntilIdle();
408
409 EXPECT_EQ(fit::ok(), result);
410 EXPECT_EQ(kNewName, test_device()->local_name());
411 }
412
413 // Tests that writing a local name that is larger than the maximum size
414 // succeeds. The saved local name is the original (untruncated) local name.
TEST_F(AdapterTest,SetNameLargerThanMax)415 TEST_F(AdapterTest, SetNameLargerThanMax) {
416 const std::string long_name(hci_spec::kMaxNameLength + 1, 'x');
417
418 FakeController::Settings settings;
419 settings.ApplyDualModeDefaults();
420 test_device()->set_settings(settings);
421 ASSERT_TRUE(EnsureInitialized());
422
423 hci::Result<> result = ToResult(HostError::kFailed);
424 auto name_cb = [&result](const auto& status) { result = status; };
425 adapter()->SetLocalName(long_name, name_cb);
426
427 RunUntilIdle();
428
429 EXPECT_EQ(fit::ok(), result);
430 EXPECT_EQ(long_name, adapter()->state().local_name);
431 }
432
433 // Tests that SetLocalName results in BrEdrDiscoveryManager updating it's local
434 // name.
TEST_F(AdapterTest,SetLocalNameCallsBrEdrUpdateLocalName)435 TEST_F(AdapterTest, SetLocalNameCallsBrEdrUpdateLocalName) {
436 const std::string kNewName = "This is a test BT name! 1234";
437
438 FakeController::Settings settings;
439 settings.ApplyDualModeDefaults();
440 test_device()->set_settings(settings);
441 ASSERT_TRUE(EnsureInitialized());
442 ASSERT_TRUE(adapter()->bredr());
443
444 hci::Result<> result = ToResult(HostError::kFailed);
445 auto name_cb = [&result](const auto& status) { result = status; };
446 adapter()->SetLocalName(kNewName, name_cb);
447
448 RunUntilIdle();
449
450 EXPECT_EQ(fit::ok(), result);
451 EXPECT_EQ(kNewName, adapter()->state().local_name);
452 EXPECT_EQ(kNewName, adapter()->local_name());
453 }
454
455 // Tests that writing a long local name results in BrEdr updating it's local
456 // name. Should still succeed, and the stored local name should be the original
457 // name.
TEST_F(AdapterTest,BrEdrUpdateLocalNameLargerThanMax)458 TEST_F(AdapterTest, BrEdrUpdateLocalNameLargerThanMax) {
459 const std::string long_name(
460 hci_spec::kExtendedInquiryResponseMaxNameBytes + 2, 'x');
461
462 FakeController::Settings settings;
463 settings.ApplyDualModeDefaults();
464 test_device()->set_settings(settings);
465 ASSERT_TRUE(EnsureInitialized());
466 EXPECT_TRUE(adapter()->bredr());
467
468 hci::Result<> result = ToResult(HostError::kFailed);
469 auto name_cb = [&result](const auto& status) { result = status; };
470 adapter()->SetLocalName(long_name, name_cb);
471
472 RunUntilIdle();
473
474 EXPECT_EQ(fit::ok(), result);
475 // Both the adapter & discovery manager local name should be the original
476 // (untruncated) name.
477 EXPECT_EQ(long_name, adapter()->state().local_name);
478 EXPECT_EQ(long_name, adapter()->local_name());
479 }
480
481 // Tests WriteExtendedInquiryResponse failure leads to |local_name_| not
482 // updated.
TEST_F(AdapterTest,BrEdrUpdateEIRResponseError)483 TEST_F(AdapterTest, BrEdrUpdateEIRResponseError) {
484 std::string kNewName = "EirFailure";
485
486 // Make all settings valid but make WriteExtendedInquiryResponse command fail.
487 FakeController::Settings settings;
488 settings.ApplyDualModeDefaults();
489 test_device()->set_settings(settings);
490 test_device()->SetDefaultResponseStatus(
491 hci_spec::kWriteExtendedInquiryResponse,
492 pw::bluetooth::emboss::StatusCode::CONNECTION_TERMINATED_BY_LOCAL_HOST);
493 ASSERT_TRUE(EnsureInitialized());
494
495 hci::Result<> result = fit::ok();
496 auto name_cb = [&result](const auto& status) { result = status; };
497
498 adapter()->SetLocalName(kNewName, name_cb);
499
500 RunUntilIdle();
501
502 // kWriteLocalName will succeed, but kWriteExtendedInquiryResponse will fail
503 EXPECT_EQ(ToResult(pw::bluetooth::emboss::StatusCode::
504 CONNECTION_TERMINATED_BY_LOCAL_HOST),
505 result);
506 // The |local_name_| should not be set.
507 EXPECT_NE(kNewName, adapter()->state().local_name);
508 EXPECT_NE(kNewName, adapter()->local_name());
509 }
510
TEST_F(AdapterTest,DefaultName)511 TEST_F(AdapterTest, DefaultName) {
512 FakeController::Settings settings;
513 settings.ApplyDualModeDefaults();
514 test_device()->set_settings(settings);
515
516 bool initialized = false;
517 InitializeAdapter([&](bool success) {
518 // Ensure that the local name has been written to the controller when
519 // initialization has completed.
520 EXPECT_TRUE(success);
521 EXPECT_EQ(kDefaultLocalName, test_device()->local_name());
522 EXPECT_EQ(kDefaultLocalName, adapter()->state().local_name);
523
524 initialized = true;
525 });
526
527 EXPECT_TRUE(initialized);
528 }
529
TEST_F(AdapterTest,PeerCacheReturnsNonNull)530 TEST_F(AdapterTest, PeerCacheReturnsNonNull) {
531 EXPECT_TRUE(adapter()->peer_cache());
532 }
533
TEST_F(AdapterTest,LeAutoConnect)534 TEST_F(AdapterTest, LeAutoConnect) {
535 constexpr pw::chrono::SystemClock::duration kTestScanPeriod =
536 std::chrono::seconds(10);
537 constexpr PeerId kPeerId(1234);
538
539 FakeController::Settings settings;
540 settings.ApplyLEOnlyDefaults();
541 test_device()->set_settings(settings);
542
543 InitializeAdapter([](bool) {});
544 adapter()->le()->set_scan_period_for_testing(kTestScanPeriod);
545
546 auto fake_peer =
547 std::make_unique<FakePeer>(kTestAddr, dispatcher(), true, false);
548 fake_peer->set_directed_advertising_enabled(true);
549 test_device()->AddPeer(std::move(fake_peer));
550
551 std::unique_ptr<bt::gap::LowEnergyConnectionHandle> conn;
552 adapter()->set_auto_connect_callback(
553 [&](auto conn_ref) { conn = std::move(conn_ref); });
554
555 // Enable background scanning. No auto-connect should take place since the
556 // device isn't yet bonded.
557 std::unique_ptr<LowEnergyDiscoverySession> session;
558 adapter()->le()->StartDiscovery(
559 /*active=*/false,
560 [&session](auto cb_session) { session = std::move(cb_session); });
561 RunUntilIdle();
562 EXPECT_FALSE(conn);
563 EXPECT_EQ(0u, adapter()->peer_cache()->count());
564
565 // Mark the peer as bonded and advance the scan period.
566 sm::PairingData pdata;
567 pdata.peer_ltk = sm::LTK();
568 pdata.local_ltk = sm::LTK();
569 adapter()->peer_cache()->AddBondedPeer(
570 BondingData{.identifier = kPeerId,
571 .address = kTestAddr,
572 .name = std::nullopt,
573 .le_pairing_data = pdata,
574 .bredr_link_key = std::nullopt,
575 .bredr_services = {}});
576 EXPECT_EQ(1u, adapter()->peer_cache()->count());
577
578 // FakeController only sends advertising reports at the start of scan periods,
579 // so we need to start a second period.
580 RunFor(kTestScanPeriod);
581
582 // The peer should have been auto-connected.
583 ASSERT_TRUE(conn);
584 EXPECT_EQ(kPeerId, conn->peer_identifier());
585 }
586
TEST_F(AdapterTest,LeSkipAutoConnectBehavior)587 TEST_F(AdapterTest, LeSkipAutoConnectBehavior) {
588 constexpr pw::chrono::SystemClock::duration kTestScanPeriod =
589 std::chrono::seconds(10);
590 constexpr PeerId kPeerId(1234);
591
592 FakeController::Settings settings;
593 settings.ApplyLEOnlyDefaults();
594 test_device()->set_settings(settings);
595
596 InitializeAdapter([](bool) {});
597 adapter()->le()->set_scan_period_for_testing(kTestScanPeriod);
598
599 auto fake_peer =
600 std::make_unique<FakePeer>(kTestAddr, dispatcher(), true, false);
601 fake_peer->set_directed_advertising_enabled(true);
602 test_device()->AddPeer(std::move(fake_peer));
603
604 std::unique_ptr<bt::gap::LowEnergyConnectionHandle> conn;
605 adapter()->set_auto_connect_callback(
606 [&](auto conn_ref) { conn = std::move(conn_ref); });
607
608 // Enable background scanning. No auto-connect should take place since the
609 // device isn't yet bonded.
610 std::unique_ptr<LowEnergyDiscoverySession> session;
611 adapter()->le()->StartDiscovery(
612 /*active=*/false,
613 [&session](auto cb_session) { session = std::move(cb_session); });
614 RunUntilIdle();
615 EXPECT_FALSE(conn);
616 EXPECT_EQ(0u, adapter()->peer_cache()->count());
617
618 // Mark the peer as bonded.
619 sm::PairingData pdata;
620 pdata.peer_ltk = sm::LTK();
621 pdata.local_ltk = sm::LTK();
622 adapter()->peer_cache()->AddBondedPeer(
623 BondingData{.identifier = kPeerId,
624 .address = kTestAddr,
625 .name = std::nullopt,
626 .le_pairing_data = pdata,
627 .bredr_link_key = std::nullopt,
628 .bredr_services = {}});
629 EXPECT_EQ(1u, adapter()->peer_cache()->count());
630
631 // Fake a manual disconnect to skip auto-connect behavior.
632 adapter()->peer_cache()->SetAutoConnectBehaviorForIntentionalDisconnect(
633 kPeerId);
634
635 // Advance the scan period.
636 RunFor(kTestScanPeriod);
637
638 // The peer should NOT have been auto-connected.
639 ASSERT_FALSE(conn);
640
641 // The peer should still not auto-connect after a subsequent scan period.
642 RunFor(kTestScanPeriod);
643 ASSERT_FALSE(conn);
644
645 // Fake a manual connection to reset auto-connect behavior.
646 adapter()->peer_cache()->SetAutoConnectBehaviorForSuccessfulConnection(
647 kPeerId);
648
649 // Advance the scan period.
650 RunFor(kTestScanPeriod);
651
652 // The peer SHOULD have been auto-connected.
653 ASSERT_TRUE(conn);
654 EXPECT_EQ(kPeerId, conn->peer_identifier());
655 }
656
657 // Tests the interactions between the advertising manager and the local address
658 // manager when the controller uses legacy advertising.
TEST_F(AdapterTest,LocalAddressForLegacyAdvertising)659 TEST_F(AdapterTest, LocalAddressForLegacyAdvertising) {
660 FakeController::Settings settings;
661 settings.ApplyLegacyLEConfig();
662 test_device()->set_settings(settings);
663 InitializeAdapter([](bool) {});
664
665 std::optional<AdvertisementInstance> instance;
666 auto adv_cb = [&](auto i, hci::Result<> status) {
667 instance = std::move(i);
668 EXPECT_EQ(fit::ok(), status);
669 };
670
671 // Advertising should use the public address by default when privacy is not
672 // enabled.
673 adapter()->le()->StartAdvertising(AdvertisingData(),
674 AdvertisingData(),
675 AdvertisingInterval::FAST1,
676 /*extended_pdu=*/false,
677 /*anonymous=*/false,
678 /*include_tx_power_level=*/false,
679 /*connectable=*/std::nullopt,
680 /*address_type=*/std::nullopt,
681 adv_cb);
682 RunUntilIdle();
683 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
684 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
685 test_device()->legacy_advertising_state().own_address_type);
686
687 // Enable privacy. The random address should not get configured while
688 // advertising is in progress.
689 adapter()->le()->EnablePrivacy(true);
690 RunUntilIdle();
691 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
692
693 // Stop advertising.
694 instance.reset();
695 RunUntilIdle();
696 EXPECT_FALSE(test_device()->legacy_advertising_state().enabled);
697 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
698
699 // Restart advertising. This should configure the LE random address and
700 // advertise using it.
701 adapter()->le()->StartAdvertising(AdvertisingData(),
702 AdvertisingData(),
703 AdvertisingInterval::FAST1,
704 /*extended_pdu=*/false,
705 /*anonymous=*/false,
706 /*include_tx_power_level=*/false,
707 /*connectable=*/std::nullopt,
708 /*address_type=*/std::nullopt,
709 adv_cb);
710 RunUntilIdle();
711 EXPECT_TRUE(test_device()->legacy_advertising_state().random_address);
712 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
713 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
714 test_device()->legacy_advertising_state().own_address_type);
715
716 // Advance time to force the random address to refresh. The update should be
717 // deferred while advertising.
718 auto last_random_addr =
719 *test_device()->legacy_advertising_state().random_address;
720 RunFor(kPrivateAddressTimeout);
721 EXPECT_EQ(last_random_addr,
722 *test_device()->legacy_advertising_state().random_address);
723
724 // Restarting advertising should refresh the controller address.
725 instance.reset();
726 adapter()->le()->StartAdvertising(AdvertisingData(),
727 AdvertisingData(),
728 AdvertisingInterval::FAST1,
729 /*extended_pdu=*/false,
730 /*anonymous=*/false,
731 /*include_tx_power_level=*/false,
732 /*connectable=*/std::nullopt,
733 /*address_type=*/std::nullopt,
734 adv_cb);
735 RunUntilIdle();
736 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
737 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
738 test_device()->legacy_advertising_state().own_address_type);
739 EXPECT_TRUE(test_device()->legacy_advertising_state().random_address);
740 EXPECT_NE(last_random_addr,
741 test_device()->legacy_advertising_state().random_address);
742
743 // Disable privacy. The next time advertising gets started it should use a
744 // public address.
745 adapter()->le()->EnablePrivacy(false);
746 instance.reset();
747 adapter()->le()->StartAdvertising(AdvertisingData(),
748 AdvertisingData(),
749 AdvertisingInterval::FAST1,
750 /*extended_pdu=*/false,
751 /*anonymous=*/false,
752 /*include_tx_power_level=*/false,
753 /*connectable=*/std::nullopt,
754 /*address_type=*/std::nullopt,
755 adv_cb);
756 RunUntilIdle();
757 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
758 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
759 test_device()->legacy_advertising_state().own_address_type);
760 }
761
762 // Tests the interactions between the discovery manager and the local address
763 // manager.
TEST_F(AdapterTest,LocalAddressForDiscovery)764 TEST_F(AdapterTest, LocalAddressForDiscovery) {
765 FakeController::Settings settings;
766 settings.ApplyLegacyLEConfig();
767 test_device()->set_settings(settings);
768 InitializeAdapter([](bool) {});
769
770 // Set a scan period that is longer than the private address timeout, for
771 // testing.
772 constexpr pw::chrono::SystemClock::duration kTestDelay =
773 std::chrono::seconds(5);
774 constexpr pw::chrono::SystemClock::duration kTestScanPeriod =
775 kPrivateAddressTimeout + kTestDelay;
776 adapter()->le()->set_scan_period_for_testing(kTestScanPeriod);
777
778 // Discovery should use the public address by default.
779 LowEnergyDiscoverySessionPtr session;
780 auto cb = [&](auto s) { session = std::move(s); };
781 adapter()->le()->StartDiscovery(/*active=*/true, cb);
782 RunUntilIdle();
783 ASSERT_TRUE(session);
784 EXPECT_TRUE(test_device()->le_scan_state().enabled);
785 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
786 test_device()->le_scan_state().own_address_type);
787
788 // Enable privacy. The random address should not get configured while a scan
789 // is in progress.
790 adapter()->le()->EnablePrivacy(true);
791 RunUntilIdle();
792 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
793
794 // Stop discovery.
795 session = nullptr;
796 RunUntilIdle();
797 EXPECT_FALSE(test_device()->le_scan_state().enabled);
798 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
799
800 // Restart discovery. This should configure the LE random address and scan
801 // using it.
802 adapter()->le()->StartDiscovery(/*active=*/true, cb);
803 RunUntilIdle();
804 ASSERT_TRUE(session);
805 EXPECT_TRUE(test_device()->le_scan_state().enabled);
806 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
807 test_device()->le_scan_state().own_address_type);
808
809 // Advance time to force the random address to refresh. The update should be
810 // deferred while still scanning.
811 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
812 auto last_random_addr =
813 *test_device()->legacy_advertising_state().random_address;
814 RunFor(kPrivateAddressTimeout);
815 EXPECT_EQ(last_random_addr,
816 *test_device()->legacy_advertising_state().random_address);
817
818 // Let the scan period expire. This should restart scanning and refresh the
819 // random address.
820 RunFor(kTestDelay);
821 EXPECT_TRUE(test_device()->le_scan_state().enabled);
822 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
823 test_device()->le_scan_state().own_address_type);
824 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
825 EXPECT_NE(last_random_addr,
826 test_device()->legacy_advertising_state().random_address);
827
828 // Disable privacy. The next time scanning gets started it should use a
829 // public address.
830 adapter()->le()->EnablePrivacy(false);
831 RunFor(kTestScanPeriod);
832 EXPECT_TRUE(test_device()->le_scan_state().enabled);
833 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
834 test_device()->le_scan_state().own_address_type);
835 }
836
TEST_F(AdapterTest,LocalAddressForConnections)837 TEST_F(AdapterTest, LocalAddressForConnections) {
838 FakeController::Settings settings;
839 settings.ApplyLegacyLEConfig();
840 test_device()->set_settings(settings);
841 InitializeAdapter([](bool) {});
842
843 // Set-up a device for testing.
844 auto* peer =
845 adapter()->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
846 auto fake_peer = std::make_unique<FakePeer>(kTestAddr, dispatcher());
847 test_device()->AddPeer(std::move(fake_peer));
848
849 std::unique_ptr<bt::gap::LowEnergyConnectionHandle> conn_ref;
850 auto connect_cb = [&conn_ref](auto result) {
851 ASSERT_EQ(fit::ok(), result);
852 conn_ref = std::move(result).value();
853 };
854
855 // A connection request should use the public address by default.
856 adapter()->le()->Connect(
857 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
858
859 // Enable privacy. The random address should not get configured while a
860 // connection attempt is in progress.
861 adapter()->le()->EnablePrivacy(true);
862 RunUntilIdle();
863 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
864 ASSERT_TRUE(conn_ref);
865 ASSERT_TRUE(test_device()->le_connect_params());
866 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
867 test_device()->le_connect_params()->own_address_type);
868
869 // Create a new connection. The second attempt should use a random address.
870 // re-enabled.
871 conn_ref = nullptr;
872 adapter()->le()->Connect(
873 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
874 RunUntilIdle();
875 EXPECT_TRUE(test_device()->legacy_advertising_state().random_address);
876 ASSERT_TRUE(conn_ref);
877 ASSERT_TRUE(test_device()->le_connect_params());
878
879 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
880 // address when initiating connections. Change this test to expect a random
881 // address once RPAs for central connections are re-enabled.
882 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
883 test_device()->le_connect_params()->own_address_type);
884
885 // Disable privacy. The next connection attempt should use a public address.
886 adapter()->le()->EnablePrivacy(false);
887 conn_ref = nullptr;
888 adapter()->le()->Connect(
889 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
890 RunUntilIdle();
891 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
892 test_device()->le_connect_params()->own_address_type);
893 }
894
895 // Tests the deferral of random address configuration while a connection request
896 // is outstanding.
TEST_F(AdapterTest,LocalAddressDuringHangingConnect)897 TEST_F(AdapterTest, LocalAddressDuringHangingConnect) {
898 FakeController::Settings settings;
899 settings.ApplyLegacyLEConfig();
900 test_device()->set_settings(settings);
901 InitializeAdapter([](bool) {});
902
903 auto* peer =
904 adapter()->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
905
906 // Cause scanning to succeed and the connection request to hang.
907 auto fake_peer = std::make_unique<FakePeer>(kTestAddr, dispatcher());
908 fake_peer->set_force_pending_connect(true);
909 test_device()->AddPeer(std::move(fake_peer));
910
911 constexpr pw::chrono::SystemClock::duration kTestDelay =
912 std::chrono::seconds(5);
913 constexpr pw::chrono::SystemClock::duration kTestTimeout =
914 kPrivateAddressTimeout + kTestDelay;
915
916 // Some of the behavior below stems from the fact that kTestTimeout is longer
917 // than kCacheTimeout. This assertion is here to catch regressions in this
918 // test if the values ever change.
919 // TODO: https://fxbug.dev/42087236 - Configuring the cache expiration timeout
920 // explicitly would remove some of the unnecessary invariants from this test
921 // case.
922 static_assert(kTestTimeout > kCacheTimeout,
923 "expected a shorter device cache timeout");
924
925 adapter()->le()->set_request_timeout_for_testing(kTestTimeout);
926
927 // The connection request should use a public address.
928 std::optional<HostError> error;
929 int connect_cb_calls = 0;
930 auto connect_cb = [&error, &connect_cb_calls](auto result) {
931 connect_cb_calls++;
932 ASSERT_TRUE(result.is_error());
933 error = result.error_value();
934 };
935 adapter()->le()->Connect(
936 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
937 RunUntilIdle();
938 ASSERT_TRUE(test_device()->le_connect_params());
939 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
940 test_device()->le_connect_params()->own_address_type);
941
942 // Enable privacy. The random address should not get configured while a
943 // connection request is outstanding.
944 adapter()->le()->EnablePrivacy(true);
945 RunUntilIdle();
946 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
947
948 // Let the connection request timeout.
949 RunFor(kTestTimeout);
950 ASSERT_TRUE(error.has_value());
951 EXPECT_EQ(HostError::kTimedOut, error.value())
952 << "Error: " << HostErrorToString(error.value());
953 EXPECT_EQ(1, connect_cb_calls);
954
955 // The peer should not have expired.
956 ASSERT_EQ(peer, adapter()->peer_cache()->FindByAddress(kTestAddr));
957 adapter()->le()->Connect(
958 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
959 RunUntilIdle();
960 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
961 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
962 // address when initiating connections. Change this test to expect a random
963 // address once RPAs for central connections are re-enabled.
964 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
965 test_device()->le_connect_params()->own_address_type);
966
967 // Advance the time to cause the random address to refresh. The update should
968 // be deferred while a connection request is outstanding.
969 auto last_random_addr =
970 *test_device()->legacy_advertising_state().random_address;
971 RunFor(kPrivateAddressTimeout);
972 EXPECT_EQ(last_random_addr,
973 *test_device()->legacy_advertising_state().random_address);
974
975 ASSERT_EQ(peer, adapter()->peer_cache()->FindByAddress(kTestAddr));
976
977 // The address should refresh after the pending request expires and before the
978 // next connection attempt.
979 RunFor(kTestDelay);
980 ASSERT_EQ(2, connect_cb_calls);
981
982 // This will be notified when LowEnergyConnectionManager is destroyed.
983 auto noop_connect_cb = [](auto) {};
984 adapter()->le()->Connect(peer->identifier(),
985 std::move(noop_connect_cb),
986 LowEnergyConnectionOptions());
987 RunUntilIdle();
988 EXPECT_NE(last_random_addr,
989 *test_device()->legacy_advertising_state().random_address);
990 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
991 // address when initiating connections. Change this test to expect a random
992 // address once RPAs for central connections are re-enabled.
993 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
994 test_device()->le_connect_params()->own_address_type);
995 }
996
997 // Tests that existing connections don't prevent an address change.
TEST_F(AdapterTest,ExistingConnectionDoesNotPreventLocalAddressChange)998 TEST_F(AdapterTest, ExistingConnectionDoesNotPreventLocalAddressChange) {
999 FakeController::Settings settings;
1000 settings.ApplyLegacyLEConfig();
1001 test_device()->set_settings(settings);
1002 InitializeAdapter([](bool) {});
1003
1004 adapter()->le()->EnablePrivacy(true);
1005
1006 std::unique_ptr<bt::gap::LowEnergyConnectionHandle> conn_ref;
1007 auto connect_cb = [&](auto result) {
1008 ASSERT_EQ(fit::ok(), result);
1009 conn_ref = std::move(result).value();
1010 ASSERT_TRUE(conn_ref);
1011 };
1012
1013 auto* peer =
1014 adapter()->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
1015 auto fake_peer = std::make_unique<FakePeer>(kTestAddr, dispatcher());
1016 test_device()->AddPeer(std::move(fake_peer));
1017 adapter()->le()->Connect(
1018 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
1019 RunUntilIdle();
1020 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
1021 // address when initiating connections. Change this test to expect a random
1022 // address once RPAs for central connections are re-enabled.
1023 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
1024 test_device()->le_connect_params()->own_address_type);
1025
1026 // Expire the private address. The address should refresh without interference
1027 // from the ongoing connection.
1028 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
1029 auto last_random_addr =
1030 *test_device()->legacy_advertising_state().random_address;
1031 RunFor(kPrivateAddressTimeout);
1032 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
1033 EXPECT_NE(last_random_addr,
1034 *test_device()->legacy_advertising_state().random_address);
1035 }
1036
TEST_F(AdapterTest,IsDiscoverableLowEnergy)1037 TEST_F(AdapterTest, IsDiscoverableLowEnergy) {
1038 FakeController::Settings settings;
1039 settings.ApplyLegacyLEConfig();
1040 test_device()->set_settings(settings);
1041 InitializeAdapter([](bool) {});
1042
1043 EXPECT_FALSE(adapter()->IsDiscoverable());
1044
1045 AdvertisementInstance instance;
1046 adapter()->le()->StartAdvertising(AdvertisingData(),
1047 AdvertisingData(),
1048 AdvertisingInterval::FAST1,
1049 /*extended_pdu=*/false,
1050 /*anonymous=*/false,
1051 /*include_tx_power_level=*/false,
1052 /*connectable=*/std::nullopt,
1053 /*address_type=*/std::nullopt,
1054 [&](AdvertisementInstance i, auto status) {
1055 ASSERT_EQ(fit::ok(), status);
1056 instance = std::move(i);
1057 });
1058 RunUntilIdle();
1059 EXPECT_TRUE(adapter()->IsDiscoverable());
1060
1061 instance = {};
1062 RunUntilIdle();
1063 EXPECT_FALSE(adapter()->IsDiscoverable());
1064 }
1065
TEST_F(AdapterTest,IsDiscoverableBredr)1066 TEST_F(AdapterTest, IsDiscoverableBredr) {
1067 FakeController::Settings settings;
1068 settings.ApplyDualModeDefaults();
1069 test_device()->set_settings(settings);
1070 InitializeAdapter([](bool) {});
1071
1072 EXPECT_FALSE(adapter()->IsDiscoverable());
1073
1074 std::unique_ptr<BrEdrDiscoverableSession> session;
1075 adapter()->bredr()->RequestDiscoverable(
1076 [&](auto, auto s) { session = std::move(s); });
1077 RunUntilIdle();
1078 EXPECT_TRUE(adapter()->IsDiscoverable());
1079
1080 session = nullptr;
1081 RunUntilIdle();
1082 EXPECT_FALSE(adapter()->IsDiscoverable());
1083 }
1084
TEST_F(AdapterTest,IsDiscoverableLowEnergyPrivacyEnabled)1085 TEST_F(AdapterTest, IsDiscoverableLowEnergyPrivacyEnabled) {
1086 FakeController::Settings settings;
1087 settings.ApplyLegacyLEConfig();
1088 test_device()->set_settings(settings);
1089 InitializeAdapter([](bool) {});
1090
1091 EXPECT_FALSE(adapter()->IsDiscoverable());
1092 adapter()->le()->EnablePrivacy(true);
1093 EXPECT_FALSE(adapter()->IsDiscoverable());
1094
1095 AdvertisementInstance instance;
1096 adapter()->le()->StartAdvertising(AdvertisingData(),
1097 AdvertisingData(),
1098 AdvertisingInterval::FAST1,
1099 /*extended_pdu=*/false,
1100 /*anonymous=*/false,
1101 /*include_tx_power_level=*/false,
1102 /*connectable=*/std::nullopt,
1103 /*address_type=*/std::nullopt,
1104 [&](AdvertisementInstance i, auto status) {
1105 ASSERT_EQ(fit::ok(), status);
1106 instance = std::move(i);
1107 });
1108 RunUntilIdle();
1109 // Even though we are advertising over LE, we are not discoverable since
1110 // Privacy is enabled.
1111 EXPECT_FALSE(adapter()->IsDiscoverable());
1112
1113 instance = {};
1114 RunUntilIdle();
1115 EXPECT_FALSE(adapter()->IsDiscoverable());
1116 }
1117
1118 #ifndef NINSPECT
TEST_F(AdapterTest,InspectHierarchy)1119 TEST_F(AdapterTest, InspectHierarchy) {
1120 inspect::Inspector inspector;
1121 auto bt_host_node = inspector.GetRoot().CreateChild("bt-host");
1122 adapter()->AttachInspect(bt_host_node, "adapter");
1123
1124 bool success;
1125 int init_cb_count = 0;
1126 auto init_cb = [&](bool cb_success) {
1127 success = cb_success;
1128 init_cb_count++;
1129 };
1130
1131 // Return valid buffer information and enable LE support. (This should
1132 // succeed).
1133 FakeController::Settings settings;
1134 settings.AddBREDRSupportedCommands();
1135 settings.lmp_features_page0 |=
1136 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1137 settings.le_acl_data_packet_length = 0x1B;
1138 settings.le_total_num_acl_data_packets = 1;
1139 settings.synchronous_data_packet_length = 6;
1140 settings.total_num_synchronous_data_packets = 2;
1141 test_device()->set_settings(settings);
1142
1143 InitializeAdapter(std::move(init_cb));
1144 EXPECT_TRUE(success);
1145
1146 auto le_connection_manager_matcher =
1147 NodeMatches(NameMatches("low_energy_connection_manager"));
1148 auto bredr_connection_manager_matcher =
1149 NodeMatches(NameMatches("bredr_connection_manager"));
1150 auto peer_cache_matcher =
1151 NodeMatches(NameMatches(PeerCache::kInspectNodeName));
1152 auto sdp_server_matcher =
1153 NodeMatches(NameMatches(sdp::Server::kInspectNodeName));
1154 auto acl_data_channel_matcher =
1155 NodeMatches(NameMatches(hci::AclDataChannel::kInspectNodeName));
1156 auto le_matcher =
1157 AllOf(NodeMatches(AllOf(NameMatches("le"),
1158 PropertyList(UnorderedElementsAre(
1159 UintIs("outgoing_connection_requests", 0),
1160 UintIs("pair_requests", 0),
1161 UintIs("start_advertising_events", 0),
1162 UintIs("stop_advertising_events", 0),
1163 UintIs("start_discovery_events", 0))))));
1164 auto bredr_matcher =
1165 AllOf(NodeMatches(AllOf(NameMatches("bredr"),
1166 PropertyList(UnorderedElementsAre(
1167 UintIs("outgoing_connection_requests", 0),
1168 UintIs("pair_requests", 0),
1169 UintIs("set_connectable_true_events", 0),
1170 UintIs("set_connectable_false_events", 0),
1171 UintIs("open_l2cap_channel_requests", 0))))));
1172 auto metrics_node_matcher =
1173 AllOf(NodeMatches(NameMatches(Adapter::kMetricsInspectNodeName)),
1174 ChildrenMatch(UnorderedElementsAre(bredr_matcher, le_matcher)));
1175 auto le_discovery_manager_matcher =
1176 NodeMatches(NameMatches("low_energy_discovery_manager"));
1177 auto bredr_discovery_manager_matcher =
1178 NodeMatches(NameMatches("bredr_discovery_manager"));
1179 auto hci_matcher = NodeMatches(NameMatches(hci::Transport::kInspectNodeName));
1180
1181 auto adapter_matcher = AllOf(
1182 NodeMatches(AllOf(
1183 NameMatches("adapter"),
1184 PropertyList(UnorderedElementsAre(
1185 StringIs("adapter_id", adapter()->identifier().ToString()),
1186 StringIs(
1187 "hci_version",
1188 hci_spec::HCIVersionToString(adapter()->state().hci_version)),
1189 UintIs(
1190 "bredr_max_num_packets",
1191 adapter()->state().bredr_data_buffer_info.max_num_packets()),
1192 UintIs(
1193 "bredr_max_data_length",
1194 adapter()->state().bredr_data_buffer_info.max_data_length()),
1195 UintIs("le_max_num_packets",
1196 adapter()
1197 ->state()
1198 .low_energy_state.acl_data_buffer_info()
1199 .max_num_packets()),
1200 UintIs("le_max_data_length",
1201 adapter()
1202 ->state()
1203 .low_energy_state.acl_data_buffer_info()
1204 .max_data_length()),
1205 UintIs("sco_max_num_packets",
1206 adapter()->state().sco_buffer_info.max_num_packets()),
1207 UintIs("sco_max_data_length",
1208 adapter()->state().sco_buffer_info.max_data_length()),
1209 StringIs("lmp_features", adapter()->state().features.ToString()),
1210 StringIs("le_features",
1211 bt_lib_cpp_string::StringPrintf(
1212 "0x%016lx",
1213 adapter()
1214 ->state()
1215 .low_energy_state.supported_features())))))),
1216 ChildrenMatch(UnorderedElementsAre(peer_cache_matcher,
1217 sdp_server_matcher,
1218 le_connection_manager_matcher,
1219 bredr_connection_manager_matcher,
1220 le_discovery_manager_matcher,
1221 metrics_node_matcher,
1222 bredr_discovery_manager_matcher,
1223 hci_matcher)));
1224
1225 auto bt_host_matcher =
1226 AllOf(NodeMatches(NameMatches("bt-host")),
1227 ChildrenMatch(UnorderedElementsAre(adapter_matcher)));
1228 auto hierarchy = inspect::ReadFromVmo(inspector.DuplicateVmo()).take_value();
1229
1230 EXPECT_THAT(hierarchy,
1231 AllOf(NodeMatches(NameMatches("root")),
1232 ChildrenMatch(UnorderedElementsAre(bt_host_matcher))));
1233 }
1234 #endif // NINSPECT
1235
TEST_F(AdapterTest,VendorFeatures)1236 TEST_F(AdapterTest, VendorFeatures) {
1237 FakeController::Settings settings;
1238 settings.ApplyDualModeDefaults();
1239 test_device()->set_settings(settings);
1240
1241 bool success = false;
1242 auto init_cb = [&](bool cb_success) { success = cb_success; };
1243 InitializeAdapter(std::move(init_cb));
1244 EXPECT_TRUE(success);
1245 EXPECT_EQ(adapter()->state().controller_features, kDefaultFeaturesBits);
1246 }
1247
TEST_F(AdapterTest,LowEnergyStartAdvertisingConnectCallbackReceivesConnection)1248 TEST_F(AdapterTest,
1249 LowEnergyStartAdvertisingConnectCallbackReceivesConnection) {
1250 FakeController::Settings settings;
1251 settings.ApplyLegacyLEConfig();
1252 test_device()->set_settings(settings);
1253 InitializeAdapter([](bool) {});
1254
1255 AdvertisementInstance instance;
1256 auto adv_cb = [&](auto i, hci::Result<> status) {
1257 instance = std::move(i);
1258 EXPECT_EQ(fit::ok(), status);
1259 };
1260
1261 std::optional<Adapter::LowEnergy::ConnectionResult> conn_result;
1262 std::optional<AdvertisementId> conn_cb_advertisement_id;
1263 Adapter::LowEnergy::ConnectionCallback connect_cb =
1264 [&](AdvertisementId adv_id, Adapter::LowEnergy::ConnectionResult result) {
1265 conn_result = std::move(result);
1266 conn_cb_advertisement_id = adv_id;
1267 };
1268
1269 adapter()->le()->StartAdvertising(
1270 AdvertisingData(),
1271 AdvertisingData(),
1272 AdvertisingInterval::FAST1,
1273 /*extended_pdu=*/false,
1274 /*anonymous=*/false,
1275 /*include_tx_power_level=*/false,
1276 bt::gap::Adapter::LowEnergy::ConnectableAdvertisingParameters{
1277 .connection_cb = std::move(connect_cb),
1278 .bondable_mode = sm::BondableMode::NonBondable},
1279 /*address_type=*/std::nullopt,
1280 adv_cb);
1281 RunUntilIdle();
1282 EXPECT_FALSE(conn_result);
1283
1284 fit::closure complete_interrogation;
1285 // Pause interrogation so we can control when the inbound connection procedure
1286 // completes.
1287 test_device()->pause_responses_for_opcode(
1288 bt::hci_spec::kReadRemoteVersionInfo, [&](fit::closure trigger) {
1289 complete_interrogation = std::move(trigger);
1290 });
1291
1292 test_device()->AddPeer(std::make_unique<FakePeer>(kTestAddr, dispatcher()));
1293 test_device()->ConnectLowEnergy(kTestAddr);
1294 RunUntilIdle();
1295 ASSERT_FALSE(conn_result);
1296 ASSERT_TRUE(complete_interrogation);
1297
1298 complete_interrogation();
1299 RunUntilIdle();
1300 ASSERT_TRUE(conn_result);
1301 ASSERT_EQ(fit::ok(), *conn_result);
1302 std::unique_ptr<LowEnergyConnectionHandle> conn_handle =
1303 std::move(*conn_result).value();
1304 ASSERT_TRUE(conn_handle);
1305 EXPECT_EQ(conn_handle->bondable_mode(), sm::BondableMode::NonBondable);
1306 EXPECT_EQ(*conn_cb_advertisement_id, instance.id());
1307 conn_result.reset();
1308 }
1309
1310 // Tests where the constructor must run in the test, rather than Setup.
1311
1312 class AdapterConstructorTest : public TestingBase {
1313 public:
1314 AdapterConstructorTest() = default;
1315 ~AdapterConstructorTest() override = default;
1316
SetUp()1317 void SetUp() override {
1318 TestingBase::SetUp();
1319
1320 l2cap_ = std::make_unique<l2cap::testing::FakeL2cap>(dispatcher());
1321 gatt_ = std::make_unique<gatt::testing::FakeLayer>(dispatcher());
1322 }
1323
TearDown()1324 void TearDown() override {
1325 l2cap_ = nullptr;
1326 gatt_ = nullptr;
1327 TestingBase::TearDown();
1328 }
1329
1330 protected:
1331 std::unique_ptr<l2cap::testing::FakeL2cap> l2cap_;
1332 std::unique_ptr<gatt::testing::FakeLayer> gatt_;
1333 };
1334
1335 using GAP_AdapterConstructorTest = AdapterConstructorTest;
1336
TEST_F(AdapterConstructorTest,GattCallbacks)1337 TEST_F(AdapterConstructorTest, GattCallbacks) {
1338 constexpr PeerId kPeerId(1234);
1339 constexpr gatt::ServiceChangedCCCPersistedData kPersistedData = {
1340 .notify = true, .indicate = true};
1341
1342 int set_persist_cb_count = 0;
1343 int set_retrieve_cb_count = 0;
1344
1345 auto set_persist_cb_cb = [&set_persist_cb_count]() {
1346 set_persist_cb_count++;
1347 };
1348
1349 auto set_retrieve_cb_cb = [&set_retrieve_cb_count]() {
1350 set_retrieve_cb_count++;
1351 };
1352
1353 gatt_->SetSetPersistServiceChangedCCCCallbackCallback(set_persist_cb_cb);
1354 gatt_->SetSetRetrieveServiceChangedCCCCallbackCallback(set_retrieve_cb_cb);
1355
1356 EXPECT_EQ(set_persist_cb_count, 0);
1357 EXPECT_EQ(set_retrieve_cb_count, 0);
1358
1359 Adapter::Config config = {
1360 .legacy_pairing_enabled = false,
1361 };
1362 auto adapter = Adapter::Create(dispatcher(),
1363 transport()->GetWeakPtr(),
1364 gatt_->GetWeakPtr(),
1365 config,
1366 std::move(l2cap_));
1367
1368 EXPECT_EQ(set_persist_cb_count, 1);
1369 EXPECT_EQ(set_retrieve_cb_count, 1);
1370
1371 // Before the peer exists, adding its gatt info to the peer cache does
1372 // nothing.
1373 gatt_->CallPersistServiceChangedCCCCallback(
1374 kPeerId, /*notify=*/true, /*indicate=*/false);
1375 auto persisted_data_1 = gatt_->CallRetrieveServiceChangedCCCCallback(kPeerId);
1376 EXPECT_EQ(persisted_data_1, std::nullopt);
1377
1378 // After adding a classic peer, adding its info to the peer cache still does
1379 // nothing.
1380 Peer* classic_peer =
1381 adapter->peer_cache()->NewPeer(kTestAddrBrEdr, /*connectable=*/true);
1382 PeerId classic_peer_id = classic_peer->identifier();
1383
1384 gatt_->CallPersistServiceChangedCCCCallback(
1385 classic_peer_id, /*notify=*/false, /*indicate=*/true);
1386 auto persisted_data_2 =
1387 gatt_->CallRetrieveServiceChangedCCCCallback(classic_peer_id);
1388 EXPECT_EQ(persisted_data_2, std::nullopt);
1389
1390 // After adding an LE peer, adding its info to the peer cache works.
1391 Peer* le_peer =
1392 adapter->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
1393 PeerId le_peer_id = le_peer->identifier();
1394
1395 gatt_->CallPersistServiceChangedCCCCallback(
1396 le_peer_id, /*notify=*/true, /*indicate=*/true);
1397 auto persisted_data_3 =
1398 gatt_->CallRetrieveServiceChangedCCCCallback(le_peer_id);
1399 ASSERT_TRUE(persisted_data_3.has_value());
1400 auto persisted_data_3_value = persisted_data_3.value();
1401 EXPECT_EQ(persisted_data_3_value, kPersistedData);
1402
1403 // After the peer is removed, the gatt info is no longer in the peer cache.
1404 bool result = adapter->peer_cache()->RemoveDisconnectedPeer(le_peer_id);
1405 EXPECT_TRUE(result);
1406
1407 auto persisted_data_4 =
1408 gatt_->CallRetrieveServiceChangedCCCCallback(le_peer_id);
1409 EXPECT_EQ(persisted_data_4, std::nullopt);
1410 }
1411
TEST_F(AdapterTest,BufferSizesRecordedInState)1412 TEST_F(AdapterTest, BufferSizesRecordedInState) {
1413 bool success = false;
1414 auto init_cb = [&](bool cb_success) { success = cb_success; };
1415
1416 FakeController::Settings settings;
1417 // Enable ReadBuffer commands.
1418 settings.AddBREDRSupportedCommands();
1419 settings.AddLESupportedCommands();
1420 settings.lmp_features_page0 |=
1421 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1422
1423 // Minimum supported size as per Core Spec v5.4, Vol 4, Part E, 7.8.2
1424 settings.le_acl_data_packet_length = 0x1B;
1425
1426 settings.le_total_num_acl_data_packets = 2;
1427 settings.acl_data_packet_length = 3;
1428 settings.total_num_acl_data_packets = 4;
1429 settings.synchronous_data_packet_length = 5;
1430 settings.total_num_synchronous_data_packets = 6;
1431 settings.iso_data_packet_length = 7;
1432 settings.total_num_iso_data_packets = 8;
1433 test_device()->set_settings(settings);
1434
1435 InitializeAdapter(std::move(init_cb));
1436 EXPECT_TRUE(success);
1437 EXPECT_EQ(adapter()
1438 ->state()
1439 .low_energy_state.acl_data_buffer_info()
1440 .max_data_length(),
1441 (uint16_t)0x1B);
1442 EXPECT_EQ(adapter()
1443 ->state()
1444 .low_energy_state.acl_data_buffer_info()
1445 .max_num_packets(),
1446 2u);
1447 EXPECT_EQ(adapter()->state().bredr_data_buffer_info.max_data_length(), 3u);
1448 EXPECT_EQ(adapter()->state().bredr_data_buffer_info.max_num_packets(), 4u);
1449 EXPECT_EQ(adapter()->state().sco_buffer_info.max_data_length(), 5u);
1450 EXPECT_EQ(adapter()->state().sco_buffer_info.max_num_packets(), 6u);
1451 EXPECT_EQ(adapter()
1452 ->state()
1453 .low_energy_state.iso_data_buffer_info()
1454 .max_data_length(),
1455 7u);
1456 EXPECT_EQ(adapter()
1457 ->state()
1458 .low_energy_state.iso_data_buffer_info()
1459 .max_num_packets(),
1460 8u);
1461 }
1462
TEST_F(AdapterTest,LEReadMaximumAdvertisingDataLengthNotSupported)1463 TEST_F(AdapterTest, LEReadMaximumAdvertisingDataLengthNotSupported) {
1464 FakeController::Settings settings;
1465 settings.AddBREDRSupportedCommands();
1466 settings.AddLESupportedCommands();
1467 settings.lmp_features_page0 |=
1468 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1469 settings.le_acl_data_packet_length = 0x1B;
1470 settings.le_total_num_acl_data_packets = 2;
1471 test_device()->set_settings(settings);
1472
1473 const LowEnergyState& low_energy_state = adapter()->state().low_energy_state;
1474 bool success = false;
1475 auto init_cb = [&](bool cb_success) { success = cb_success; };
1476 InitializeAdapter(std::move(init_cb));
1477 EXPECT_TRUE(success);
1478 EXPECT_EQ(hci_spec::kMaxLEAdvertisingDataLength,
1479 low_energy_state.max_advertising_data_length());
1480 }
1481
TEST_F(AdapterTest,LEReadMaximumAdvertisingDataLengthSupported)1482 TEST_F(AdapterTest, LEReadMaximumAdvertisingDataLengthSupported) {
1483 FakeController::Settings settings;
1484 settings.AddBREDRSupportedCommands();
1485 settings.AddLESupportedCommands();
1486 settings.lmp_features_page0 |=
1487 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1488 settings.le_acl_data_packet_length = 0x1B;
1489 settings.le_total_num_acl_data_packets = 2;
1490 settings.SupportedCommandsView()
1491 .le_read_maximum_advertising_data_length()
1492 .Write(true);
1493
1494 test_device()->set_settings(settings);
1495 test_device()->set_maximum_advertising_data_length(
1496 hci_spec::kMaxLEExtendedAdvertisingDataLength);
1497
1498 const LowEnergyState& low_energy_state = adapter()->state().low_energy_state;
1499 bool success = false;
1500 auto init_cb = [&](bool cb_success) { success = cb_success; };
1501 InitializeAdapter(std::move(init_cb));
1502 EXPECT_TRUE(success);
1503 EXPECT_EQ(hci_spec::kMaxLEExtendedAdvertisingDataLength,
1504 low_energy_state.max_advertising_data_length());
1505 }
1506
TEST_F(AdapterTest,LEConnectedIsochronousStreamSupported)1507 TEST_F(AdapterTest, LEConnectedIsochronousStreamSupported) {
1508 FakeController::Settings settings;
1509 settings.AddBREDRSupportedCommands();
1510 settings.AddLESupportedCommands();
1511 settings.lmp_features_page0 |=
1512 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1513 settings.le_features |= static_cast<uint64_t>(
1514 hci_spec::LESupportedFeature::kConnectedIsochronousStreamPeripheral);
1515 settings.le_acl_data_packet_length = 0x1B;
1516 settings.le_total_num_acl_data_packets = 2;
1517
1518 test_device()->set_settings(settings);
1519
1520 bool success = false;
1521 auto init_cb = [&](bool cb_success) { success = cb_success; };
1522 InitializeAdapter(std::move(init_cb));
1523 EXPECT_TRUE(success);
1524 const auto& le_features = test_device()->le_features();
1525 EXPECT_TRUE(
1526 (le_features.le_features &
1527 static_cast<uint64_t>(hci_spec::LESupportedFeature::
1528 kConnectedIsochronousStreamHostSupport)) != 0);
1529 }
1530
TEST_F(AdapterTest,ScoDataChannelInitializedSuccessfully)1531 TEST_F(AdapterTest, ScoDataChannelInitializedSuccessfully) {
1532 // Return valid buffer information and enable LE support.
1533 FakeController::Settings settings;
1534 settings.AddBREDRSupportedCommands();
1535 settings.lmp_features_page0 |=
1536 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1537 settings.le_acl_data_packet_length = 0x1B;
1538 settings.le_total_num_acl_data_packets = 1;
1539 // Ensure SCO buffers are available.
1540 settings.synchronous_data_packet_length = 6;
1541 settings.total_num_synchronous_data_packets = 2;
1542 // Enable SCO flow control command.
1543 settings.SupportedCommandsView()
1544 .write_synchronous_flow_control_enable()
1545 .Write(true);
1546 test_device()->set_settings(settings);
1547
1548 bool success = false;
1549 auto init_cb = [&](bool cb_success) { success = cb_success; };
1550 InitializeAdapter(std::move(init_cb));
1551 EXPECT_TRUE(success);
1552 EXPECT_TRUE(transport()->sco_data_channel());
1553 }
1554
TEST_F(AdapterTest,ScoDataChannelNotInitializedBecauseFlowControlNotSupported)1555 TEST_F(AdapterTest,
1556 ScoDataChannelNotInitializedBecauseFlowControlNotSupported) {
1557 // Return valid buffer information and enable LE support.
1558 FakeController::Settings settings;
1559 settings.AddBREDRSupportedCommands();
1560 settings.lmp_features_page0 |=
1561 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1562 settings.SupportedCommandsView()
1563 .write_synchronous_flow_control_enable()
1564 .Write(false);
1565 settings.le_acl_data_packet_length = 0x1B;
1566 settings.le_total_num_acl_data_packets = 1;
1567 // Ensure SCO buffers are available.
1568 settings.synchronous_data_packet_length = 6;
1569 settings.total_num_synchronous_data_packets = 2;
1570 test_device()->set_settings(settings);
1571
1572 bool success = false;
1573 auto init_cb = [&](bool cb_success) { success = cb_success; };
1574 InitializeAdapter(std::move(init_cb));
1575 EXPECT_TRUE(success);
1576 EXPECT_FALSE(transport()->sco_data_channel());
1577 }
1578
TEST_F(AdapterTest,ScoDataChannelNotInitializedBecauseBufferInfoNotAvailable)1579 TEST_F(AdapterTest, ScoDataChannelNotInitializedBecauseBufferInfoNotAvailable) {
1580 // Return valid buffer information and enable LE support.
1581 FakeController::Settings settings;
1582 settings.AddBREDRSupportedCommands();
1583 settings.lmp_features_page0 |=
1584 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1585 settings.le_acl_data_packet_length = 0x1B;
1586 settings.le_total_num_acl_data_packets = 1;
1587 // Ensure SCO buffers are not available.
1588 settings.synchronous_data_packet_length = 1;
1589 settings.total_num_synchronous_data_packets = 0;
1590 // Enable SCO flow control command.
1591 settings.SupportedCommandsView()
1592 .write_synchronous_flow_control_enable()
1593 .Write(true);
1594 test_device()->set_settings(settings);
1595
1596 bool success = false;
1597 auto init_cb = [&](bool cb_success) { success = cb_success; };
1598 InitializeAdapter(std::move(init_cb));
1599 EXPECT_TRUE(success);
1600 EXPECT_FALSE(transport()->sco_data_channel());
1601 }
1602
TEST_F(AdapterScoAndIsoDisabledTest,ScoDataChannelFailsToInitializeBecauseScoDisabled)1603 TEST_F(AdapterScoAndIsoDisabledTest,
1604 ScoDataChannelFailsToInitializeBecauseScoDisabled) {
1605 // Return valid buffer information and enable LE support.
1606 FakeController::Settings settings;
1607 settings.AddBREDRSupportedCommands();
1608 settings.lmp_features_page0 |=
1609 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1610 settings.le_acl_data_packet_length = 0x1B;
1611 settings.le_total_num_acl_data_packets = 1;
1612 // Ensure SCO buffers are available.
1613 settings.synchronous_data_packet_length = 6;
1614 settings.total_num_synchronous_data_packets = 2;
1615 // Enable SCO flow control command.
1616 settings.SupportedCommandsView()
1617 .write_synchronous_flow_control_enable()
1618 .Write(true);
1619 test_device()->set_settings(settings);
1620
1621 bool success = false;
1622 auto init_cb = [&](bool cb_success) { success = cb_success; };
1623 InitializeAdapter(std::move(init_cb));
1624 EXPECT_TRUE(success);
1625 EXPECT_FALSE(transport()->sco_data_channel());
1626 }
1627
TEST_F(AdapterTest,IsoDataChannelInitializedSuccessfully)1628 TEST_F(AdapterTest, IsoDataChannelInitializedSuccessfully) {
1629 FakeController::Settings settings;
1630 settings.ApplyDualModeDefaults();
1631 test_device()->set_settings(settings);
1632
1633 bool success = false;
1634 auto init_cb = [&](bool cb_success) { success = cb_success; };
1635 InitializeAdapter(std::move(init_cb));
1636 EXPECT_TRUE(success);
1637 EXPECT_TRUE(transport()->iso_data_channel());
1638 }
1639
TEST_F(AdapterTest,IsoDataChannelNotInitializedNoBufferData)1640 TEST_F(AdapterTest, IsoDataChannelNotInitializedNoBufferData) {
1641 FakeController::Settings settings;
1642 settings.ApplyDualModeDefaults();
1643 settings.iso_data_packet_length = 0;
1644 settings.total_num_iso_data_packets = 0;
1645 test_device()->set_settings(settings);
1646
1647 bool success = false;
1648 auto init_cb = [&](bool cb_success) { success = cb_success; };
1649 InitializeAdapter(std::move(init_cb));
1650 EXPECT_TRUE(success);
1651 EXPECT_FALSE(transport()->iso_data_channel());
1652 }
1653
TEST_F(AdapterScoAndIsoDisabledTest,IsoDataChannelNoControllerSupport)1654 TEST_F(AdapterScoAndIsoDisabledTest, IsoDataChannelNoControllerSupport) {
1655 FakeController::Settings settings;
1656 settings.ApplyDualModeDefaults();
1657 test_device()->set_settings(settings);
1658
1659 bool success = false;
1660 auto init_cb = [&](bool cb_success) { success = cb_success; };
1661 InitializeAdapter(std::move(init_cb));
1662 EXPECT_TRUE(success);
1663 EXPECT_FALSE(transport()->iso_data_channel());
1664 }
1665
TEST_F(AdapterTest,InitializeWriteSecureConnectionsHostSupport)1666 TEST_F(AdapterTest, InitializeWriteSecureConnectionsHostSupport) {
1667 bool success;
1668 int init_cb_count = 0;
1669 auto init_cb = [&](bool cb_success) {
1670 success = cb_success;
1671 init_cb_count++;
1672 };
1673
1674 // Enable LE support and extended features (Secure Connections Host Support)
1675 FakeController::Settings settings;
1676 settings.lmp_features_page0 |=
1677 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1678 settings.lmp_features_page0 |=
1679 static_cast<uint64_t>(hci_spec::LMPFeature::kExtendedFeatures);
1680 settings.lmp_features_page1 |= static_cast<uint64_t>(
1681 hci_spec::LMPFeature::kSecureConnectionsHostSupport);
1682 settings.le_acl_data_packet_length = 0x1B;
1683 settings.le_total_num_acl_data_packets = 1;
1684 test_device()->set_settings(settings);
1685
1686 InitializeAdapter(std::move(init_cb));
1687 EXPECT_TRUE(success);
1688 EXPECT_EQ(1, init_cb_count);
1689 EXPECT_TRUE(adapter()->state().IsLowEnergySupported());
1690 EXPECT_TRUE(adapter()->state().IsBREDRSupported());
1691 EXPECT_TRUE(adapter()->state().IsSecureConnectionHostSupportSupported());
1692 EXPECT_TRUE(adapter()->le());
1693 EXPECT_TRUE(adapter()->bredr());
1694 EXPECT_EQ(TechnologyType::kDualMode, adapter()->state().type());
1695 EXPECT_FALSE(transport_closed_called());
1696 }
1697
GetSupportedDelayRangeHelper(bool supported,const std::optional<std::vector<uint8_t>> & codec_config)1698 void AdapterTest::GetSupportedDelayRangeHelper(
1699 bool supported, const std::optional<std::vector<uint8_t>>& codec_config) {
1700 FakeController::Settings settings;
1701
1702 // Define minimum required settings for an LE controller
1703 settings.lmp_features_page0 |=
1704 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1705 settings.le_acl_data_packet_length = 0x1B;
1706 settings.le_total_num_acl_data_packets = 1;
1707
1708 // Enable or disable the "Read Local Supported Controller Delay" command
1709 settings.SupportedCommandsView()
1710 .read_local_supported_controller_delay()
1711 .Write(supported);
1712
1713 test_device()->set_settings(settings);
1714
1715 bool init_success = false;
1716 InitializeAdapter([&](bool success) { init_success = success; });
1717 ASSERT_TRUE(init_success);
1718
1719 pw::Status cb_status = static_cast<pw::Status::Code>(
1720 200); // Error code that should never be returned
1721 uint32_t min_delay_us = -1;
1722 uint32_t max_delay_us = -1;
1723 Adapter::GetSupportedDelayRangeCallback cb =
1724 [&](pw::Status status, uint32_t min_delay, uint32_t max_delay) {
1725 cb_status = status;
1726 min_delay_us = min_delay;
1727 max_delay_us = max_delay;
1728 };
1729
1730 // Construct codec ID information
1731 StaticPacket<pw::bluetooth::emboss::CodecIdWriter> codec_id;
1732 codec_id.view().coding_format().Write(
1733 pw::bluetooth::emboss::CodingFormat::U_LAW);
1734 codec_id.view().company_id().Write(0u);
1735 codec_id.view().vendor_codec_id().Write(0u);
1736
1737 adapter()->GetSupportedDelayRange(
1738 codec_id,
1739 pw::bluetooth::emboss::LogicalTransportType::BR_EDR_ACL,
1740 pw::bluetooth::emboss::DataPathDirection::INPUT,
1741 codec_config,
1742 std::move(cb));
1743 RunUntilIdle();
1744 if (!supported) {
1745 EXPECT_EQ(cb_status, PW_STATUS_UNIMPLEMENTED);
1746 } else {
1747 EXPECT_TRUE(cb_status.ok());
1748 EXPECT_LE(min_delay_us, max_delay_us);
1749 EXPECT_LE(max_delay_us, 0x3D0900u);
1750 }
1751 }
1752
1753 // Verify proper behavior when "Read Local Supported Controller Delay" command
1754 // is not supported in the controller.
TEST_F(AdapterTest,ReadLocalSupportedControllerDelayNotSupported)1755 TEST_F(AdapterTest, ReadLocalSupportedControllerDelayNotSupported) {
1756 GetSupportedDelayRangeHelper(false, std::nullopt);
1757 }
1758
1759 // Verify proper behavior when "Read Local Supported Controller Delay" command
1760 // is supported in the controller and behaves properly when codec configuration
1761 // is empty.
TEST_F(AdapterTest,ReadLocalSupportedControllerDelayBasic)1762 TEST_F(AdapterTest, ReadLocalSupportedControllerDelayBasic) {
1763 GetSupportedDelayRangeHelper(true, std::nullopt);
1764 }
1765 // Verify proper behavior when "Read Local Supported Controller Delay" command
1766 // is supported in the controller and behaves properly when codec configuration
1767 // is present.
TEST_F(AdapterTest,ReadLocalSupportedControllerDelayWithCodecConfig)1768 TEST_F(AdapterTest, ReadLocalSupportedControllerDelayWithCodecConfig) {
1769 std::vector<uint8_t> codec_configuration{0x11, 0x22, 0x33, 0x44, 0x55};
1770 GetSupportedDelayRangeHelper(true, codec_configuration);
1771 }
1772
1773 } // namespace
1774 } // namespace bt::gap
1775