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/hci/android_extended_low_energy_advertiser.h"
16 #include "pw_bluetooth_sapphire/internal/host/hci/extended_low_energy_advertiser.h"
17 #include "pw_bluetooth_sapphire/internal/host/testing/controller_test.h"
18 #include "pw_bluetooth_sapphire/internal/host/testing/fake_controller.h"
19 
20 // Multiple advertising is supported by the Bluetooth 5.0+ Core Specification as
21 // well as Android vendor extensions. This test file contains shared tests for
22 // both versions of LE Multiple Advertising.
23 
24 namespace bt::hci {
25 namespace {
26 
27 using bt::testing::FakeController;
28 using TestingBase = bt::testing::FakeDispatcherControllerTest<FakeController>;
29 using AdvertisingOptions = LowEnergyAdvertiser::AdvertisingOptions;
30 using LEAdvertisingState = FakeController::LEAdvertisingState;
31 
32 constexpr AdvertisingIntervalRange kTestInterval(
33     hci_spec::kLEAdvertisingIntervalMin, hci_spec::kLEAdvertisingIntervalMax);
34 
35 const DeviceAddress kPublicAddress(DeviceAddress::Type::kLEPublic, {1});
36 const DeviceAddress kRandomAddress(DeviceAddress::Type::kLERandom, {2});
37 
38 template <typename T>
39 class LowEnergyMultipleAdvertisingTest : public TestingBase {
40  public:
41   LowEnergyMultipleAdvertisingTest() = default;
42   ~LowEnergyMultipleAdvertisingTest() override = default;
43 
44  protected:
SetUp()45   void SetUp() override {
46     TestingBase::SetUp();
47 
48     // ACL data channel needs to be present for production hci::Connection
49     // objects.
50     TestingBase::InitializeACLDataChannel(
51         hci::DataBufferInfo(),
52         hci::DataBufferInfo(hci_spec::kMaxACLPayloadSize, 10));
53 
54     FakeController::Settings settings;
55     settings.ApplyExtendedLEConfig();
56     this->test_device()->set_settings(settings);
57 
58     advertiser_ = std::unique_ptr<T>(CreateAdvertiserInternal());
59   }
60 
TearDown()61   void TearDown() override {
62     advertiser_ = nullptr;
63     this->test_device()->Stop();
64     TestingBase::TearDown();
65   }
66 
67   template <bool same = std::is_same_v<T, AndroidExtendedLowEnergyAdvertiser>>
68   std::enable_if_t<same, AndroidExtendedLowEnergyAdvertiser>*
CreateAdvertiserInternal()69   CreateAdvertiserInternal() {
70     return new AndroidExtendedLowEnergyAdvertiser(transport()->GetWeakPtr(),
71                                                   max_advertisements_);
72   }
73 
74   template <bool same = std::is_same_v<T, ExtendedLowEnergyAdvertiser>>
75   std::enable_if_t<same, ExtendedLowEnergyAdvertiser>*
CreateAdvertiserInternal()76   CreateAdvertiserInternal() {
77     return new ExtendedLowEnergyAdvertiser(
78         transport()->GetWeakPtr(),
79         hci_spec::kMaxLEExtendedAdvertisingDataLength);
80   }
81 
advertiser() const82   T* advertiser() const { return advertiser_.get(); }
83 
MakeExpectSuccessCallback()84   ResultFunction<> MakeExpectSuccessCallback() {
85     return [this](Result<> status) {
86       last_status_ = status;
87       EXPECT_EQ(fit::ok(), status);
88     };
89   }
90 
MakeExpectErrorCallback()91   ResultFunction<> MakeExpectErrorCallback() {
92     return [this](Result<> status) {
93       last_status_ = status;
94       EXPECT_EQ(fit::failed(), status);
95     };
96   }
97 
GetExampleData(bool include_flags=true)98   static AdvertisingData GetExampleData(bool include_flags = true) {
99     AdvertisingData result;
100 
101     std::string name = "fuchsia";
102     EXPECT_TRUE(result.SetLocalName(name));
103 
104     uint16_t appearance = 0x1234;
105     result.SetAppearance(appearance);
106 
107     EXPECT_LE(result.CalculateBlockSize(include_flags),
108               hci_spec::kMaxLEAdvertisingDataLength);
109     return result;
110   }
111 
GetLastStatus()112   std::optional<Result<>> GetLastStatus() {
113     if (!last_status_) {
114       return std::nullopt;
115     }
116 
117     return std::exchange(last_status_, std::nullopt).value();
118   }
119 
max_advertisements() const120   uint8_t max_advertisements() const { return max_advertisements_; }
121 
122  private:
123   std::unique_ptr<T> advertiser_;
124   std::optional<Result<>> last_status_;
125   uint8_t max_advertisements_ = hci_spec::kMaxAdvertisingHandle + 1;
126 
127   BT_DISALLOW_COPY_AND_ASSIGN_ALLOW_MOVE(LowEnergyMultipleAdvertisingTest);
128 };
129 
130 using Implementations = ::testing::Types<ExtendedLowEnergyAdvertiser,
131                                          AndroidExtendedLowEnergyAdvertiser>;
132 TYPED_TEST_SUITE(LowEnergyMultipleAdvertisingTest, Implementations);
133 
TYPED_TEST(LowEnergyMultipleAdvertisingTest,AdvertisingHandlesExhausted)134 TYPED_TEST(LowEnergyMultipleAdvertisingTest, AdvertisingHandlesExhausted) {
135   this->test_device()->set_num_supported_advertising_sets(
136       this->max_advertisements());
137 
138   AdvertisingData ad = this->GetExampleData();
139   AdvertisingData scan_data = this->GetExampleData();
140   AdvertisingOptions options(kTestInterval,
141                              kDefaultNoAdvFlags,
142                              /*extended_pdu=*/false,
143                              /*anonymous=*/false,
144                              /*include_tx_power_level=*/true);
145 
146   for (uint8_t i = 0; i < this->advertiser()->MaxAdvertisements(); i++) {
147     this->advertiser()->StartAdvertising(
148         DeviceAddress(DeviceAddress::Type::kLEPublic, {i}),
149         ad,
150         scan_data,
151         options,
152         /*connect_callback=*/nullptr,
153         this->MakeExpectSuccessCallback());
154     this->RunUntilIdle();
155   }
156 
157   ASSERT_TRUE(this->GetLastStatus());
158   EXPECT_TRUE(this->advertiser()->IsAdvertising());
159   EXPECT_EQ(this->advertiser()->MaxAdvertisements(),
160             this->advertiser()->NumAdvertisements());
161 
162   this->advertiser()->StartAdvertising(
163       DeviceAddress(DeviceAddress::Type::kLEPublic,
164                     {hci_spec::kAdvertisingHandleMax + 1}),
165       ad,
166       scan_data,
167       options,
168       /*connect_callback=*/nullptr,
169       this->MakeExpectErrorCallback());
170 
171   this->RunUntilIdle();
172   ASSERT_FALSE(this->GetLastStatus());
173   EXPECT_TRUE(this->advertiser()->IsAdvertising());
174   EXPECT_EQ(this->advertiser()->MaxAdvertisements(),
175             this->advertiser()->NumAdvertisements());
176 }
177 
TYPED_TEST(LowEnergyMultipleAdvertisingTest,SimultaneousAdvertisements)178 TYPED_TEST(LowEnergyMultipleAdvertisingTest, SimultaneousAdvertisements) {
179   this->test_device()->set_num_supported_advertising_sets(2);
180 
181   AdvertisingData ad = this->GetExampleData();
182   AdvertisingData scan_data = this->GetExampleData();
183 
184   // start public address advertising
185   AdvertisingOptions public_options(kTestInterval,
186                                     kDefaultNoAdvFlags,
187                                     /*extended_pdu=*/false,
188                                     /*anonymous=*/false,
189                                     /*include_tx_power_level=*/false);
190   this->advertiser()->StartAdvertising(kPublicAddress,
191                                        ad,
192                                        scan_data,
193                                        public_options,
194                                        /*connect_callback=*/nullptr,
195                                        this->MakeExpectSuccessCallback());
196   this->RunUntilIdle();
197   std::optional<hci_spec::AdvertisingHandle> handle_public_addr =
198       this->advertiser()->LastUsedHandleForTesting();
199   ASSERT_TRUE(handle_public_addr);
200 
201   // start random address advertising
202   constexpr AdvertisingIntervalRange random_interval(
203       hci_spec::kLEAdvertisingIntervalMin + 1u,
204       hci_spec::kLEAdvertisingIntervalMax - 1u);
205   AdvertisingOptions random_options(random_interval,
206                                     kDefaultNoAdvFlags,
207                                     /*extended_pdu=*/false,
208                                     /*anonymous=*/false,
209                                     /*include_tx_power_level=*/false);
210   this->advertiser()->StartAdvertising(kRandomAddress,
211                                        ad,
212                                        scan_data,
213                                        random_options,
214                                        /*connect_callback=*/nullptr,
215                                        this->MakeExpectSuccessCallback());
216   this->RunUntilIdle();
217   std::optional<hci_spec::AdvertisingHandle> handle_random_addr =
218       this->advertiser()->LastUsedHandleForTesting();
219   ASSERT_TRUE(handle_random_addr);
220 
221   // check everything is correct
222   EXPECT_EQ(2u, this->advertiser()->NumAdvertisements());
223   EXPECT_TRUE(this->advertiser()->IsAdvertising());
224   EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress,
225                                                 /*extended_pdu=*/false));
226   EXPECT_TRUE(this->advertiser()->IsAdvertising(kRandomAddress,
227                                                 /*extended_pdu=*/false));
228 
229   const LEAdvertisingState& public_addr_state =
230       this->test_device()->extended_advertising_state(
231           handle_public_addr.value());
232   const LEAdvertisingState& random_addr_state =
233       this->test_device()->extended_advertising_state(
234           handle_random_addr.value());
235 
236   EXPECT_TRUE(public_addr_state.enabled);
237   EXPECT_TRUE(random_addr_state.enabled);
238   EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::PUBLIC,
239             public_addr_state.own_address_type);
240   EXPECT_EQ(pw::bluetooth::emboss::LEOwnAddressType::RANDOM,
241             random_addr_state.own_address_type);
242   EXPECT_EQ(hci_spec::kLEAdvertisingIntervalMin,
243             public_addr_state.interval_min);
244   EXPECT_EQ(hci_spec::kLEAdvertisingIntervalMax,
245             public_addr_state.interval_max);
246   EXPECT_EQ(hci_spec::kLEAdvertisingIntervalMin + 1u,
247             random_addr_state.interval_min);
248   EXPECT_EQ(hci_spec::kLEAdvertisingIntervalMax - 1u,
249             random_addr_state.interval_max);
250 }
251 
TYPED_TEST(LowEnergyMultipleAdvertisingTest,StopAdvertisingAllAdvertisementsStopped)252 TYPED_TEST(LowEnergyMultipleAdvertisingTest,
253            StopAdvertisingAllAdvertisementsStopped) {
254   this->test_device()->set_num_supported_advertising_sets(2);
255 
256   AdvertisingData ad = this->GetExampleData();
257   AdvertisingData scan_data = this->GetExampleData();
258 
259   // start public address advertising
260   AdvertisingOptions public_options(kTestInterval,
261                                     kDefaultNoAdvFlags,
262                                     /*extended_pdu=*/false,
263                                     /*anonymous=*/false,
264                                     /*include_tx_power_level=*/false);
265   this->advertiser()->StartAdvertising(kPublicAddress,
266                                        ad,
267                                        scan_data,
268                                        public_options,
269                                        /*connect_callback=*/nullptr,
270                                        this->MakeExpectSuccessCallback());
271   this->RunUntilIdle();
272   std::optional<hci_spec::AdvertisingHandle> handle_public_addr =
273       this->advertiser()->LastUsedHandleForTesting();
274   ASSERT_TRUE(handle_public_addr);
275 
276   // start random address advertising
277   constexpr AdvertisingIntervalRange random_interval(
278       hci_spec::kLEAdvertisingIntervalMin + 1u,
279       hci_spec::kLEAdvertisingIntervalMax - 1u);
280   AdvertisingOptions random_options(random_interval,
281                                     kDefaultNoAdvFlags,
282                                     /*extended_pdu=*/false,
283                                     /*anonymous=*/false,
284                                     /*include_tx_power_level=*/false);
285   this->advertiser()->StartAdvertising(kRandomAddress,
286                                        ad,
287                                        scan_data,
288                                        random_options,
289                                        /*connect_callback=*/nullptr,
290                                        this->MakeExpectSuccessCallback());
291   this->RunUntilIdle();
292   std::optional<hci_spec::AdvertisingHandle> handle_random_addr =
293       this->advertiser()->LastUsedHandleForTesting();
294   ASSERT_TRUE(handle_random_addr);
295 
296   // check everything is correct
297   EXPECT_EQ(2u, this->advertiser()->NumAdvertisements());
298   EXPECT_TRUE(this->advertiser()->IsAdvertising());
299   EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress,
300                                                 /*extended_pdu=*/false));
301   EXPECT_TRUE(this->advertiser()->IsAdvertising(kRandomAddress,
302                                                 /*extended_pdu=*/false));
303 
304   // Stop advertising
305   this->advertiser()->StopAdvertising();
306   this->RunUntilIdle();
307 
308   // Check that advertiser and controller both report not advertising
309   EXPECT_EQ(0u, this->advertiser()->NumAdvertisements());
310   EXPECT_FALSE(this->advertiser()->IsAdvertising());
311   EXPECT_FALSE(this->advertiser()->IsAdvertising(kPublicAddress,
312                                                  /*extended_pdu=*/false));
313   EXPECT_FALSE(this->advertiser()->IsAdvertising(kRandomAddress,
314                                                  /*extended_pdu=*/false));
315 
316   const LEAdvertisingState& public_addr_state =
317       this->test_device()->extended_advertising_state(
318           handle_public_addr.value());
319   const LEAdvertisingState& random_addr_state =
320       this->test_device()->extended_advertising_state(
321           handle_random_addr.value());
322 
323   constexpr uint8_t blank[hci_spec::kMaxLEAdvertisingDataLength] = {0};
324 
325   EXPECT_FALSE(public_addr_state.enabled);
326   EXPECT_EQ(0,
327             std::memcmp(blank,
328                         public_addr_state.data,
329                         hci_spec::kMaxLEAdvertisingDataLength));
330   EXPECT_EQ(0, public_addr_state.data_length);
331   EXPECT_EQ(0,
332             std::memcmp(blank,
333                         public_addr_state.data,
334                         hci_spec::kMaxLEAdvertisingDataLength));
335   EXPECT_EQ(0, public_addr_state.scan_rsp_length);
336 
337   EXPECT_FALSE(random_addr_state.enabled);
338   EXPECT_EQ(0,
339             std::memcmp(blank,
340                         random_addr_state.data,
341                         hci_spec::kMaxLEAdvertisingDataLength));
342   EXPECT_EQ(0, random_addr_state.data_length);
343   EXPECT_EQ(0,
344             std::memcmp(blank,
345                         random_addr_state.data,
346                         hci_spec::kMaxLEAdvertisingDataLength));
347   EXPECT_EQ(0, random_addr_state.scan_rsp_length);
348 }
349 
TYPED_TEST(LowEnergyMultipleAdvertisingTest,StopAdvertisingSingleAdvertisement)350 TYPED_TEST(LowEnergyMultipleAdvertisingTest,
351            StopAdvertisingSingleAdvertisement) {
352   this->test_device()->set_num_supported_advertising_sets(2);
353 
354   AdvertisingData ad = this->GetExampleData();
355   AdvertisingData scan_data = this->GetExampleData();
356 
357   // start public address advertising
358   AdvertisingOptions public_options(kTestInterval,
359                                     kDefaultNoAdvFlags,
360                                     /*extended_pdu=*/false,
361                                     /*anonymous=*/false,
362                                     /*include_tx_power_level=*/false);
363   this->advertiser()->StartAdvertising(kPublicAddress,
364                                        ad,
365                                        scan_data,
366                                        public_options,
367                                        /*connect_callback=*/nullptr,
368                                        this->MakeExpectSuccessCallback());
369   this->RunUntilIdle();
370   std::optional<hci_spec::AdvertisingHandle> handle_public_addr =
371       this->advertiser()->LastUsedHandleForTesting();
372   ASSERT_TRUE(handle_public_addr);
373 
374   // start random address advertising
375   constexpr AdvertisingIntervalRange random_interval(
376       hci_spec::kLEAdvertisingIntervalMin + 1u,
377       hci_spec::kLEAdvertisingIntervalMax - 1u);
378   AdvertisingOptions random_options(random_interval,
379                                     kDefaultNoAdvFlags,
380                                     /*extended_pdu=*/false,
381                                     /*anonymous=*/false,
382                                     /*include_tx_power_level=*/false);
383   this->advertiser()->StartAdvertising(kRandomAddress,
384                                        ad,
385                                        scan_data,
386                                        random_options,
387                                        /*connect_callback=*/nullptr,
388                                        this->MakeExpectSuccessCallback());
389   this->RunUntilIdle();
390   std::optional<hci_spec::AdvertisingHandle> handle_random_addr =
391       this->advertiser()->LastUsedHandleForTesting();
392   ASSERT_TRUE(handle_random_addr);
393 
394   // check everything is correct
395   EXPECT_TRUE(this->advertiser()->IsAdvertising());
396   EXPECT_EQ(2u, this->advertiser()->NumAdvertisements());
397   EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress,
398                                                 /*extended_pdu=*/false));
399   EXPECT_TRUE(this->advertiser()->IsAdvertising(kRandomAddress,
400                                                 /*extended_pdu=*/false));
401 
402   // Stop advertising the random address
403   this->advertiser()->StopAdvertising(kRandomAddress, /*extended_pdu=*/false);
404   this->RunUntilIdle();
405 
406   // Check that advertiser and controller both report the same advertising state
407   EXPECT_TRUE(this->advertiser()->IsAdvertising());
408   EXPECT_EQ(1u, this->advertiser()->NumAdvertisements());
409   EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress,
410                                                 /*extended_pdu=*/false));
411   EXPECT_FALSE(this->advertiser()->IsAdvertising(kRandomAddress,
412                                                  /*extended_pdu=*/false));
413 
414   constexpr uint8_t blank[hci_spec::kMaxLEAdvertisingDataLength] = {0};
415 
416   {
417     const LEAdvertisingState& public_addr_state =
418         this->test_device()->extended_advertising_state(
419             handle_public_addr.value());
420     const LEAdvertisingState& random_addr_state =
421         this->test_device()->extended_advertising_state(
422             handle_random_addr.value());
423 
424     EXPECT_TRUE(public_addr_state.enabled);
425     EXPECT_NE(0,
426               std::memcmp(blank,
427                           public_addr_state.data,
428                           hci_spec::kMaxLEAdvertisingDataLength));
429     EXPECT_NE(0, public_addr_state.data_length);
430     EXPECT_NE(0,
431               std::memcmp(blank,
432                           public_addr_state.data,
433                           hci_spec::kMaxLEAdvertisingDataLength));
434     EXPECT_NE(0, public_addr_state.scan_rsp_length);
435 
436     EXPECT_FALSE(random_addr_state.enabled);
437     EXPECT_EQ(0,
438               std::memcmp(blank,
439                           random_addr_state.data,
440                           hci_spec::kMaxLEAdvertisingDataLength));
441     EXPECT_EQ(0, random_addr_state.data_length);
442     EXPECT_EQ(0,
443               std::memcmp(blank,
444                           random_addr_state.data,
445                           hci_spec::kMaxLEAdvertisingDataLength));
446     EXPECT_EQ(0, random_addr_state.scan_rsp_length);
447   }
448 
449   // stop advertising the public address
450   this->advertiser()->StopAdvertising(kPublicAddress, /*extended_pdu=*/false);
451   this->RunUntilIdle();
452 
453   {
454     const LEAdvertisingState& public_addr_state =
455         this->test_device()->extended_advertising_state(
456             handle_public_addr.value());
457     const LEAdvertisingState& random_addr_state =
458         this->test_device()->extended_advertising_state(
459             handle_random_addr.value());
460 
461     // Check that advertiser and controller both report the same advertising
462     // state
463     EXPECT_FALSE(this->advertiser()->IsAdvertising());
464     EXPECT_EQ(0u, this->advertiser()->NumAdvertisements());
465     EXPECT_FALSE(this->advertiser()->IsAdvertising(kPublicAddress,
466                                                    /*extended_pdu=*/false));
467     EXPECT_FALSE(this->advertiser()->IsAdvertising(kRandomAddress,
468                                                    /*extended_pdu=*/false));
469 
470     EXPECT_FALSE(public_addr_state.enabled);
471     EXPECT_EQ(0,
472               std::memcmp(blank,
473                           public_addr_state.data,
474                           hci_spec::kMaxLEAdvertisingDataLength));
475     EXPECT_EQ(0, public_addr_state.data_length);
476     EXPECT_EQ(0,
477               std::memcmp(blank,
478                           public_addr_state.data,
479                           hci_spec::kMaxLEAdvertisingDataLength));
480     EXPECT_EQ(0, public_addr_state.scan_rsp_length);
481 
482     EXPECT_FALSE(random_addr_state.enabled);
483     EXPECT_EQ(0,
484               std::memcmp(blank,
485                           random_addr_state.data,
486                           hci_spec::kMaxLEAdvertisingDataLength));
487     EXPECT_EQ(0, random_addr_state.data_length);
488     EXPECT_EQ(0,
489               std::memcmp(blank,
490                           random_addr_state.data,
491                           hci_spec::kMaxLEAdvertisingDataLength));
492     EXPECT_EQ(0, random_addr_state.scan_rsp_length);
493   }
494 }
495 
TYPED_TEST(LowEnergyMultipleAdvertisingTest,SuccessiveAdvertisingCalls)496 TYPED_TEST(LowEnergyMultipleAdvertisingTest, SuccessiveAdvertisingCalls) {
497   this->test_device()->set_num_supported_advertising_sets(2);
498 
499   AdvertisingData ad = this->GetExampleData();
500   AdvertisingData scan_data = this->GetExampleData();
501   AdvertisingOptions options(kTestInterval,
502                              kDefaultNoAdvFlags,
503                              /*extended_pdu=*/false,
504                              /*anonymous=*/false,
505                              /*include_tx_power_level=*/false);
506 
507   this->advertiser()->StartAdvertising(kPublicAddress,
508                                        ad,
509                                        scan_data,
510                                        options,
511                                        /*connect_callback=*/nullptr,
512                                        this->MakeExpectSuccessCallback());
513   this->advertiser()->StartAdvertising(kRandomAddress,
514                                        ad,
515                                        scan_data,
516                                        options,
517                                        /*connect_callback=*/nullptr,
518                                        this->MakeExpectSuccessCallback());
519 
520   this->RunUntilIdle();
521   EXPECT_TRUE(this->advertiser()->IsAdvertising());
522   EXPECT_EQ(2u, this->advertiser()->NumAdvertisements());
523   EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress,
524                                                 /*extended_pdu=*/false));
525   EXPECT_TRUE(this->advertiser()->IsAdvertising(kRandomAddress,
526                                                 /*extended_pdu=*/false));
527 
528   this->advertiser()->StopAdvertising(kPublicAddress, /*extended_pdu=*/false);
529   this->advertiser()->StopAdvertising(kRandomAddress, /*extended_pdu=*/false);
530 
531   this->RunUntilIdle();
532   EXPECT_FALSE(this->advertiser()->IsAdvertising());
533   EXPECT_EQ(0u, this->advertiser()->NumAdvertisements());
534   EXPECT_FALSE(this->advertiser()->IsAdvertising(kPublicAddress,
535                                                  /*extended_pdu=*/false));
536   EXPECT_FALSE(this->advertiser()->IsAdvertising(kRandomAddress,
537                                                  /*extended_pdu=*/false));
538 }
539 
TYPED_TEST(LowEnergyMultipleAdvertisingTest,InterleavedAdvertisingCalls)540 TYPED_TEST(LowEnergyMultipleAdvertisingTest, InterleavedAdvertisingCalls) {
541   this->test_device()->set_num_supported_advertising_sets(
542       this->max_advertisements());
543 
544   AdvertisingData ad = this->GetExampleData();
545   AdvertisingData scan_data = this->GetExampleData();
546   AdvertisingOptions options(kTestInterval,
547                              kDefaultNoAdvFlags,
548                              /*extended_pdu=*/false,
549                              /*anonymous=*/false,
550                              /*include_tx_power_level=*/false);
551 
552   this->advertiser()->StartAdvertising(kPublicAddress,
553                                        ad,
554                                        scan_data,
555                                        options,
556                                        /*connect_callback=*/nullptr,
557                                        this->MakeExpectSuccessCallback());
558   this->advertiser()->StopAdvertising(kPublicAddress, /*extended_pdu=*/false);
559   this->advertiser()->StartAdvertising(kPublicAddress,
560                                        ad,
561                                        scan_data,
562                                        options,
563                                        /*connect_callback=*/nullptr,
564                                        this->MakeExpectSuccessCallback());
565 
566   this->RunUntilIdle();
567   EXPECT_TRUE(this->advertiser()->IsAdvertising());
568   EXPECT_EQ(1u, this->advertiser()->NumAdvertisements());
569   EXPECT_TRUE(this->advertiser()->IsAdvertising(kPublicAddress,
570                                                 /*extended_pdu=*/false));
571   EXPECT_FALSE(this->advertiser()->IsAdvertising(kRandomAddress,
572                                                  /*extended_pdu=*/false));
573 }
574 
TYPED_TEST(LowEnergyMultipleAdvertisingTest,StopWhileStarting)575 TYPED_TEST(LowEnergyMultipleAdvertisingTest, StopWhileStarting) {
576   AdvertisingData ad = this->GetExampleData();
577   AdvertisingData scan_data = this->GetExampleData();
578   AdvertisingOptions options(kTestInterval,
579                              kDefaultNoAdvFlags,
580                              /*extended_pdu=*/false,
581                              /*anonymous=*/false,
582                              /*include_tx_power_level=*/false);
583 
584   this->advertiser()->StartAdvertising(kPublicAddress,
585                                        ad,
586                                        scan_data,
587                                        options,
588                                        /*connect_callback=*/nullptr,
589                                        this->MakeExpectSuccessCallback());
590   this->advertiser()->StopAdvertising(kPublicAddress, /*extended_pdu=*/false);
591 
592   this->RunUntilIdle();
593   EXPECT_TRUE(this->GetLastStatus());
594 
595   std::optional<hci_spec::AdvertisingHandle> handle =
596       this->advertiser()->LastUsedHandleForTesting();
597   ASSERT_TRUE(handle);
598 
599   EXPECT_FALSE(
600       this->test_device()->extended_advertising_state(handle.value()).enabled);
601 }
602 
603 }  // namespace
604 }  // namespace bt::hci
605