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, {}, [&session](auto cb_session) {
560 session = std::move(cb_session);
561 });
562 RunUntilIdle();
563 EXPECT_FALSE(conn);
564 EXPECT_EQ(0u, adapter()->peer_cache()->count());
565
566 // Mark the peer as bonded and advance the scan period.
567 sm::PairingData pdata;
568 pdata.peer_ltk = sm::LTK();
569 pdata.local_ltk = sm::LTK();
570 adapter()->peer_cache()->AddBondedPeer(
571 BondingData{.identifier = kPeerId,
572 .address = kTestAddr,
573 .name = std::nullopt,
574 .le_pairing_data = pdata,
575 .bredr_link_key = std::nullopt,
576 .bredr_services = {}});
577 EXPECT_EQ(1u, adapter()->peer_cache()->count());
578
579 // FakeController only sends advertising reports at the start of scan periods,
580 // so we need to start a second period.
581 RunFor(kTestScanPeriod);
582
583 // The peer should have been auto-connected.
584 ASSERT_TRUE(conn);
585 EXPECT_EQ(kPeerId, conn->peer_identifier());
586 }
587
TEST_F(AdapterTest,LeSkipAutoConnectBehavior)588 TEST_F(AdapterTest, LeSkipAutoConnectBehavior) {
589 constexpr pw::chrono::SystemClock::duration kTestScanPeriod =
590 std::chrono::seconds(10);
591 constexpr PeerId kPeerId(1234);
592
593 FakeController::Settings settings;
594 settings.ApplyLEOnlyDefaults();
595 test_device()->set_settings(settings);
596
597 InitializeAdapter([](bool) {});
598 adapter()->le()->set_scan_period_for_testing(kTestScanPeriod);
599
600 auto fake_peer =
601 std::make_unique<FakePeer>(kTestAddr, dispatcher(), true, false);
602 fake_peer->set_directed_advertising_enabled(true);
603 test_device()->AddPeer(std::move(fake_peer));
604
605 std::unique_ptr<bt::gap::LowEnergyConnectionHandle> conn;
606 adapter()->set_auto_connect_callback(
607 [&](auto conn_ref) { conn = std::move(conn_ref); });
608
609 // Enable background scanning. No auto-connect should take place since the
610 // device isn't yet bonded.
611 std::unique_ptr<LowEnergyDiscoverySession> session;
612 adapter()->le()->StartDiscovery(
613 /*active=*/false, {}, [&session](auto cb_session) {
614 session = std::move(cb_session);
615 });
616 RunUntilIdle();
617 EXPECT_FALSE(conn);
618 EXPECT_EQ(0u, adapter()->peer_cache()->count());
619
620 // Mark the peer as bonded.
621 sm::PairingData pdata;
622 pdata.peer_ltk = sm::LTK();
623 pdata.local_ltk = sm::LTK();
624 adapter()->peer_cache()->AddBondedPeer(
625 BondingData{.identifier = kPeerId,
626 .address = kTestAddr,
627 .name = std::nullopt,
628 .le_pairing_data = pdata,
629 .bredr_link_key = std::nullopt,
630 .bredr_services = {}});
631 EXPECT_EQ(1u, adapter()->peer_cache()->count());
632
633 // Fake a manual disconnect to skip auto-connect behavior.
634 adapter()->peer_cache()->SetAutoConnectBehaviorForIntentionalDisconnect(
635 kPeerId);
636
637 // Advance the scan period.
638 RunFor(kTestScanPeriod);
639
640 // The peer should NOT have been auto-connected.
641 ASSERT_FALSE(conn);
642
643 // The peer should still not auto-connect after a subsequent scan period.
644 RunFor(kTestScanPeriod);
645 ASSERT_FALSE(conn);
646
647 // Fake a manual connection to reset auto-connect behavior.
648 adapter()->peer_cache()->SetAutoConnectBehaviorForSuccessfulConnection(
649 kPeerId);
650
651 // Advance the scan period.
652 RunFor(kTestScanPeriod);
653
654 // The peer SHOULD have been auto-connected.
655 ASSERT_TRUE(conn);
656 EXPECT_EQ(kPeerId, conn->peer_identifier());
657 }
658
659 // Tests the interactions between the advertising manager and the local address
660 // manager when the controller uses legacy advertising.
TEST_F(AdapterTest,LocalAddressForLegacyAdvertising)661 TEST_F(AdapterTest, LocalAddressForLegacyAdvertising) {
662 FakeController::Settings settings;
663 settings.ApplyLegacyLEConfig();
664 test_device()->set_settings(settings);
665 InitializeAdapter([](bool) {});
666
667 std::optional<AdvertisementInstance> instance;
668 auto adv_cb = [&](auto i, hci::Result<> status) {
669 instance = std::move(i);
670 EXPECT_EQ(fit::ok(), status);
671 };
672
673 // Advertising should use the public address by default when privacy is not
674 // enabled.
675 adapter()->le()->StartAdvertising(AdvertisingData(),
676 AdvertisingData(),
677 AdvertisingInterval::FAST1,
678 /*extended_pdu=*/false,
679 /*anonymous=*/false,
680 /*include_tx_power_level=*/false,
681 /*connectable=*/std::nullopt,
682 /*address_type=*/std::nullopt,
683 adv_cb);
684 RunUntilIdle();
685 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
686 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
687 test_device()->legacy_advertising_state().own_address_type);
688
689 // Enable privacy. The random address should not get configured while
690 // advertising is in progress.
691 adapter()->le()->EnablePrivacy(true);
692 RunUntilIdle();
693 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
694
695 // Stop advertising.
696 instance.reset();
697 RunUntilIdle();
698 EXPECT_FALSE(test_device()->legacy_advertising_state().enabled);
699 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
700
701 // Restart advertising. This should configure the LE random address and
702 // advertise using it.
703 adapter()->le()->StartAdvertising(AdvertisingData(),
704 AdvertisingData(),
705 AdvertisingInterval::FAST1,
706 /*extended_pdu=*/false,
707 /*anonymous=*/false,
708 /*include_tx_power_level=*/false,
709 /*connectable=*/std::nullopt,
710 /*address_type=*/std::nullopt,
711 adv_cb);
712 RunUntilIdle();
713 EXPECT_TRUE(test_device()->legacy_advertising_state().random_address);
714 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
715 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
716 test_device()->legacy_advertising_state().own_address_type);
717
718 // Advance time to force the random address to refresh. The update should be
719 // deferred while advertising.
720 auto last_random_addr =
721 *test_device()->legacy_advertising_state().random_address;
722 RunFor(kPrivateAddressTimeout);
723 EXPECT_EQ(last_random_addr,
724 *test_device()->legacy_advertising_state().random_address);
725
726 // Restarting advertising should refresh the controller address.
727 instance.reset();
728 adapter()->le()->StartAdvertising(AdvertisingData(),
729 AdvertisingData(),
730 AdvertisingInterval::FAST1,
731 /*extended_pdu=*/false,
732 /*anonymous=*/false,
733 /*include_tx_power_level=*/false,
734 /*connectable=*/std::nullopt,
735 /*address_type=*/std::nullopt,
736 adv_cb);
737 RunUntilIdle();
738 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
739 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
740 test_device()->legacy_advertising_state().own_address_type);
741 EXPECT_TRUE(test_device()->legacy_advertising_state().random_address);
742 EXPECT_NE(last_random_addr,
743 test_device()->legacy_advertising_state().random_address);
744
745 // Disable privacy. The next time advertising gets started it should use a
746 // public address.
747 adapter()->le()->EnablePrivacy(false);
748 instance.reset();
749 adapter()->le()->StartAdvertising(AdvertisingData(),
750 AdvertisingData(),
751 AdvertisingInterval::FAST1,
752 /*extended_pdu=*/false,
753 /*anonymous=*/false,
754 /*include_tx_power_level=*/false,
755 /*connectable=*/std::nullopt,
756 /*address_type=*/std::nullopt,
757 adv_cb);
758 RunUntilIdle();
759 EXPECT_TRUE(test_device()->legacy_advertising_state().enabled);
760 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
761 test_device()->legacy_advertising_state().own_address_type);
762 }
763
764 // Tests the interactions between the discovery manager and the local address
765 // manager.
TEST_F(AdapterTest,LocalAddressForDiscovery)766 TEST_F(AdapterTest, LocalAddressForDiscovery) {
767 FakeController::Settings settings;
768 settings.ApplyLegacyLEConfig();
769 test_device()->set_settings(settings);
770 InitializeAdapter([](bool) {});
771
772 // Set a scan period that is longer than the private address timeout, for
773 // testing.
774 constexpr pw::chrono::SystemClock::duration kTestDelay =
775 std::chrono::seconds(5);
776 constexpr pw::chrono::SystemClock::duration kTestScanPeriod =
777 kPrivateAddressTimeout + kTestDelay;
778 adapter()->le()->set_scan_period_for_testing(kTestScanPeriod);
779
780 // Discovery should use the public address by default.
781 LowEnergyDiscoverySessionPtr session;
782 auto cb = [&](auto s) { session = std::move(s); };
783 adapter()->le()->StartDiscovery(/*active=*/true, {}, cb);
784 RunUntilIdle();
785 ASSERT_TRUE(session);
786 EXPECT_TRUE(test_device()->le_scan_state().enabled);
787 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
788 test_device()->le_scan_state().own_address_type);
789
790 // Enable privacy. The random address should not get configured while a scan
791 // is in progress.
792 adapter()->le()->EnablePrivacy(true);
793 RunUntilIdle();
794 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
795
796 // Stop discovery.
797 session = nullptr;
798 RunUntilIdle();
799 EXPECT_FALSE(test_device()->le_scan_state().enabled);
800 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
801
802 // Restart discovery. This should configure the LE random address and scan
803 // using it.
804 adapter()->le()->StartDiscovery(/*active=*/true, {}, cb);
805 RunUntilIdle();
806 ASSERT_TRUE(session);
807 EXPECT_TRUE(test_device()->le_scan_state().enabled);
808 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
809 test_device()->le_scan_state().own_address_type);
810
811 // Advance time to force the random address to refresh. The update should be
812 // deferred while still scanning.
813 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
814 auto last_random_addr =
815 *test_device()->legacy_advertising_state().random_address;
816 RunFor(kPrivateAddressTimeout);
817 EXPECT_EQ(last_random_addr,
818 *test_device()->legacy_advertising_state().random_address);
819
820 // Let the scan period expire. This should restart scanning and refresh the
821 // random address.
822 RunFor(kTestDelay);
823 EXPECT_TRUE(test_device()->le_scan_state().enabled);
824 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
825 test_device()->le_scan_state().own_address_type);
826 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
827 EXPECT_NE(last_random_addr,
828 test_device()->legacy_advertising_state().random_address);
829
830 // Disable privacy. The next time scanning gets started it should use a
831 // public address.
832 adapter()->le()->EnablePrivacy(false);
833 RunFor(kTestScanPeriod);
834 EXPECT_TRUE(test_device()->le_scan_state().enabled);
835 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
836 test_device()->le_scan_state().own_address_type);
837 }
838
TEST_F(AdapterTest,LocalAddressForConnections)839 TEST_F(AdapterTest, LocalAddressForConnections) {
840 FakeController::Settings settings;
841 settings.ApplyLegacyLEConfig();
842 test_device()->set_settings(settings);
843 InitializeAdapter([](bool) {});
844
845 // Set-up a device for testing.
846 auto* peer =
847 adapter()->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
848 auto fake_peer = std::make_unique<FakePeer>(kTestAddr, dispatcher());
849 test_device()->AddPeer(std::move(fake_peer));
850
851 std::unique_ptr<bt::gap::LowEnergyConnectionHandle> conn_ref;
852 auto connect_cb = [&conn_ref](auto result) {
853 ASSERT_EQ(fit::ok(), result);
854 conn_ref = std::move(result).value();
855 };
856
857 // A connection request should use the public address by default.
858 adapter()->le()->Connect(
859 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
860
861 // Enable privacy. The random address should not get configured while a
862 // connection attempt is in progress.
863 adapter()->le()->EnablePrivacy(true);
864 RunUntilIdle();
865 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
866 ASSERT_TRUE(conn_ref);
867 ASSERT_TRUE(test_device()->le_connect_params());
868 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
869 test_device()->le_connect_params()->own_address_type);
870
871 // Disconnect
872 conn_ref = nullptr;
873
874 // Create a new connection. The LowEnergyConnectionManager should try to
875 // update the local address before creating the connection.
876 adapter()->le()->Connect(
877 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
878 RunUntilIdle();
879 EXPECT_TRUE(test_device()->legacy_advertising_state().random_address);
880 ASSERT_TRUE(conn_ref);
881 ASSERT_TRUE(test_device()->le_connect_params());
882
883 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
884 // address when initiating connections. Change this test to expect a random
885 // address once RPAs for central connections are re-enabled.
886 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
887 test_device()->le_connect_params()->own_address_type);
888
889 // Disable privacy. The next connection attempt should use a public address.
890 adapter()->le()->EnablePrivacy(false);
891 conn_ref = nullptr;
892 adapter()->le()->Connect(
893 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
894 RunUntilIdle();
895 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
896 test_device()->le_connect_params()->own_address_type);
897 }
898
899 // Tests the deferral of random address configuration while a connection request
900 // is outstanding.
TEST_F(AdapterTest,LocalAddressDuringHangingConnect)901 TEST_F(AdapterTest, LocalAddressDuringHangingConnect) {
902 FakeController::Settings settings;
903 settings.ApplyLegacyLEConfig();
904 test_device()->set_settings(settings);
905 InitializeAdapter([](bool) {});
906
907 auto* peer =
908 adapter()->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
909
910 // Cause scanning to succeed and the connection request to hang.
911 auto fake_peer = std::make_unique<FakePeer>(kTestAddr, dispatcher());
912 fake_peer->set_force_pending_connect(true);
913 test_device()->AddPeer(std::move(fake_peer));
914
915 constexpr pw::chrono::SystemClock::duration kTestDelay =
916 std::chrono::seconds(5);
917 constexpr pw::chrono::SystemClock::duration kTestTimeout =
918 kPrivateAddressTimeout + kTestDelay;
919
920 // Some of the behavior below stems from the fact that kTestTimeout is longer
921 // than kCacheTimeout. This assertion is here to catch regressions in this
922 // test if the values ever change.
923 // TODO: https://fxbug.dev/42087236 - Configuring the cache expiration timeout
924 // explicitly would remove some of the unnecessary invariants from this test
925 // case.
926 static_assert(kTestTimeout > kCacheTimeout,
927 "expected a shorter device cache timeout");
928
929 adapter()->le()->set_request_timeout_for_testing(kTestTimeout);
930
931 // The connection request should use a public address.
932 std::optional<HostError> error;
933 int connect_cb_calls = 0;
934 auto connect_cb = [&error, &connect_cb_calls](auto result) {
935 connect_cb_calls++;
936 ASSERT_TRUE(result.is_error());
937 error = result.error_value();
938 };
939 adapter()->le()->Connect(
940 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
941 RunUntilIdle();
942 ASSERT_TRUE(test_device()->le_connect_params());
943 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
944 test_device()->le_connect_params()->own_address_type);
945
946 // Enable privacy. The random address should not get configured while a
947 // connection request is outstanding.
948 adapter()->le()->EnablePrivacy(true);
949 RunUntilIdle();
950 EXPECT_FALSE(test_device()->legacy_advertising_state().random_address);
951
952 // Let the connection request timeout.
953 RunFor(kTestTimeout);
954 ASSERT_TRUE(error.has_value());
955 EXPECT_EQ(HostError::kTimedOut, error.value())
956 << "Error: " << HostErrorToString(error.value());
957 EXPECT_EQ(1, connect_cb_calls);
958
959 // The peer should not have expired.
960 ASSERT_EQ(peer, adapter()->peer_cache()->FindByAddress(kTestAddr));
961 adapter()->le()->Connect(
962 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
963 RunUntilIdle();
964 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
965 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
966 // address when initiating connections. Change this test to expect a random
967 // address once RPAs for central connections are re-enabled.
968 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
969 test_device()->le_connect_params()->own_address_type);
970
971 // Advance the time to cause the random address to refresh. The update should
972 // be deferred while a connection request is outstanding.
973 auto last_random_addr =
974 *test_device()->legacy_advertising_state().random_address;
975 RunFor(kPrivateAddressTimeout);
976 EXPECT_EQ(last_random_addr,
977 *test_device()->legacy_advertising_state().random_address);
978
979 ASSERT_EQ(peer, adapter()->peer_cache()->FindByAddress(kTestAddr));
980
981 // The address should refresh after the pending request expires and before the
982 // next connection attempt.
983 RunFor(kTestDelay);
984 ASSERT_EQ(2, connect_cb_calls);
985
986 // This will be notified when LowEnergyConnectionManager is destroyed.
987 auto noop_connect_cb = [](auto) {};
988 adapter()->le()->Connect(peer->identifier(),
989 std::move(noop_connect_cb),
990 LowEnergyConnectionOptions());
991 RunUntilIdle();
992 EXPECT_NE(last_random_addr,
993 *test_device()->legacy_advertising_state().random_address);
994 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
995 // address when initiating connections. Change this test to expect a random
996 // address once RPAs for central connections are re-enabled.
997 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
998 test_device()->le_connect_params()->own_address_type);
999 }
1000
1001 // Tests that existing connections don't prevent an address change.
TEST_F(AdapterTest,ExistingConnectionDoesNotPreventLocalAddressChange)1002 TEST_F(AdapterTest, ExistingConnectionDoesNotPreventLocalAddressChange) {
1003 FakeController::Settings settings;
1004 settings.ApplyLegacyLEConfig();
1005 test_device()->set_settings(settings);
1006 InitializeAdapter([](bool) {});
1007
1008 adapter()->le()->EnablePrivacy(true);
1009
1010 std::unique_ptr<bt::gap::LowEnergyConnectionHandle> conn_ref;
1011 auto connect_cb = [&](auto result) {
1012 ASSERT_EQ(fit::ok(), result);
1013 conn_ref = std::move(result).value();
1014 ASSERT_TRUE(conn_ref);
1015 };
1016
1017 auto* peer =
1018 adapter()->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
1019 auto fake_peer = std::make_unique<FakePeer>(kTestAddr, dispatcher());
1020 test_device()->AddPeer(std::move(fake_peer));
1021 adapter()->le()->Connect(
1022 peer->identifier(), connect_cb, LowEnergyConnectionOptions());
1023 RunUntilIdle();
1024 // TODO: https://fxbug.dev/42141593 - The current policy is to use a public
1025 // address when initiating connections. Change this test to expect a random
1026 // address once RPAs for central connections are re-enabled.
1027 EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
1028 test_device()->le_connect_params()->own_address_type);
1029
1030 // Expire the private address. The address should refresh without interference
1031 // from the ongoing connection.
1032 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
1033 auto last_random_addr =
1034 *test_device()->legacy_advertising_state().random_address;
1035 RunFor(kPrivateAddressTimeout);
1036 ASSERT_TRUE(test_device()->legacy_advertising_state().random_address);
1037 EXPECT_NE(last_random_addr,
1038 *test_device()->legacy_advertising_state().random_address);
1039 }
1040
TEST_F(AdapterTest,IsDiscoverableLowEnergy)1041 TEST_F(AdapterTest, IsDiscoverableLowEnergy) {
1042 FakeController::Settings settings;
1043 settings.ApplyLegacyLEConfig();
1044 test_device()->set_settings(settings);
1045 InitializeAdapter([](bool) {});
1046
1047 EXPECT_FALSE(adapter()->IsDiscoverable());
1048
1049 AdvertisementInstance instance;
1050 adapter()->le()->StartAdvertising(AdvertisingData(),
1051 AdvertisingData(),
1052 AdvertisingInterval::FAST1,
1053 /*extended_pdu=*/false,
1054 /*anonymous=*/false,
1055 /*include_tx_power_level=*/false,
1056 /*connectable=*/std::nullopt,
1057 /*address_type=*/std::nullopt,
1058 [&](AdvertisementInstance i, auto status) {
1059 ASSERT_EQ(fit::ok(), status);
1060 instance = std::move(i);
1061 });
1062 RunUntilIdle();
1063 EXPECT_TRUE(adapter()->IsDiscoverable());
1064
1065 instance = {};
1066 RunUntilIdle();
1067 EXPECT_FALSE(adapter()->IsDiscoverable());
1068 }
1069
TEST_F(AdapterTest,IsDiscoverableBredr)1070 TEST_F(AdapterTest, IsDiscoverableBredr) {
1071 FakeController::Settings settings;
1072 settings.ApplyDualModeDefaults();
1073 test_device()->set_settings(settings);
1074 InitializeAdapter([](bool) {});
1075
1076 EXPECT_FALSE(adapter()->IsDiscoverable());
1077
1078 std::unique_ptr<BrEdrDiscoverableSession> session;
1079 adapter()->bredr()->RequestDiscoverable(
1080 [&](auto, auto s) { session = std::move(s); });
1081 RunUntilIdle();
1082 EXPECT_TRUE(adapter()->IsDiscoverable());
1083
1084 session = nullptr;
1085 RunUntilIdle();
1086 EXPECT_FALSE(adapter()->IsDiscoverable());
1087 }
1088
TEST_F(AdapterTest,IsDiscoverableLowEnergyPrivacyEnabled)1089 TEST_F(AdapterTest, IsDiscoverableLowEnergyPrivacyEnabled) {
1090 FakeController::Settings settings;
1091 settings.ApplyLegacyLEConfig();
1092 test_device()->set_settings(settings);
1093 InitializeAdapter([](bool) {});
1094
1095 EXPECT_FALSE(adapter()->IsDiscoverable());
1096 adapter()->le()->EnablePrivacy(true);
1097 EXPECT_FALSE(adapter()->IsDiscoverable());
1098
1099 AdvertisementInstance instance;
1100 adapter()->le()->StartAdvertising(AdvertisingData(),
1101 AdvertisingData(),
1102 AdvertisingInterval::FAST1,
1103 /*extended_pdu=*/false,
1104 /*anonymous=*/false,
1105 /*include_tx_power_level=*/false,
1106 /*connectable=*/std::nullopt,
1107 /*address_type=*/std::nullopt,
1108 [&](AdvertisementInstance i, auto status) {
1109 ASSERT_EQ(fit::ok(), status);
1110 instance = std::move(i);
1111 });
1112 RunUntilIdle();
1113 // Even though we are advertising over LE, we are not discoverable since
1114 // Privacy is enabled.
1115 EXPECT_FALSE(adapter()->IsDiscoverable());
1116
1117 instance = {};
1118 RunUntilIdle();
1119 EXPECT_FALSE(adapter()->IsDiscoverable());
1120 }
1121
1122 #ifndef NINSPECT
TEST_F(AdapterTest,InspectHierarchy)1123 TEST_F(AdapterTest, InspectHierarchy) {
1124 inspect::Inspector inspector;
1125 auto bt_host_node = inspector.GetRoot().CreateChild("bt-host");
1126 adapter()->AttachInspect(bt_host_node, "adapter");
1127
1128 bool success;
1129 int init_cb_count = 0;
1130 auto init_cb = [&](bool cb_success) {
1131 success = cb_success;
1132 init_cb_count++;
1133 };
1134
1135 // Return valid buffer information and enable LE support. (This should
1136 // succeed).
1137 FakeController::Settings settings;
1138 settings.AddBREDRSupportedCommands();
1139 settings.lmp_features_page0 |=
1140 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1141 settings.le_acl_data_packet_length = 0x1B;
1142 settings.le_total_num_acl_data_packets = 1;
1143 settings.synchronous_data_packet_length = 6;
1144 settings.total_num_synchronous_data_packets = 2;
1145 test_device()->set_settings(settings);
1146
1147 InitializeAdapter(std::move(init_cb));
1148 EXPECT_TRUE(success);
1149
1150 auto le_connection_manager_matcher =
1151 NodeMatches(NameMatches("low_energy_connection_manager"));
1152 auto bredr_connection_manager_matcher =
1153 NodeMatches(NameMatches("bredr_connection_manager"));
1154 auto peer_cache_matcher =
1155 NodeMatches(NameMatches(PeerCache::kInspectNodeName));
1156 auto sdp_server_matcher =
1157 NodeMatches(NameMatches(sdp::Server::kInspectNodeName));
1158 auto acl_data_channel_matcher =
1159 NodeMatches(NameMatches(hci::AclDataChannel::kInspectNodeName));
1160 auto le_matcher =
1161 AllOf(NodeMatches(AllOf(NameMatches("le"),
1162 PropertyList(UnorderedElementsAre(
1163 UintIs("open_l2cap_channel_requests", 0),
1164 UintIs("outgoing_connection_requests", 0),
1165 UintIs("pair_requests", 0),
1166 UintIs("start_advertising_events", 0),
1167 UintIs("stop_advertising_events", 0),
1168 UintIs("start_discovery_events", 0))))));
1169 auto bredr_matcher =
1170 AllOf(NodeMatches(AllOf(NameMatches("bredr"),
1171 PropertyList(UnorderedElementsAre(
1172 UintIs("outgoing_connection_requests", 0),
1173 UintIs("pair_requests", 0),
1174 UintIs("set_connectable_true_events", 0),
1175 UintIs("set_connectable_false_events", 0),
1176 UintIs("open_l2cap_channel_requests", 0))))));
1177 auto metrics_node_matcher =
1178 AllOf(NodeMatches(NameMatches(Adapter::kMetricsInspectNodeName)),
1179 ChildrenMatch(UnorderedElementsAre(bredr_matcher, le_matcher)));
1180 auto le_discovery_manager_matcher =
1181 NodeMatches(NameMatches("low_energy_discovery_manager"));
1182 auto bredr_discovery_manager_matcher =
1183 NodeMatches(NameMatches("bredr_discovery_manager"));
1184 auto hci_matcher = NodeMatches(NameMatches(hci::Transport::kInspectNodeName));
1185
1186 auto adapter_matcher = AllOf(
1187 NodeMatches(AllOf(
1188 NameMatches("adapter"),
1189 PropertyList(UnorderedElementsAre(
1190 StringIs("adapter_id", adapter()->identifier().ToString()),
1191 StringIs(
1192 "hci_version",
1193 hci_spec::HCIVersionToString(adapter()->state().hci_version)),
1194 UintIs(
1195 "bredr_max_num_packets",
1196 adapter()->state().bredr_data_buffer_info.max_num_packets()),
1197 UintIs(
1198 "bredr_max_data_length",
1199 adapter()->state().bredr_data_buffer_info.max_data_length()),
1200 UintIs("le_max_num_packets",
1201 adapter()
1202 ->state()
1203 .low_energy_state.acl_data_buffer_info()
1204 .max_num_packets()),
1205 UintIs("le_max_data_length",
1206 adapter()
1207 ->state()
1208 .low_energy_state.acl_data_buffer_info()
1209 .max_data_length()),
1210 UintIs("sco_max_num_packets",
1211 adapter()->state().sco_buffer_info.max_num_packets()),
1212 UintIs("sco_max_data_length",
1213 adapter()->state().sco_buffer_info.max_data_length()),
1214 StringIs("lmp_features", adapter()->state().features.ToString()),
1215 StringIs("le_features",
1216 bt_lib_cpp_string::StringPrintf(
1217 "0x%016lx",
1218 adapter()
1219 ->state()
1220 .low_energy_state.supported_features())))))),
1221 ChildrenMatch(UnorderedElementsAre(peer_cache_matcher,
1222 sdp_server_matcher,
1223 le_connection_manager_matcher,
1224 bredr_connection_manager_matcher,
1225 le_discovery_manager_matcher,
1226 metrics_node_matcher,
1227 bredr_discovery_manager_matcher,
1228 hci_matcher)));
1229
1230 auto bt_host_matcher =
1231 AllOf(NodeMatches(NameMatches("bt-host")),
1232 ChildrenMatch(UnorderedElementsAre(adapter_matcher)));
1233 auto hierarchy = inspect::ReadFromVmo(inspector.DuplicateVmo()).take_value();
1234
1235 EXPECT_THAT(hierarchy,
1236 AllOf(NodeMatches(NameMatches("root")),
1237 ChildrenMatch(UnorderedElementsAre(bt_host_matcher))));
1238 }
1239 #endif // NINSPECT
1240
TEST_F(AdapterTest,VendorFeatures)1241 TEST_F(AdapterTest, VendorFeatures) {
1242 FakeController::Settings settings;
1243 settings.ApplyDualModeDefaults();
1244 test_device()->set_settings(settings);
1245
1246 bool success = false;
1247 auto init_cb = [&](bool cb_success) { success = cb_success; };
1248 InitializeAdapter(std::move(init_cb));
1249 EXPECT_TRUE(success);
1250 EXPECT_EQ(adapter()->state().controller_features, kDefaultFeaturesBits);
1251 }
1252
TEST_F(AdapterTest,LowEnergyStartAdvertisingConnectCallbackReceivesConnection)1253 TEST_F(AdapterTest,
1254 LowEnergyStartAdvertisingConnectCallbackReceivesConnection) {
1255 FakeController::Settings settings;
1256 settings.ApplyLegacyLEConfig();
1257 test_device()->set_settings(settings);
1258 InitializeAdapter([](bool) {});
1259
1260 AdvertisementInstance instance;
1261 auto adv_cb = [&](auto i, hci::Result<> status) {
1262 instance = std::move(i);
1263 EXPECT_EQ(fit::ok(), status);
1264 };
1265
1266 std::optional<Adapter::LowEnergy::ConnectionResult> conn_result;
1267 std::optional<AdvertisementId> conn_cb_advertisement_id;
1268 Adapter::LowEnergy::ConnectionCallback connect_cb =
1269 [&](AdvertisementId adv_id, Adapter::LowEnergy::ConnectionResult result) {
1270 conn_result = std::move(result);
1271 conn_cb_advertisement_id = adv_id;
1272 };
1273
1274 adapter()->le()->StartAdvertising(
1275 AdvertisingData(),
1276 AdvertisingData(),
1277 AdvertisingInterval::FAST1,
1278 /*extended_pdu=*/false,
1279 /*anonymous=*/false,
1280 /*include_tx_power_level=*/false,
1281 bt::gap::Adapter::LowEnergy::ConnectableAdvertisingParameters{
1282 .connection_cb = std::move(connect_cb),
1283 .bondable_mode = sm::BondableMode::NonBondable},
1284 /*address_type=*/std::nullopt,
1285 adv_cb);
1286 RunUntilIdle();
1287 EXPECT_FALSE(conn_result);
1288
1289 fit::closure complete_interrogation;
1290 // Pause interrogation so we can control when the inbound connection procedure
1291 // completes.
1292 test_device()->pause_responses_for_opcode(
1293 bt::hci_spec::kReadRemoteVersionInfo, [&](fit::closure trigger) {
1294 complete_interrogation = std::move(trigger);
1295 });
1296
1297 test_device()->AddPeer(std::make_unique<FakePeer>(kTestAddr, dispatcher()));
1298 test_device()->ConnectLowEnergy(kTestAddr);
1299 RunUntilIdle();
1300 ASSERT_FALSE(conn_result);
1301 ASSERT_TRUE(complete_interrogation);
1302
1303 complete_interrogation();
1304 RunUntilIdle();
1305 ASSERT_TRUE(conn_result);
1306 ASSERT_EQ(fit::ok(), *conn_result);
1307 std::unique_ptr<LowEnergyConnectionHandle> conn_handle =
1308 std::move(*conn_result).value();
1309 ASSERT_TRUE(conn_handle);
1310 EXPECT_EQ(conn_handle->bondable_mode(), sm::BondableMode::NonBondable);
1311 EXPECT_EQ(*conn_cb_advertisement_id, instance.id());
1312 conn_result.reset();
1313 }
1314
1315 // Tests where the constructor must run in the test, rather than Setup.
1316
1317 class AdapterConstructorTest : public TestingBase {
1318 public:
1319 AdapterConstructorTest() = default;
1320 ~AdapterConstructorTest() override = default;
1321
SetUp()1322 void SetUp() override {
1323 TestingBase::SetUp();
1324
1325 l2cap_ = std::make_unique<l2cap::testing::FakeL2cap>(dispatcher());
1326 gatt_ = std::make_unique<gatt::testing::FakeLayer>(dispatcher());
1327 }
1328
TearDown()1329 void TearDown() override {
1330 l2cap_ = nullptr;
1331 gatt_ = nullptr;
1332 TestingBase::TearDown();
1333 }
1334
1335 protected:
1336 std::unique_ptr<l2cap::testing::FakeL2cap> l2cap_;
1337 std::unique_ptr<gatt::testing::FakeLayer> gatt_;
1338 };
1339
1340 using GAP_AdapterConstructorTest = AdapterConstructorTest;
1341
TEST_F(AdapterConstructorTest,GattCallbacks)1342 TEST_F(AdapterConstructorTest, GattCallbacks) {
1343 constexpr PeerId kPeerId(1234);
1344 constexpr gatt::ServiceChangedCCCPersistedData kPersistedData = {
1345 .notify = true, .indicate = true};
1346
1347 int set_persist_cb_count = 0;
1348 int set_retrieve_cb_count = 0;
1349
1350 auto set_persist_cb_cb = [&set_persist_cb_count]() {
1351 set_persist_cb_count++;
1352 };
1353
1354 auto set_retrieve_cb_cb = [&set_retrieve_cb_count]() {
1355 set_retrieve_cb_count++;
1356 };
1357
1358 gatt_->SetSetPersistServiceChangedCCCCallbackCallback(set_persist_cb_cb);
1359 gatt_->SetSetRetrieveServiceChangedCCCCallbackCallback(set_retrieve_cb_cb);
1360
1361 EXPECT_EQ(set_persist_cb_count, 0);
1362 EXPECT_EQ(set_retrieve_cb_count, 0);
1363
1364 Adapter::Config config = {
1365 .legacy_pairing_enabled = false,
1366 };
1367 auto adapter = Adapter::Create(dispatcher(),
1368 transport()->GetWeakPtr(),
1369 gatt_->GetWeakPtr(),
1370 config,
1371 std::move(l2cap_));
1372
1373 EXPECT_EQ(set_persist_cb_count, 1);
1374 EXPECT_EQ(set_retrieve_cb_count, 1);
1375
1376 // Before the peer exists, adding its gatt info to the peer cache does
1377 // nothing.
1378 gatt_->CallPersistServiceChangedCCCCallback(
1379 kPeerId, /*notify=*/true, /*indicate=*/false);
1380 auto persisted_data_1 = gatt_->CallRetrieveServiceChangedCCCCallback(kPeerId);
1381 EXPECT_EQ(persisted_data_1, std::nullopt);
1382
1383 // After adding a classic peer, adding its info to the peer cache still does
1384 // nothing.
1385 Peer* classic_peer =
1386 adapter->peer_cache()->NewPeer(kTestAddrBrEdr, /*connectable=*/true);
1387 PeerId classic_peer_id = classic_peer->identifier();
1388
1389 gatt_->CallPersistServiceChangedCCCCallback(
1390 classic_peer_id, /*notify=*/false, /*indicate=*/true);
1391 auto persisted_data_2 =
1392 gatt_->CallRetrieveServiceChangedCCCCallback(classic_peer_id);
1393 EXPECT_EQ(persisted_data_2, std::nullopt);
1394
1395 // After adding an LE peer, adding its info to the peer cache works.
1396 Peer* le_peer =
1397 adapter->peer_cache()->NewPeer(kTestAddr, /*connectable=*/true);
1398 PeerId le_peer_id = le_peer->identifier();
1399
1400 gatt_->CallPersistServiceChangedCCCCallback(
1401 le_peer_id, /*notify=*/true, /*indicate=*/true);
1402 auto persisted_data_3 =
1403 gatt_->CallRetrieveServiceChangedCCCCallback(le_peer_id);
1404 ASSERT_TRUE(persisted_data_3.has_value());
1405 auto persisted_data_3_value = persisted_data_3.value();
1406 EXPECT_EQ(persisted_data_3_value, kPersistedData);
1407
1408 // After the peer is removed, the gatt info is no longer in the peer cache.
1409 bool result = adapter->peer_cache()->RemoveDisconnectedPeer(le_peer_id);
1410 EXPECT_TRUE(result);
1411
1412 auto persisted_data_4 =
1413 gatt_->CallRetrieveServiceChangedCCCCallback(le_peer_id);
1414 EXPECT_EQ(persisted_data_4, std::nullopt);
1415 }
1416
TEST_F(AdapterTest,BufferSizesRecordedInState)1417 TEST_F(AdapterTest, BufferSizesRecordedInState) {
1418 bool success = false;
1419 auto init_cb = [&](bool cb_success) { success = cb_success; };
1420
1421 FakeController::Settings settings;
1422 // Enable ReadBuffer commands.
1423 settings.AddBREDRSupportedCommands();
1424 settings.AddLESupportedCommands();
1425 settings.lmp_features_page0 |=
1426 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1427
1428 // Minimum supported size as per Core Spec v5.4, Vol 4, Part E, 7.8.2
1429 settings.le_acl_data_packet_length = 0x1B;
1430
1431 settings.le_total_num_acl_data_packets = 2;
1432 settings.acl_data_packet_length = 3;
1433 settings.total_num_acl_data_packets = 4;
1434 settings.synchronous_data_packet_length = 5;
1435 settings.total_num_synchronous_data_packets = 6;
1436 settings.iso_data_packet_length = 7;
1437 settings.total_num_iso_data_packets = 8;
1438 test_device()->set_settings(settings);
1439
1440 InitializeAdapter(std::move(init_cb));
1441 EXPECT_TRUE(success);
1442 EXPECT_EQ(adapter()
1443 ->state()
1444 .low_energy_state.acl_data_buffer_info()
1445 .max_data_length(),
1446 (uint16_t)0x1B);
1447 EXPECT_EQ(adapter()
1448 ->state()
1449 .low_energy_state.acl_data_buffer_info()
1450 .max_num_packets(),
1451 2u);
1452 EXPECT_EQ(adapter()->state().bredr_data_buffer_info.max_data_length(), 3u);
1453 EXPECT_EQ(adapter()->state().bredr_data_buffer_info.max_num_packets(), 4u);
1454 EXPECT_EQ(adapter()->state().sco_buffer_info.max_data_length(), 5u);
1455 EXPECT_EQ(adapter()->state().sco_buffer_info.max_num_packets(), 6u);
1456 EXPECT_EQ(adapter()
1457 ->state()
1458 .low_energy_state.iso_data_buffer_info()
1459 .max_data_length(),
1460 7u);
1461 EXPECT_EQ(adapter()
1462 ->state()
1463 .low_energy_state.iso_data_buffer_info()
1464 .max_num_packets(),
1465 8u);
1466 }
1467
TEST_F(AdapterTest,LEReadMaximumAdvertisingDataLengthNotSupported)1468 TEST_F(AdapterTest, LEReadMaximumAdvertisingDataLengthNotSupported) {
1469 FakeController::Settings settings;
1470 settings.AddBREDRSupportedCommands();
1471 settings.AddLESupportedCommands();
1472 settings.lmp_features_page0 |=
1473 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1474 settings.le_acl_data_packet_length = 0x1B;
1475 settings.le_total_num_acl_data_packets = 2;
1476 test_device()->set_settings(settings);
1477
1478 const LowEnergyState& low_energy_state = adapter()->state().low_energy_state;
1479 bool success = false;
1480 auto init_cb = [&](bool cb_success) { success = cb_success; };
1481 InitializeAdapter(std::move(init_cb));
1482 EXPECT_TRUE(success);
1483 EXPECT_EQ(hci_spec::kMaxLEAdvertisingDataLength,
1484 low_energy_state.max_advertising_data_length());
1485 }
1486
TEST_F(AdapterTest,LEReadMaximumAdvertisingDataLengthSupported)1487 TEST_F(AdapterTest, LEReadMaximumAdvertisingDataLengthSupported) {
1488 FakeController::Settings settings;
1489 settings.AddBREDRSupportedCommands();
1490 settings.AddLESupportedCommands();
1491 settings.lmp_features_page0 |=
1492 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1493 settings.le_acl_data_packet_length = 0x1B;
1494 settings.le_total_num_acl_data_packets = 2;
1495 settings.SupportedCommandsView()
1496 .le_read_maximum_advertising_data_length()
1497 .Write(true);
1498
1499 test_device()->set_settings(settings);
1500 test_device()->set_maximum_advertising_data_length(
1501 hci_spec::kMaxLEExtendedAdvertisingDataLength);
1502
1503 const LowEnergyState& low_energy_state = adapter()->state().low_energy_state;
1504 bool success = false;
1505 auto init_cb = [&](bool cb_success) { success = cb_success; };
1506 InitializeAdapter(std::move(init_cb));
1507 EXPECT_TRUE(success);
1508 EXPECT_EQ(hci_spec::kMaxLEExtendedAdvertisingDataLength,
1509 low_energy_state.max_advertising_data_length());
1510 }
1511
TEST_F(AdapterTest,LEConnectedIsochronousStreamSupported)1512 TEST_F(AdapterTest, LEConnectedIsochronousStreamSupported) {
1513 FakeController::Settings settings;
1514 settings.AddBREDRSupportedCommands();
1515 settings.AddLESupportedCommands();
1516 settings.lmp_features_page0 |=
1517 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1518 settings.le_features |= static_cast<uint64_t>(
1519 hci_spec::LESupportedFeature::kConnectedIsochronousStreamPeripheral);
1520 settings.le_acl_data_packet_length = 0x1B;
1521 settings.le_total_num_acl_data_packets = 2;
1522
1523 test_device()->set_settings(settings);
1524
1525 bool success = false;
1526 auto init_cb = [&](bool cb_success) { success = cb_success; };
1527 InitializeAdapter(std::move(init_cb));
1528 EXPECT_TRUE(success);
1529 const auto& le_features = test_device()->le_features();
1530 EXPECT_TRUE(
1531 (le_features &
1532 static_cast<uint64_t>(hci_spec::LESupportedFeature::
1533 kConnectedIsochronousStreamHostSupport)) != 0);
1534 }
1535
TEST_F(AdapterTest,ScoDataChannelInitializedSuccessfully)1536 TEST_F(AdapterTest, ScoDataChannelInitializedSuccessfully) {
1537 // Return valid buffer information and enable LE support.
1538 FakeController::Settings settings;
1539 settings.AddBREDRSupportedCommands();
1540 settings.lmp_features_page0 |=
1541 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1542 settings.le_acl_data_packet_length = 0x1B;
1543 settings.le_total_num_acl_data_packets = 1;
1544 // Ensure SCO buffers are available.
1545 settings.synchronous_data_packet_length = 6;
1546 settings.total_num_synchronous_data_packets = 2;
1547 // Enable SCO flow control command.
1548 settings.SupportedCommandsView()
1549 .write_synchronous_flow_control_enable()
1550 .Write(true);
1551 test_device()->set_settings(settings);
1552
1553 bool success = false;
1554 auto init_cb = [&](bool cb_success) { success = cb_success; };
1555 InitializeAdapter(std::move(init_cb));
1556 EXPECT_TRUE(success);
1557 EXPECT_TRUE(transport()->sco_data_channel());
1558 }
1559
TEST_F(AdapterTest,ScoDataChannelNotInitializedBecauseFlowControlNotSupported)1560 TEST_F(AdapterTest,
1561 ScoDataChannelNotInitializedBecauseFlowControlNotSupported) {
1562 // Return valid buffer information and enable LE support.
1563 FakeController::Settings settings;
1564 settings.AddBREDRSupportedCommands();
1565 settings.lmp_features_page0 |=
1566 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1567 settings.SupportedCommandsView()
1568 .write_synchronous_flow_control_enable()
1569 .Write(false);
1570 settings.le_acl_data_packet_length = 0x1B;
1571 settings.le_total_num_acl_data_packets = 1;
1572 // Ensure SCO buffers are available.
1573 settings.synchronous_data_packet_length = 6;
1574 settings.total_num_synchronous_data_packets = 2;
1575 test_device()->set_settings(settings);
1576
1577 bool success = false;
1578 auto init_cb = [&](bool cb_success) { success = cb_success; };
1579 InitializeAdapter(std::move(init_cb));
1580 EXPECT_TRUE(success);
1581 EXPECT_FALSE(transport()->sco_data_channel());
1582 }
1583
TEST_F(AdapterTest,ScoDataChannelNotInitializedBecauseBufferInfoNotAvailable)1584 TEST_F(AdapterTest, ScoDataChannelNotInitializedBecauseBufferInfoNotAvailable) {
1585 // Return valid buffer information and enable LE support.
1586 FakeController::Settings settings;
1587 settings.AddBREDRSupportedCommands();
1588 settings.lmp_features_page0 |=
1589 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1590 settings.le_acl_data_packet_length = 0x1B;
1591 settings.le_total_num_acl_data_packets = 1;
1592 // Ensure SCO buffers are not available.
1593 settings.synchronous_data_packet_length = 1;
1594 settings.total_num_synchronous_data_packets = 0;
1595 // Enable SCO flow control command.
1596 settings.SupportedCommandsView()
1597 .write_synchronous_flow_control_enable()
1598 .Write(true);
1599 test_device()->set_settings(settings);
1600
1601 bool success = false;
1602 auto init_cb = [&](bool cb_success) { success = cb_success; };
1603 InitializeAdapter(std::move(init_cb));
1604 EXPECT_TRUE(success);
1605 EXPECT_FALSE(transport()->sco_data_channel());
1606 }
1607
TEST_F(AdapterScoAndIsoDisabledTest,ScoDataChannelFailsToInitializeBecauseScoDisabled)1608 TEST_F(AdapterScoAndIsoDisabledTest,
1609 ScoDataChannelFailsToInitializeBecauseScoDisabled) {
1610 // Return valid buffer information and enable LE support.
1611 FakeController::Settings settings;
1612 settings.AddBREDRSupportedCommands();
1613 settings.lmp_features_page0 |=
1614 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1615 settings.le_acl_data_packet_length = 0x1B;
1616 settings.le_total_num_acl_data_packets = 1;
1617 // Ensure SCO buffers are available.
1618 settings.synchronous_data_packet_length = 6;
1619 settings.total_num_synchronous_data_packets = 2;
1620 // Enable SCO flow control command.
1621 settings.SupportedCommandsView()
1622 .write_synchronous_flow_control_enable()
1623 .Write(true);
1624 test_device()->set_settings(settings);
1625
1626 bool success = false;
1627 auto init_cb = [&](bool cb_success) { success = cb_success; };
1628 InitializeAdapter(std::move(init_cb));
1629 EXPECT_TRUE(success);
1630 EXPECT_FALSE(transport()->sco_data_channel());
1631 }
1632
TEST_F(AdapterTest,IsoDataChannelInitializedSuccessfully)1633 TEST_F(AdapterTest, IsoDataChannelInitializedSuccessfully) {
1634 FakeController::Settings settings;
1635 settings.ApplyDualModeDefaults();
1636 test_device()->set_settings(settings);
1637
1638 bool success = false;
1639 auto init_cb = [&](bool cb_success) { success = cb_success; };
1640 InitializeAdapter(std::move(init_cb));
1641 EXPECT_TRUE(success);
1642 EXPECT_TRUE(transport()->iso_data_channel());
1643 }
1644
TEST_F(AdapterTest,IsoDataChannelNotInitializedNoBufferData)1645 TEST_F(AdapterTest, IsoDataChannelNotInitializedNoBufferData) {
1646 FakeController::Settings settings;
1647 settings.ApplyDualModeDefaults();
1648 settings.iso_data_packet_length = 0;
1649 settings.total_num_iso_data_packets = 0;
1650 test_device()->set_settings(settings);
1651
1652 bool success = false;
1653 auto init_cb = [&](bool cb_success) { success = cb_success; };
1654 InitializeAdapter(std::move(init_cb));
1655 EXPECT_TRUE(success);
1656 EXPECT_FALSE(transport()->iso_data_channel());
1657 }
1658
TEST_F(AdapterScoAndIsoDisabledTest,IsoDataChannelNoControllerSupport)1659 TEST_F(AdapterScoAndIsoDisabledTest, IsoDataChannelNoControllerSupport) {
1660 FakeController::Settings settings;
1661 settings.ApplyDualModeDefaults();
1662 test_device()->set_settings(settings);
1663
1664 bool success = false;
1665 auto init_cb = [&](bool cb_success) { success = cb_success; };
1666 InitializeAdapter(std::move(init_cb));
1667 EXPECT_TRUE(success);
1668 EXPECT_FALSE(transport()->iso_data_channel());
1669 }
1670
TEST_F(AdapterTest,InitializeWriteSecureConnectionsHostSupport)1671 TEST_F(AdapterTest, InitializeWriteSecureConnectionsHostSupport) {
1672 bool success;
1673 int init_cb_count = 0;
1674 auto init_cb = [&](bool cb_success) {
1675 success = cb_success;
1676 init_cb_count++;
1677 };
1678
1679 // Enable LE support and extended features (Secure Connections Host Support)
1680 FakeController::Settings settings;
1681 settings.lmp_features_page0 |=
1682 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1683 settings.lmp_features_page0 |=
1684 static_cast<uint64_t>(hci_spec::LMPFeature::kExtendedFeatures);
1685 settings.lmp_features_page1 |= static_cast<uint64_t>(
1686 hci_spec::LMPFeature::kSecureConnectionsHostSupport);
1687 settings.le_acl_data_packet_length = 0x1B;
1688 settings.le_total_num_acl_data_packets = 1;
1689 test_device()->set_settings(settings);
1690
1691 InitializeAdapter(std::move(init_cb));
1692 EXPECT_TRUE(success);
1693 EXPECT_EQ(1, init_cb_count);
1694 EXPECT_TRUE(adapter()->state().IsLowEnergySupported());
1695 EXPECT_TRUE(adapter()->state().IsBREDRSupported());
1696 EXPECT_TRUE(adapter()->state().IsSecureConnectionHostSupportSupported());
1697 EXPECT_TRUE(adapter()->le());
1698 EXPECT_TRUE(adapter()->bredr());
1699 EXPECT_EQ(TechnologyType::kDualMode, adapter()->state().type());
1700 EXPECT_FALSE(transport_closed_called());
1701 }
1702
GetSupportedDelayRangeHelper(bool supported,const std::optional<std::vector<uint8_t>> & codec_config)1703 void AdapterTest::GetSupportedDelayRangeHelper(
1704 bool supported, const std::optional<std::vector<uint8_t>>& codec_config) {
1705 FakeController::Settings settings;
1706
1707 // Define minimum required settings for an LE controller
1708 settings.lmp_features_page0 |=
1709 static_cast<uint64_t>(hci_spec::LMPFeature::kLESupportedHost);
1710 settings.le_acl_data_packet_length = 0x1B;
1711 settings.le_total_num_acl_data_packets = 1;
1712
1713 // Enable or disable the "Read Local Supported Controller Delay" command
1714 settings.SupportedCommandsView()
1715 .read_local_supported_controller_delay()
1716 .Write(supported);
1717
1718 test_device()->set_settings(settings);
1719
1720 bool init_success = false;
1721 InitializeAdapter([&](bool success) { init_success = success; });
1722 ASSERT_TRUE(init_success);
1723
1724 pw::Status cb_status = static_cast<pw::Status::Code>(
1725 200); // Error code that should never be returned
1726 uint32_t min_delay_us = -1;
1727 uint32_t max_delay_us = -1;
1728 Adapter::GetSupportedDelayRangeCallback cb =
1729 [&](pw::Status status, uint32_t min_delay, uint32_t max_delay) {
1730 cb_status = status;
1731 min_delay_us = min_delay;
1732 max_delay_us = max_delay;
1733 };
1734
1735 // Construct codec ID information
1736 StaticPacket<pw::bluetooth::emboss::CodecIdWriter> codec_id;
1737 codec_id.view().coding_format().Write(
1738 pw::bluetooth::emboss::CodingFormat::U_LAW);
1739 codec_id.view().company_id().Write(0u);
1740 codec_id.view().vendor_codec_id().Write(0u);
1741
1742 adapter()->GetSupportedDelayRange(
1743 codec_id,
1744 pw::bluetooth::emboss::LogicalTransportType::BR_EDR_ACL,
1745 pw::bluetooth::emboss::DataPathDirection::INPUT,
1746 codec_config,
1747 std::move(cb));
1748 RunUntilIdle();
1749 if (!supported) {
1750 EXPECT_EQ(cb_status, PW_STATUS_UNIMPLEMENTED);
1751 } else {
1752 EXPECT_TRUE(cb_status.ok());
1753 EXPECT_LE(min_delay_us, max_delay_us);
1754 EXPECT_LE(max_delay_us, 0x3D0900u);
1755 }
1756 }
1757
1758 // Verify proper behavior when "Read Local Supported Controller Delay" command
1759 // is not supported in the controller.
TEST_F(AdapterTest,ReadLocalSupportedControllerDelayNotSupported)1760 TEST_F(AdapterTest, ReadLocalSupportedControllerDelayNotSupported) {
1761 GetSupportedDelayRangeHelper(false, std::nullopt);
1762 }
1763
1764 // Verify proper behavior when "Read Local Supported Controller Delay" command
1765 // is supported in the controller and behaves properly when codec configuration
1766 // is empty.
TEST_F(AdapterTest,ReadLocalSupportedControllerDelayBasic)1767 TEST_F(AdapterTest, ReadLocalSupportedControllerDelayBasic) {
1768 GetSupportedDelayRangeHelper(true, std::nullopt);
1769 }
1770 // Verify proper behavior when "Read Local Supported Controller Delay" command
1771 // is supported in the controller and behaves properly when codec configuration
1772 // is present.
TEST_F(AdapterTest,ReadLocalSupportedControllerDelayWithCodecConfig)1773 TEST_F(AdapterTest, ReadLocalSupportedControllerDelayWithCodecConfig) {
1774 std::vector<uint8_t> codec_configuration{0x11, 0x22, 0x33, 0x44, 0x55};
1775 GetSupportedDelayRangeHelper(true, codec_configuration);
1776 }
1777
TEST_F(AdapterTest,RemotePublicKeyValidationSupported)1778 TEST_F(AdapterTest, RemotePublicKeyValidationSupported) {
1779 FakeController::Settings settings;
1780 settings.ApplyDualModeDefaults();
1781 settings.SupportedCommandsView().read_local_simple_pairing_options().Write(
1782 true);
1783 test_device()->set_settings(settings);
1784 EXPECT_TRUE(EnsureInitialized());
1785 EXPECT_TRUE(
1786 adapter()->state().IsControllerRemotePublicKeyValidationSupported());
1787 }
1788
TEST_F(AdapterTest,RemotePublicKeyValidationNotSupported)1789 TEST_F(AdapterTest, RemotePublicKeyValidationNotSupported) {
1790 FakeController::Settings settings;
1791 settings.ApplyDualModeDefaults();
1792 settings.SupportedCommandsView().read_local_simple_pairing_options().Write(
1793 false);
1794 test_device()->set_settings(settings);
1795 EXPECT_TRUE(EnsureInitialized());
1796 EXPECT_FALSE(
1797 adapter()->state().IsControllerRemotePublicKeyValidationSupported());
1798 }
1799
1800 } // namespace
1801 } // namespace bt::gap
1802