1 /*
2  * Copyright 2021 HIMSA II K/S - www.himsa.com.
3  * Represented by EHIMA - www.ehima.com
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include "state_machine.h"
19 
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22 
23 #include <future>
24 
25 #include "../le_audio_types.h"
26 #include "broadcast_configuration_provider.h"
27 #include "btm_iso_api.h"
28 #include "stack/include/btm_ble_api_types.h"
29 #include "state_machine.h"
30 #include "test/common/mock_functions.h"
31 #include "test/mock/mock_main_shim_le_advertising_manager.h"
32 #include "test/mock/mock_stack_btm_iso.h"
33 
34 using namespace bluetooth::hci::iso_manager;
35 
36 using bluetooth::hci::IsoManager;
37 using bluetooth::le_audio::BasicAudioAnnouncementData;
38 using testing::_;
39 using testing::Mock;
40 using testing::SaveArg;
41 using testing::Test;
42 
43 // Disables most likely false-positives from base::SplitString()
__asan_default_options()44 extern "C" const char* __asan_default_options() {
45   return "detect_container_overflow=0";
46 }
47 
btsnd_hcic_ble_rand(base::Callback<void (BT_OCTET8)> cb)48 void btsnd_hcic_ble_rand(base::Callback<void(BT_OCTET8)> cb) {}
49 
50 namespace bluetooth::le_audio {
51 namespace broadcaster {
52 namespace {
53 // bit 0: encrypted, bit 1: standard quality present
54 static const uint8_t test_public_broadcast_features = 0x3;
55 static const std::string test_broadcast_name = "Test";
56 static const std::vector<uint8_t> default_public_metadata = {
57     5,   bluetooth::le_audio::types::kLeAudioMetadataTypeProgramInfo,
58     0x1, 0x2,
59     0x3, 0x4};
60 
61 class MockBroadcastStatMachineCallbacks
62     : public IBroadcastStateMachineCallbacks {
63  public:
64   MockBroadcastStatMachineCallbacks() = default;
65   MockBroadcastStatMachineCallbacks(const MockBroadcastStatMachineCallbacks&) =
66       delete;
67   MockBroadcastStatMachineCallbacks& operator=(
68       const MockBroadcastStatMachineCallbacks&) = delete;
69 
70   ~MockBroadcastStatMachineCallbacks() override = default;
71 
72   MOCK_METHOD((void), OnStateMachineCreateStatus,
73               (uint32_t broadcast_id, bool initialized), (override));
74   MOCK_METHOD((void), OnStateMachineDestroyed, (uint32_t broadcast_id),
75               (override));
76   MOCK_METHOD((void), OnStateMachineEvent,
77               (uint32_t broadcast_id, BroadcastStateMachine::State state,
78                const void* data),
79               (override));
80   MOCK_METHOD((void), OnOwnAddressResponse,
81               (uint32_t broadcast_id, uint8_t addr_type, RawAddress addr),
82               (override));
83   MOCK_METHOD((void), OnBigCreated, (const std::vector<uint16_t>& conn_handle),
84               (override));
85 };
86 
87 class MockBroadcastAdvertisingCallbacks : public AdvertisingCallbacks {
88  public:
89   MockBroadcastAdvertisingCallbacks() = default;
90   MockBroadcastAdvertisingCallbacks(const MockBroadcastAdvertisingCallbacks&) =
91       delete;
92   MockBroadcastAdvertisingCallbacks& operator=(
93       const MockBroadcastAdvertisingCallbacks&) = delete;
94 
95   ~MockBroadcastAdvertisingCallbacks() override = default;
96 
97   MOCK_METHOD((void), OnAdvertisingSetStarted,
98               (int reg_id, uint8_t advertiser_id, int8_t tx_power,
99                uint8_t status),
100               (override));
101   MOCK_METHOD((void), OnAdvertisingEnabled,
102               (uint8_t advertiser_id, bool enable, uint8_t status), (override));
103   MOCK_METHOD((void), OnAdvertisingDataSet,
104               (uint8_t advertiser_id, uint8_t status), (override));
105   MOCK_METHOD((void), OnScanResponseDataSet,
106               (uint8_t advertiser_id, uint8_t status), (override));
107   MOCK_METHOD((void), OnAdvertisingParametersUpdated,
108               (uint8_t advertiser_id, int8_t tx_power, uint8_t status),
109               (override));
110   MOCK_METHOD((void), OnPeriodicAdvertisingParametersUpdated,
111               (uint8_t advertiser_id, uint8_t status), (override));
112   MOCK_METHOD((void), OnPeriodicAdvertisingDataSet,
113               (uint8_t advertiser_id, uint8_t status), (override));
114   MOCK_METHOD((void), OnPeriodicAdvertisingEnabled,
115               (uint8_t advertiser_id, bool enable, uint8_t status), (override));
116   MOCK_METHOD((void), OnOwnAddressRead,
117               (uint8_t advertiser_id, uint8_t address_type, RawAddress address),
118               (override));
119 };
120 
121 class StateMachineTest : public Test {
122  protected:
SetUp()123   void SetUp() override {
124     reset_mock_function_count_map();
125     MockBleAdvertisingManager::Initialize();
126 
127     mock_ble_advertising_manager_ = MockBleAdvertisingManager::Get();
128 
129     sm_callbacks_.reset(new MockBroadcastStatMachineCallbacks());
130     adv_callbacks_.reset(new MockBroadcastAdvertisingCallbacks());
131     BroadcastStateMachine::Initialize(sm_callbacks_.get(),
132                                       adv_callbacks_.get());
133 
134     ON_CALL(*mock_ble_advertising_manager_, StartAdvertisingSet)
135         .WillByDefault(
136             [this](uint8_t client_id, int reg_id,
137                    BleAdvertiserInterface::IdTxPowerStatusCallback register_cb,
138                    AdvertiseParameters params,
139                    std::vector<uint8_t> advertise_data,
140                    std::vector<uint8_t> scan_response_data,
141                    PeriodicAdvertisingParameters periodic_params,
142                    std::vector<uint8_t> periodic_data, uint16_t duration,
143                    uint8_t maxExtAdvEvents,
144                    BleAdvertiserInterface::IdStatusCallback timeout_cb) {
145               static uint8_t advertiser_id = 1;
146               uint8_t tx_power = 32;
147               uint8_t status = 0;
148               this->adv_callbacks_->OnAdvertisingSetStarted(
149                   BroadcastStateMachine::kLeAudioBroadcastRegId,
150                   advertiser_id++, tx_power, status);
151             });
152 
153     ON_CALL(*mock_ble_advertising_manager_, Enable)
154         .WillByDefault(
155             [this](uint8_t advertiser_id, bool enable,
156                    BleAdvertiserInterface::StatusCallback cb, uint16_t duration,
157                    uint8_t maxExtAdvEvents,
158                    BleAdvertiserInterface::StatusCallback timeout_cb) {
159               uint8_t status = 0;
160               this->adv_callbacks_->OnAdvertisingEnabled(advertiser_id, enable,
161                                                          status);
162             });
163 
164     ON_CALL(*mock_ble_advertising_manager_, GetOwnAddress)
165         .WillByDefault(
166             [](uint8_t inst_id, BleAdvertiserInterface::GetAddressCallback cb) {
167               uint8_t address_type = 0x02;
168               RawAddress address;
169               const uint8_t addr[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
170               address.FromOctets(addr);
171               cb.Run(address_type, address);
172             });
173 
174     ON_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus)
175         .WillByDefault([this](uint32_t broadcast_id, bool initialized) {
176           auto instance_it =
177               std::find_if(pending_broadcasts_.begin(),
178                            pending_broadcasts_.end(), [broadcast_id](auto& up) {
179                              return (up->GetBroadcastId() == broadcast_id);
180                            });
181           if (instance_it != pending_broadcasts_.end()) {
182             if (initialized) {
183               broadcasts_[broadcast_id] = std::move(*instance_it);
184             }
185             pending_broadcasts_.erase(instance_it);
186           }
187           instance_creation_promise_.set_value(broadcast_id);
188         });
189 
190     ON_CALL(*(sm_callbacks_.get()), OnStateMachineDestroyed)
191         .WillByDefault([this](uint32_t broadcast_id) {
192           if (broadcasts_.count(broadcast_id)) {
193             instance_destruction_promise_.set_value(broadcast_id);
194           }
195         });
196 
197     ON_CALL(*(adv_callbacks_.get()), OnAdvertisingSetStarted)
198         .WillByDefault([this](int reg_id, uint8_t advertiser_id,
199                               int8_t tx_power, uint8_t status) {
200           pending_broadcasts_.back()->OnCreateAnnouncement(advertiser_id,
201                                                            tx_power, status);
202         });
203 
204     ON_CALL(*(adv_callbacks_.get()), OnAdvertisingEnabled)
205         .WillByDefault(
206             [this](uint8_t advertiser_id, bool enable, uint8_t status) {
207               auto const& iter = std::find_if(
208                   broadcasts_.cbegin(), broadcasts_.cend(),
209                   [advertiser_id](auto const& sm) {
210                     return sm.second->GetAdvertisingSid() == advertiser_id;
211                   });
212               if (iter != broadcasts_.cend()) {
213                 iter->second->OnEnableAnnouncement(enable, status);
214               }
215             });
216     ConfigureIsoManagerMock();
217   }
218 
ConfigureIsoManagerMock()219   void ConfigureIsoManagerMock() {
220     iso_manager_ = IsoManager::GetInstance();
221     ASSERT_NE(iso_manager_, nullptr);
222     iso_manager_->Start();
223 
224     mock_iso_manager_ = MockIsoManager::GetInstance();
225     ASSERT_NE(mock_iso_manager_, nullptr);
226 
227     ON_CALL(*mock_iso_manager_, CreateBig)
228         .WillByDefault([this](uint8_t big_id, big_create_params p) {
229           auto bit =
230               std::find_if(broadcasts_.begin(), broadcasts_.end(),
231                            [big_id](auto const& entry) {
232                              return entry.second->GetAdvertisingSid() == big_id;
233                            });
234           if (bit == broadcasts_.end()) return;
235 
236           big_create_cmpl_evt evt;
237           evt.big_id = big_id;
238 
239           // For test convenience lets encode big_id into conn_hdl MSB.
240           // NOTE: In current implementation big_id is equal to advertising SID.
241           //       This is an important detail exploited by the IsoManager mock
242           static uint8_t conn_lsb = 1;
243           uint16_t conn_msb = ((uint16_t)big_id) << 8;
244           for (auto i = 0; i < p.num_bis; ++i) {
245             evt.conn_handles.push_back(conn_msb | conn_lsb++);
246           }
247 
248           bit->second->HandleHciEvent(HCI_BLE_CREATE_BIG_CPL_EVT, &evt);
249         });
250 
251     ON_CALL(*mock_iso_manager_, SetupIsoDataPath)
252         .WillByDefault([this](uint16_t conn_handle, iso_data_path_params p) {
253           // Get the big_id encoded in conn_handle's MSB
254           uint8_t big_id = conn_handle >> 8;
255           auto bit =
256               std::find_if(broadcasts_.begin(), broadcasts_.end(),
257                            [big_id](auto const& entry) {
258                              return entry.second->GetAdvertisingSid() == big_id;
259                            });
260           if (bit == broadcasts_.end()) return;
261           bit->second->OnSetupIsoDataPath(0, conn_handle);
262         });
263 
264     ON_CALL(*mock_iso_manager_, RemoveIsoDataPath)
265         .WillByDefault([this](uint16_t conn_handle, uint8_t iso_direction) {
266           // Get the big_id encoded in conn_handle's MSB
267           uint8_t big_id = conn_handle >> 8;
268           auto bit =
269               std::find_if(broadcasts_.begin(), broadcasts_.end(),
270                            [big_id](auto const& entry) {
271                              return entry.second->GetAdvertisingSid() == big_id;
272                            });
273           if (bit == broadcasts_.end()) return;
274           bit->second->OnRemoveIsoDataPath(0, conn_handle);
275         });
276 
277     ON_CALL(*mock_iso_manager_, TerminateBig)
278         .WillByDefault([this](uint8_t big_id, uint8_t reason) {
279           // Get the big_id encoded in conn_handle's MSB
280           auto bit =
281               std::find_if(broadcasts_.begin(), broadcasts_.end(),
282                            [big_id](auto const& entry) {
283                              return entry.second->GetAdvertisingSid() == big_id;
284                            });
285           if (bit == broadcasts_.end()) return;
286 
287           big_terminate_cmpl_evt evt;
288           evt.big_id = big_id;
289           evt.reason = reason;
290 
291           bit->second->HandleHciEvent(HCI_BLE_TERM_BIG_CPL_EVT, &evt);
292         });
293   }
294 
TearDown()295   void TearDown() override {
296     iso_manager_->Stop();
297     mock_iso_manager_ = nullptr;
298     Mock::VerifyAndClearExpectations(sm_callbacks_.get());
299     Mock::VerifyAndClearExpectations(adv_callbacks_.get());
300 
301     pending_broadcasts_.clear();
302     broadcasts_.clear();
303     sm_callbacks_.reset();
304     adv_callbacks_.reset();
305 
306     MockBleAdvertisingManager::CleanUp();
307     mock_ble_advertising_manager_ = nullptr;
308   }
309 
InstantiateStateMachine(bluetooth::le_audio::types::LeAudioContextType context=bluetooth::le_audio::types::LeAudioContextType::UNSPECIFIED)310   uint32_t InstantiateStateMachine(
311       bluetooth::le_audio::types::LeAudioContextType context =
312           bluetooth::le_audio::types::LeAudioContextType::UNSPECIFIED) {
313     // We will get the state machine create status update in an async callback
314     // so let's wait for it here.
315     instance_creation_promise_ = std::promise<uint32_t>();
316     std::future<uint32_t> instance_future =
317         instance_creation_promise_.get_future();
318 
319     static uint8_t broadcast_id_lsb = 1;
320 
321     const std::vector<std::pair<types::LeAudioContextType, uint8_t>>&
322         subgroup_quality = {{context, 1}};
323     auto config = GetBroadcastConfig(subgroup_quality);
324     auto broadcast_id = broadcast_id_lsb++;
325     pending_broadcasts_.push_back(BroadcastStateMachine::CreateInstance({
326         .is_public = true,
327         .broadcast_id = broadcast_id,
328         .broadcast_name = test_broadcast_name,
329         .config = config,
330         // .announcement = ,
331         // .broadcast_code = ,
332     }));
333     pending_broadcasts_.back()->Initialize();
334     return instance_future.get();
335   }
336 
337   MockBleAdvertisingManager* mock_ble_advertising_manager_;
338   IsoManager* iso_manager_;
339   MockIsoManager* mock_iso_manager_;
340 
341   std::map<uint32_t, std::unique_ptr<BroadcastStateMachine>> broadcasts_;
342   std::vector<std::unique_ptr<BroadcastStateMachine>> pending_broadcasts_;
343   std::unique_ptr<MockBroadcastStatMachineCallbacks> sm_callbacks_;
344   std::unique_ptr<MockBroadcastAdvertisingCallbacks> adv_callbacks_;
345   std::promise<uint32_t> instance_creation_promise_;
346   std::promise<uint8_t> instance_destruction_promise_;
347 };
348 
TEST_F(StateMachineTest,CreateInstanceFailed)349 TEST_F(StateMachineTest, CreateInstanceFailed) {
350   EXPECT_CALL(*mock_ble_advertising_manager_, StartAdvertisingSet)
351       .WillOnce(
352           [this](uint8_t client_id, int reg_id,
353                  BleAdvertiserInterface::IdTxPowerStatusCallback register_cb,
354                  AdvertiseParameters params,
355                  std::vector<uint8_t> advertise_data,
356                  std::vector<uint8_t> scan_response_data,
357                  PeriodicAdvertisingParameters periodic_params,
358                  std::vector<uint8_t> periodic_data, uint16_t duration,
359                  uint8_t maxExtAdvEvents,
360                  BleAdvertiserInterface::IdStatusCallback timeout_cb) {
361             uint8_t advertiser_id = 1;
362             uint8_t tx_power = 0;
363             uint8_t status = 1;
364             this->adv_callbacks_->OnAdvertisingSetStarted(
365                 BroadcastStateMachine::kLeAudioBroadcastRegId, advertiser_id,
366                 tx_power, status);
367           });
368 
369   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, false))
370       .Times(1);
371 
372   auto broadcast_id = InstantiateStateMachine();
373   ASSERT_NE(broadcast_id, BroadcastStateMachine::kAdvSidUndefined);
374   ASSERT_TRUE(pending_broadcasts_.empty());
375   ASSERT_TRUE(broadcasts_.empty());
376 }
377 
TEST_F(StateMachineTest,CreateInstanceSuccess)378 TEST_F(StateMachineTest, CreateInstanceSuccess) {
379   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
380       .Times(1);
381 
382   auto broadcast_id = InstantiateStateMachine();
383   ASSERT_NE(broadcast_id, BroadcastStateMachine::kAdvSidUndefined);
384   ASSERT_TRUE(pending_broadcasts_.empty());
385   ASSERT_FALSE(broadcasts_.empty());
386   ASSERT_EQ(broadcasts_[broadcast_id]->GetBroadcastId(), broadcast_id);
387   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
388             BroadcastStateMachine::State::CONFIGURED);
389 }
390 
TEST_F(StateMachineTest,DestroyInstanceSuccess)391 TEST_F(StateMachineTest, DestroyInstanceSuccess) {
392   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
393       .Times(1);
394 
395   auto broadcast_id = InstantiateStateMachine();
396   ASSERT_NE(broadcast_id, BroadcastStateMachine::kAdvSidUndefined);
397   ASSERT_FALSE(broadcasts_.empty());
398 
399   instance_destruction_promise_ = std::promise<uint8_t>();
400   std::future<uint8_t> instance_future =
401       instance_destruction_promise_.get_future();
402 
403   broadcasts_.clear();
404   EXPECT_EQ(instance_future.get(), broadcast_id);
405 }
406 
TEST_F(StateMachineTest,GetAdvertisingAddress)407 TEST_F(StateMachineTest, GetAdvertisingAddress) {
408   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
409       .Times(1);
410 
411   auto broadcast_id = InstantiateStateMachine();
412   EXPECT_CALL(*(sm_callbacks_.get()), OnOwnAddressResponse(broadcast_id, _, _))
413       .Times(1);
414   broadcasts_[broadcast_id]->RequestOwnAddress();
415 }
416 
TEST_F(StateMachineTest,Mute)417 TEST_F(StateMachineTest, Mute) {
418   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
419       .Times(1);
420 
421   auto broadcast_id = InstantiateStateMachine();
422   ASSERT_TRUE(pending_broadcasts_.empty());
423   ASSERT_FALSE(broadcasts_.empty());
424 
425   ASSERT_FALSE(broadcasts_[broadcast_id]->IsMuted());
426   broadcasts_[broadcast_id]->SetMuted(true);
427   ASSERT_TRUE(broadcasts_[broadcast_id]->IsMuted());
428   broadcasts_[broadcast_id]->SetMuted(false);
429   ASSERT_FALSE(broadcasts_[broadcast_id]->IsMuted());
430 }
431 
prepareAnnouncement(const BroadcastSubgroupCodecConfig & codec_config,std::map<uint8_t,std::vector<uint8_t>> metadata)432 static BasicAudioAnnouncementData prepareAnnouncement(
433     const BroadcastSubgroupCodecConfig& codec_config,
434     std::map<uint8_t, std::vector<uint8_t>> metadata) {
435   BasicAudioAnnouncementData announcement;
436 
437   announcement.presentation_delay_us = 40000;
438   auto const& codec_id = codec_config.GetLeAudioCodecId();
439   auto const subgroup_codec_spec = codec_config.GetCommonBisCodecSpecData();
440 
441   announcement.subgroup_configs = {{
442       .codec_config =
443           {
444               .codec_id = codec_id.coding_format,
445               .vendor_company_id = codec_id.vendor_company_id,
446               .vendor_codec_id = codec_id.vendor_codec_id,
447               .codec_specific_params = subgroup_codec_spec.Values(),
448           },
449       .metadata = std::move(metadata),
450       .bis_configs = {},
451   }};
452 
453   uint8_t bis_count = 0;
454   for (uint8_t bis_idx = 0; bis_idx < codec_config.GetAllBisConfigCount();
455        ++bis_idx) {
456     for (uint8_t bis_num = 0; bis_num < codec_config.GetNumBis(bis_idx);
457          ++bis_num) {
458       ++bis_count;
459 
460       // Check for vendor byte array
461       bluetooth::le_audio::BasicAudioAnnouncementBisConfig bis_config;
462       auto vendor_config = codec_config.GetBisVendorCodecSpecData(bis_idx);
463       if (vendor_config) {
464         bis_config.vendor_codec_specific_params = vendor_config.value();
465       }
466 
467       // Check for non vendor LTVs
468       auto config_ltv = codec_config.GetBisCodecSpecData(bis_num, bis_idx);
469       if (config_ltv) {
470         bis_config.codec_specific_params = config_ltv->Values();
471       }
472 
473       // Internally BISes are indexed from 0 in each subgroup, but the BT spec
474       // requires the indices to be indexed from 1 in the entire BIG.
475       bis_config.bis_index = bis_count;
476       announcement.subgroup_configs[0].bis_configs.push_back(
477           std::move(bis_config));
478     }
479   }
480 
481   return announcement;
482 }
483 
TEST_F(StateMachineTest,UpdateAnnouncement)484 TEST_F(StateMachineTest, UpdateAnnouncement) {
485   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
486       .Times(1);
487 
488   auto broadcast_id = InstantiateStateMachine();
489   auto adv_sid = broadcasts_[broadcast_id]->GetAdvertisingSid();
490   std::vector<uint8_t> data;
491   EXPECT_CALL(*mock_ble_advertising_manager_,
492               SetPeriodicAdvertisingData(adv_sid, _, _))
493       .Times(2)
494       .WillRepeatedly(SaveArg<1>(&data));
495 
496   std::map<uint8_t, std::vector<uint8_t>> metadata = {};
497   auto codec_config = lc3_mono_16_2;
498   auto announcement = prepareAnnouncement(codec_config, metadata);
499   broadcasts_[broadcast_id]->UpdateBroadcastAnnouncement(
500       std::move(announcement));
501 
502   uint8_t first_len = data.size();
503   ASSERT_NE(first_len, 0);  // Non-zero length
504   ASSERT_EQ(data[1], BTM_BLE_AD_TYPE_SERVICE_DATA_TYPE);
505   ASSERT_EQ(data[2], (kBasicAudioAnnouncementServiceUuid & 0x00FF));
506   ASSERT_EQ(data[3], ((kBasicAudioAnnouncementServiceUuid >> 8) & 0x00FF));
507   // The rest of the packet data is already covered by the announcement tests
508 
509   // Verify that changes in the announcement makes a difference
510   metadata = {{0x01, {0x03}}};
511   announcement = prepareAnnouncement(codec_config, metadata);
512   broadcasts_[broadcast_id]->UpdateBroadcastAnnouncement(
513       std::move(announcement));
514   uint8_t second_len = data.size();
515 
516   // These should differ by the difference in metadata
517   ASSERT_EQ(first_len + types::LeAudioLtvMap(metadata).RawPacketSize(),
518             second_len);
519 }
520 
TEST_F(StateMachineTest,ProcessMessageStartWhenConfigured)521 TEST_F(StateMachineTest, ProcessMessageStartWhenConfigured) {
522   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
523       .Times(1);
524 
525   auto sound_context = bluetooth::le_audio::types::LeAudioContextType::MEDIA;
526   uint8_t num_channels = 2;
527 
528   auto broadcast_id = InstantiateStateMachine(sound_context);
529   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
530             BroadcastStateMachine::State::CONFIGURED);
531 
532   uint8_t num_bises = 0;
533   EXPECT_CALL(*mock_iso_manager_, CreateBig)
534       .WillOnce([this, &num_bises](uint8_t big_id, big_create_params p) {
535         auto bit =
536             std::find_if(broadcasts_.begin(), broadcasts_.end(),
537                          [big_id](auto const& entry) {
538                            return entry.second->GetAdvertisingSid() == big_id;
539                          });
540         if (bit == broadcasts_.end()) return;
541 
542         num_bises = p.num_bis;
543 
544         big_create_cmpl_evt evt;
545         evt.big_id = big_id;
546 
547         // For test convenience lets encode big_id into conn_hdl's
548         // MSB
549         static uint8_t conn_lsb = 1;
550         uint16_t conn_msb = ((uint16_t)big_id) << 8;
551         for (auto i = 0; i < p.num_bis; ++i) {
552           evt.conn_handles.push_back(conn_msb | conn_lsb++);
553         }
554 
555         bit->second->HandleHciEvent(HCI_BLE_CREATE_BIG_CPL_EVT, &evt);
556       });
557 
558   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(num_channels);
559   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(0);
560   EXPECT_CALL(*(sm_callbacks_.get()),
561               OnStateMachineEvent(broadcast_id,
562                                   BroadcastStateMachine::State::STREAMING, _))
563       .Times(1);
564   broadcasts_[broadcast_id]->ProcessMessage(
565       BroadcastStateMachine::Message::START);
566 
567   // Verify the right number of BISes in the BIG being created
568   ASSERT_EQ(num_bises, num_channels);
569   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
570             BroadcastStateMachine::State::STREAMING);
571 }
572 
TEST_F(StateMachineTest,ProcessMessageStopWhenConfigured)573 TEST_F(StateMachineTest, ProcessMessageStopWhenConfigured) {
574   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
575       .Times(1);
576 
577   auto broadcast_id = InstantiateStateMachine(
578       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
579   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
580             BroadcastStateMachine::State::CONFIGURED);
581 
582   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(0);
583   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(0);
584   EXPECT_CALL(*(sm_callbacks_.get()),
585               OnStateMachineEvent(broadcast_id,
586                                   BroadcastStateMachine::State::STOPPING, _))
587       .Times(1);
588   EXPECT_CALL(*(sm_callbacks_.get()),
589               OnStateMachineEvent(broadcast_id,
590                                   BroadcastStateMachine::State::STOPPED, _))
591       .Times(1);
592   broadcasts_[broadcast_id]->ProcessMessage(
593       BroadcastStateMachine::Message::STOP);
594 
595   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
596             BroadcastStateMachine::State::STOPPED);
597 }
598 
TEST_F(StateMachineTest,ProcessMessageSuspendWhenConfigured)599 TEST_F(StateMachineTest, ProcessMessageSuspendWhenConfigured) {
600   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
601       .Times(1);
602 
603   auto broadcast_id = InstantiateStateMachine(
604       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
605   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
606             BroadcastStateMachine::State::CONFIGURED);
607 
608   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(0);
609   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(0);
610   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineEvent(broadcast_id, _, _))
611       .Times(0);
612   broadcasts_[broadcast_id]->ProcessMessage(
613       BroadcastStateMachine::Message::SUSPEND);
614   // There shall be no change in state
615   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
616             BroadcastStateMachine::State::CONFIGURED);
617 }
618 
TEST_F(StateMachineTest,ProcessMessageStartWhenStreaming)619 TEST_F(StateMachineTest, ProcessMessageStartWhenStreaming) {
620   auto broadcast_id = InstantiateStateMachine(
621       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
622 
623   broadcasts_[broadcast_id]->ProcessMessage(
624       BroadcastStateMachine::Message::START);
625   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
626             BroadcastStateMachine::State::STREAMING);
627 
628   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(0);
629   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(0);
630   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineEvent(broadcast_id, _, _))
631       .Times(0);
632   broadcasts_[broadcast_id]->ProcessMessage(
633       BroadcastStateMachine::Message::START);
634 
635   // There shall be no change in state
636   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
637             BroadcastStateMachine::State::STREAMING);
638 }
639 
TEST_F(StateMachineTest,ProcessMessageStopWhenStreaming)640 TEST_F(StateMachineTest, ProcessMessageStopWhenStreaming) {
641   auto broadcast_id = InstantiateStateMachine(
642       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
643 
644   broadcasts_[broadcast_id]->ProcessMessage(
645       BroadcastStateMachine::Message::START);
646   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
647             BroadcastStateMachine::State::STREAMING);
648 
649   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(0);
650   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(2);
651   EXPECT_CALL(*(sm_callbacks_.get()),
652               OnStateMachineEvent(broadcast_id,
653                                   BroadcastStateMachine::State::STOPPING, _))
654       .Times(1);
655   EXPECT_CALL(*(sm_callbacks_.get()),
656               OnStateMachineEvent(broadcast_id,
657                                   BroadcastStateMachine::State::STOPPED, _))
658       .Times(1);
659   broadcasts_[broadcast_id]->ProcessMessage(
660       BroadcastStateMachine::Message::STOP);
661 
662   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
663             BroadcastStateMachine::State::STOPPED);
664 }
665 
TEST_F(StateMachineTest,ProcessMessageSuspendWhenStreaming)666 TEST_F(StateMachineTest, ProcessMessageSuspendWhenStreaming) {
667   auto broadcast_id = InstantiateStateMachine(
668       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
669 
670   broadcasts_[broadcast_id]->ProcessMessage(
671       BroadcastStateMachine::Message::START);
672   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
673             BroadcastStateMachine::State::STREAMING);
674 
675   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(0);
676   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(2);
677   EXPECT_CALL(*(sm_callbacks_.get()),
678               OnStateMachineEvent(broadcast_id,
679                                   BroadcastStateMachine::State::CONFIGURED, _))
680       .Times(1);
681   broadcasts_[broadcast_id]->ProcessMessage(
682       BroadcastStateMachine::Message::SUSPEND);
683 
684   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
685             BroadcastStateMachine::State::CONFIGURED);
686 }
687 
TEST_F(StateMachineTest,ProcessMessageStartWhenStopped)688 TEST_F(StateMachineTest, ProcessMessageStartWhenStopped) {
689   auto broadcast_id = InstantiateStateMachine(
690       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
691 
692   broadcasts_[broadcast_id]->ProcessMessage(
693       BroadcastStateMachine::Message::STOP);
694   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
695             BroadcastStateMachine::State::STOPPED);
696 
697   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(2);
698   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(0);
699   EXPECT_CALL(*(sm_callbacks_.get()),
700               OnStateMachineEvent(broadcast_id,
701                                   BroadcastStateMachine::State::CONFIGURING, _))
702       .Times(1);
703   EXPECT_CALL(*(sm_callbacks_.get()),
704               OnStateMachineEvent(broadcast_id,
705                                   BroadcastStateMachine::State::STREAMING, _))
706       .Times(1);
707   broadcasts_[broadcast_id]->ProcessMessage(
708       BroadcastStateMachine::Message::START);
709 
710   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
711             BroadcastStateMachine::State::STREAMING);
712 }
713 
TEST_F(StateMachineTest,ProcessMessageStopWhenStopped)714 TEST_F(StateMachineTest, ProcessMessageStopWhenStopped) {
715   auto broadcast_id = InstantiateStateMachine(
716       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
717 
718   broadcasts_[broadcast_id]->ProcessMessage(
719       BroadcastStateMachine::Message::STOP);
720   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
721             BroadcastStateMachine::State::STOPPED);
722 
723   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(0);
724   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(0);
725   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineEvent(broadcast_id, _, _))
726       .Times(0);
727   broadcasts_[broadcast_id]->ProcessMessage(
728       BroadcastStateMachine::Message::STOP);
729 
730   // There shall be no change in state
731   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
732             BroadcastStateMachine::State::STOPPED);
733 }
734 
TEST_F(StateMachineTest,ProcessMessageSuspendWhenStopped)735 TEST_F(StateMachineTest, ProcessMessageSuspendWhenStopped) {
736   auto broadcast_id = InstantiateStateMachine(
737       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
738 
739   broadcasts_[broadcast_id]->ProcessMessage(
740       BroadcastStateMachine::Message::STOP);
741   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
742             BroadcastStateMachine::State::STOPPED);
743 
744   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(0);
745   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath).Times(0);
746   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineEvent(broadcast_id, _, _))
747       .Times(0);
748   broadcasts_[broadcast_id]->ProcessMessage(
749       BroadcastStateMachine::Message::SUSPEND);
750 
751   // There shall be no change in state
752   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
753             BroadcastStateMachine::State::STOPPED);
754 }
755 
TEST_F(StateMachineTest,OnSetupIsoDataPathError)756 TEST_F(StateMachineTest, OnSetupIsoDataPathError) {
757   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
758       .Times(1);
759 
760   auto broadcast_id = InstantiateStateMachine(
761       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
762   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
763             BroadcastStateMachine::State::CONFIGURED);
764 
765   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath)
766       .WillOnce([this](uint16_t conn_handle, iso_data_path_params p) {
767         // Get the big_id encoded in conn_handle's MSB
768         uint8_t big_id = conn_handle >> 8;
769         auto bit =
770             std::find_if(broadcasts_.begin(), broadcasts_.end(),
771                          [big_id](auto const& entry) {
772                            return entry.second->GetAdvertisingSid() == big_id;
773                          });
774         if (bit == broadcasts_.end()) return;
775         bit->second->OnSetupIsoDataPath(0, conn_handle);
776       })
777       .WillOnce([this](uint16_t conn_handle, iso_data_path_params p) {
778         // Get the big_id encoded in conn_handle's MSB
779         uint8_t big_id = conn_handle >> 8;
780         auto bit =
781             std::find_if(broadcasts_.begin(), broadcasts_.end(),
782                          [big_id](auto const& entry) {
783                            return entry.second->GetAdvertisingSid() == big_id;
784                          });
785         if (bit == broadcasts_.end()) return;
786         bit->second->OnSetupIsoDataPath(1, conn_handle);
787       })
788       .RetiresOnSaturation();
789   broadcasts_[broadcast_id]->ProcessMessage(
790       BroadcastStateMachine::Message::START);
791 
792   // On datapath setup failure we should go back to configured with BIG being
793   // destroyed. Maybe it will work out next time for the new BIG.
794   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
795             BroadcastStateMachine::State::CONFIGURED);
796 
797   // And still be able to start again
798   ON_CALL(*mock_iso_manager_, SetupIsoDataPath)
799       .WillByDefault([this](uint16_t conn_handle, iso_data_path_params p) {
800         // Get the big_id encoded in conn_handle's MSB
801         uint8_t big_id = conn_handle >> 8;
802         auto bit =
803             std::find_if(broadcasts_.begin(), broadcasts_.end(),
804                          [big_id](auto const& entry) {
805                            return entry.second->GetAdvertisingSid() == big_id;
806                          });
807         if (bit == broadcasts_.end()) return;
808         bit->second->OnSetupIsoDataPath(0, conn_handle);
809       });
810   EXPECT_CALL(*mock_iso_manager_, SetupIsoDataPath).Times(2);
811 
812   broadcasts_[broadcast_id]->ProcessMessage(
813       BroadcastStateMachine::Message::START);
814   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
815             BroadcastStateMachine::State::STREAMING);
816 }
817 
TEST_F(StateMachineTest,OnRemoveIsoDataPathError)818 TEST_F(StateMachineTest, OnRemoveIsoDataPathError) {
819   auto broadcast_id = InstantiateStateMachine(
820       bluetooth::le_audio::types::LeAudioContextType::MEDIA);
821 
822   broadcasts_[broadcast_id]->ProcessMessage(
823       BroadcastStateMachine::Message::START);
824   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
825             BroadcastStateMachine::State::STREAMING);
826 
827   EXPECT_CALL(*mock_iso_manager_, RemoveIsoDataPath)
828       .WillOnce([this](uint16_t conn_handle, uint8_t iso_direction) {
829         // Get the big_id encoded in conn_handle's MSB
830         uint8_t big_id = conn_handle >> 8;
831         auto bit =
832             std::find_if(broadcasts_.begin(), broadcasts_.end(),
833                          [big_id](auto const& entry) {
834                            return entry.second->GetAdvertisingSid() == big_id;
835                          });
836         if (bit == broadcasts_.end()) return;
837         bit->second->OnRemoveIsoDataPath(0, conn_handle);
838       })
839       .WillOnce([this](uint16_t conn_handle, uint8_t iso_direction) {
840         // Get the big_id encoded in conn_handle's MSB
841         uint8_t big_id = conn_handle >> 8;
842         auto bit =
843             std::find_if(broadcasts_.begin(), broadcasts_.end(),
844                          [big_id](auto const& entry) {
845                            return entry.second->GetAdvertisingSid() == big_id;
846                          });
847         if (bit == broadcasts_.end()) return;
848         bit->second->OnRemoveIsoDataPath(1, conn_handle);
849       })
850       .RetiresOnSaturation();
851   broadcasts_[broadcast_id]->ProcessMessage(
852       BroadcastStateMachine::Message::SUSPEND);
853 
854   // On datapath teardown failure we should stay in CONFIGURED with BIG being
855   // destroyed.
856   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
857             BroadcastStateMachine::State::CONFIGURED);
858 
859   // And still be able to start again
860   broadcasts_[broadcast_id]->ProcessMessage(
861       BroadcastStateMachine::Message::START);
862   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
863             BroadcastStateMachine::State::STREAMING);
864 }
865 
TEST_F(StateMachineTest,GetConfig)866 TEST_F(StateMachineTest, GetConfig) {
867   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
868       .Times(1);
869 
870   auto sound_context = bluetooth::le_audio::types::LeAudioContextType::MEDIA;
871   uint8_t num_channels = 2;
872 
873   auto broadcast_id = InstantiateStateMachine(sound_context);
874   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
875             BroadcastStateMachine::State::CONFIGURED);
876 
877   std::optional<BigConfig> const& big_cfg =
878       broadcasts_[broadcast_id]->GetBigConfig();
879   ASSERT_FALSE(big_cfg.has_value());
880 
881   broadcasts_[broadcast_id]->ProcessMessage(
882       BroadcastStateMachine::Message::START);
883   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
884             BroadcastStateMachine::State::STREAMING);
885 
886   ASSERT_TRUE(big_cfg.has_value());
887   ASSERT_EQ(big_cfg->status, 0);
888   // This is an implementation specific thing
889   ASSERT_EQ(big_cfg->big_id, broadcasts_[broadcast_id]->GetAdvertisingSid());
890   ASSERT_EQ(big_cfg->connection_handles.size(), num_channels);
891 }
892 
TEST_F(StateMachineTest,GetBroadcastId)893 TEST_F(StateMachineTest, GetBroadcastId) {
894   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
895       .Times(1);
896 
897   auto broadcast_id = InstantiateStateMachine();
898   ASSERT_NE(bluetooth::le_audio::kBroadcastIdInvalid, broadcast_id);
899   ASSERT_EQ(broadcasts_[broadcast_id]->GetState(),
900             BroadcastStateMachine::State::CONFIGURED);
901 }
902 
TEST_F(StateMachineTest,IsPublicBroadcast)903 TEST_F(StateMachineTest, IsPublicBroadcast) {
904   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
905       .Times(1);
906 
907   auto broadcast_id = InstantiateStateMachine();
908   ASSERT_EQ(broadcasts_[broadcast_id]->IsPublicBroadcast(), true);
909 }
910 
TEST_F(StateMachineTest,GetBroadcastName)911 TEST_F(StateMachineTest, GetBroadcastName) {
912   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
913       .Times(1);
914 
915   auto broadcast_id = InstantiateStateMachine();
916   ASSERT_EQ(broadcasts_[broadcast_id]->GetBroadcastName(), test_broadcast_name);
917 }
918 
TEST_F(StateMachineTest,GetBroadcastAnnouncement)919 TEST_F(StateMachineTest, GetBroadcastAnnouncement) {
920   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
921       .Times(1);
922 
923   auto broadcast_id = InstantiateStateMachine();
924   std::map<uint8_t, std::vector<uint8_t>> metadata = {};
925   auto codec_config = lc3_mono_16_2;
926   auto announcement = prepareAnnouncement(codec_config, metadata);
927   broadcasts_[broadcast_id]->UpdateBroadcastAnnouncement(announcement);
928 
929   ASSERT_EQ(announcement,
930             broadcasts_[broadcast_id]->GetBroadcastAnnouncement());
931 }
932 
TEST_F(StateMachineTest,GetPublicBroadcastAnnouncement)933 TEST_F(StateMachineTest, GetPublicBroadcastAnnouncement) {
934   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
935       .Times(1);
936 
937   auto broadcast_id = InstantiateStateMachine();
938   bool is_public_metadata_valid;
939   types::LeAudioLtvMap public_ltv = types::LeAudioLtvMap::Parse(
940       default_public_metadata.data(), default_public_metadata.size(),
941       is_public_metadata_valid);
942   bluetooth::le_audio::PublicBroadcastAnnouncementData pb_announcement = {
943       .features = test_public_broadcast_features,
944       .metadata = public_ltv.Values()};
945 
946   broadcasts_[broadcast_id]->UpdatePublicBroadcastAnnouncement(
947       broadcast_id, test_broadcast_name, pb_announcement);
948 
949   ASSERT_EQ(pb_announcement,
950             broadcasts_[broadcast_id]->GetPublicBroadcastAnnouncement());
951 }
952 
TEST_F(StateMachineTest,AnnouncementTest)953 TEST_F(StateMachineTest, AnnouncementTest) {
954   AdvertiseParameters adv_params;
955   std::vector<uint8_t> a_data;
956   std::vector<uint8_t> p_data;
957 
958   EXPECT_CALL(*mock_ble_advertising_manager_, StartAdvertisingSet)
959       .WillOnce([this, &p_data, &a_data, &adv_params](
960                     uint8_t client_id, int reg_id,
961                     BleAdvertiserInterface::IdTxPowerStatusCallback register_cb,
962                     AdvertiseParameters params,
963                     std::vector<uint8_t> advertise_data,
964                     std::vector<uint8_t> scan_response_data,
965                     PeriodicAdvertisingParameters periodic_params,
966                     std::vector<uint8_t> periodic_data, uint16_t duration,
967                     uint8_t maxExtAdvEvents,
968                     BleAdvertiserInterface::IdStatusCallback timeout_cb) {
969         uint8_t advertiser_id = 1;
970         uint8_t tx_power = 0;
971         uint8_t status = 0;
972 
973         // Since we are not using these buffers in this callback it is safe to
974         // move them.
975         a_data = std::move(advertise_data);
976         p_data = std::move(periodic_data);
977 
978         adv_params = params;
979 
980         this->adv_callbacks_->OnAdvertisingSetStarted(
981             BroadcastStateMachine::kLeAudioBroadcastRegId, advertiser_id,
982             tx_power, status);
983       });
984 
985   EXPECT_CALL(*(sm_callbacks_.get()), OnStateMachineCreateStatus(_, true))
986       .Times(1);
987 
988   auto broadcast_id = InstantiateStateMachine();
989   ASSERT_NE(broadcast_id, BroadcastStateMachine::kAdvSidUndefined);
990 
991   // Check ext. advertising data for Broadcast Announcement UUID
992   ASSERT_NE(a_data[0], 0);     // size
993   ASSERT_EQ(a_data[1], 0x16);  // BTM_BLE_AD_TYPE_SERVICE_DATA_TYPE
994   ASSERT_EQ(a_data[2], (kBroadcastAudioAnnouncementServiceUuid & 0x00FF));
995   ASSERT_EQ(a_data[3],
996             ((kBroadcastAudioAnnouncementServiceUuid >> 8) & 0x00FF));
997   ASSERT_EQ(a_data[4], (broadcast_id & 0x0000FF));
998   ASSERT_EQ(a_data[5], ((broadcast_id >> 8) & 0x0000FF));
999   ASSERT_EQ(a_data[6], ((broadcast_id >> 16) & 0x0000FF));
1000 
1001   ASSERT_NE(a_data[7], 0);     // size
1002   ASSERT_EQ(a_data[8], 0x16);  // BTM_BLE_AD_TYPE_SERVICE_DATA_TYPE
1003   ASSERT_EQ(a_data[9], (kPublicBroadcastAnnouncementServiceUuid & 0x00FF));
1004   ASSERT_EQ(a_data[10],
1005             ((kPublicBroadcastAnnouncementServiceUuid >> 8) & 0x00FF));
1006 
1007   // Check periodic data for Basic Announcement UUID
1008   ASSERT_NE(p_data[0], 0);     // size
1009   ASSERT_EQ(p_data[1], 0x16);  // BTM_BLE_AD_TYPE_SERVICE_DATA_TYPE
1010   ASSERT_EQ(p_data[2], (kBasicAudioAnnouncementServiceUuid & 0x00FF));
1011   ASSERT_EQ(p_data[3], ((kBasicAudioAnnouncementServiceUuid >> 8) & 0x00FF));
1012 
1013   // Check advertising parameters
1014   ASSERT_EQ(adv_params.own_address_type,
1015             BroadcastStateMachine::kBroadcastAdvertisingType);
1016 }
1017 
TEST_F(StateMachineTest,GetMetadataBeforeGettingAddress)1018 TEST_F(StateMachineTest, GetMetadataBeforeGettingAddress) {
1019   unsigned int broadcast_id = 0;
1020 
1021   BleAdvertiserInterface::GetAddressCallback cb;
1022 
1023   /* Address should be already known after notifying callback recipients */
1024   EXPECT_CALL(
1025       *(sm_callbacks_.get()),
1026       OnStateMachineEvent(_, BroadcastStateMachine::State::CONFIGURED, _))
1027       .WillOnce([this](uint32_t broadcast_id,
1028                        BroadcastStateMachine::State state, const void* data) {
1029         RawAddress test_address;
1030 
1031         RawAddress::FromString("00:00:00:00:00:00", test_address);
1032         ASSERT_NE(test_address,
1033                   this->broadcasts_[broadcast_id]->GetOwnAddress());
1034       });
1035 
1036   broadcast_id = InstantiateStateMachine();
1037   ASSERT_NE(broadcast_id, 0u);
1038   ASSERT_TRUE(pending_broadcasts_.empty());
1039   ASSERT_FALSE(broadcasts_.empty());
1040   ASSERT_TRUE(broadcasts_[broadcast_id]->GetBroadcastId() == broadcast_id);
1041 }
1042 
1043 }  // namespace
1044 }  // namespace broadcaster
1045 }  // namespace bluetooth::le_audio
1046