1 /*
2 * Copyright 2020 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 <gmock/gmock.h>
19 #include <gtest/gtest.h>
20
21 #include "btm_iso_api.h"
22 #include "hci/include/hci_layer.h"
23 #include "main/shim/shim.h"
24 #include "mock_controller.h"
25 #include "mock_hcic_layer.h"
26 #include "osi/include/allocator.h"
27 #include "stack/btm/btm_dev.h"
28 #include "stack/include/bt_hdr.h"
29 #include "stack/include/hci_error_code.h"
30 #include "stack/include/hcidefs.h"
31
32 using bluetooth::hci::IsoManager;
33 using testing::_;
34 using testing::AnyNumber;
35 using testing::AtLeast;
36 using testing::Eq;
37 using testing::Matcher;
38 using testing::Return;
39 using testing::SaveArg;
40 using testing::StrictMock;
41 using testing::Test;
42
43 // Iso Manager currently works on top of the legacy HCI layer
is_gd_shim_enabled()44 bool bluetooth::shim::is_gd_shim_enabled() { return false; }
45
46 // for function pointer testing purpose
47 bool IsIsoActive = false;
48
btm_find_dev_by_handle(uint16_t handle)49 tBTM_SEC_DEV_REC* btm_find_dev_by_handle(uint16_t handle) { return nullptr; }
BTM_LogHistory(const std::string & tag,const RawAddress & bd_addr,const std::string & msg,const std::string & extra)50 void BTM_LogHistory(const std::string& tag, const RawAddress& bd_addr,
51 const std::string& msg, const std::string& extra) {}
52
53 namespace bte {
54 class BteInterface {
55 public:
56 virtual void HciSend(BT_HDR* p_msg, uint16_t event) = 0;
57 virtual ~BteInterface() = default;
58 };
59
60 class MockBteInterface : public BteInterface {
61 public:
62 MOCK_METHOD((void), HciSend, (BT_HDR * p_msg, uint16_t event), (override));
63 };
64
65 static MockBteInterface* bte_interface = nullptr;
SetMockBteInterface(MockBteInterface * interface)66 static void SetMockBteInterface(MockBteInterface* interface) {
67 bte_interface = interface;
68 }
69 } // namespace bte
70
bte_main_hci_send(BT_HDR * p_msg,uint16_t event)71 void bte_main_hci_send(BT_HDR* p_msg, uint16_t event) {
72 bte::bte_interface->HciSend(p_msg, event);
73 osi_free(p_msg);
74 }
75
76 namespace {
77 class MockCigCallbacks : public bluetooth::hci::iso_manager::CigCallbacks {
78 public:
79 MockCigCallbacks() = default;
80 MockCigCallbacks(const MockCigCallbacks&) = delete;
81 MockCigCallbacks& operator=(const MockCigCallbacks&) = delete;
82
83 ~MockCigCallbacks() override = default;
84
85 MOCK_METHOD((void), OnSetupIsoDataPath,
86 (uint8_t status, uint16_t conn_handle, uint8_t cig_id),
87 (override));
88 MOCK_METHOD((void), OnRemoveIsoDataPath,
89 (uint8_t status, uint16_t conn_handle, uint8_t cig_id),
90 (override));
91 MOCK_METHOD((void), OnIsoLinkQualityRead,
92 (uint8_t conn_handle, uint8_t cig_id, uint32_t txUnackedPackets,
93 uint32_t txFlushedPackets, uint32_t txLastSubeventPackets,
94 uint32_t retransmittedPackets, uint32_t crcErrorPackets,
95 uint32_t rxUnreceivedPackets, uint32_t duplicatePackets),
96 (override));
97
98 MOCK_METHOD((void), OnCisEvent, (uint8_t event, void* data), (override));
99 MOCK_METHOD((void), OnCigEvent, (uint8_t event, void* data), (override));
100 };
101
102 class MockBigCallbacks : public bluetooth::hci::iso_manager::BigCallbacks {
103 public:
104 MockBigCallbacks() = default;
105 MockBigCallbacks(const MockBigCallbacks&) = delete;
106 MockBigCallbacks& operator=(const MockBigCallbacks&) = delete;
107
108 ~MockBigCallbacks() override = default;
109
110 MOCK_METHOD((void), OnSetupIsoDataPath,
111 (uint8_t status, uint16_t conn_handle, uint8_t big_id),
112 (override));
113 MOCK_METHOD((void), OnRemoveIsoDataPath,
114 (uint8_t status, uint16_t conn_handle, uint8_t big_id),
115 (override));
116
117 MOCK_METHOD((void), OnBigEvent, (uint8_t event, void* data), (override));
118 };
119 } // namespace
120
121 class IsoManagerTest : public Test {
122 protected:
SetUp()123 void SetUp() override {
124 bte::SetMockBteInterface(&bte_interface_);
125 hcic::SetMockHcicInterface(&hcic_interface_);
126 controller::SetMockControllerInterface(&controller_interface_);
127
128 big_callbacks_.reset(new MockBigCallbacks());
129 cig_callbacks_.reset(new MockCigCallbacks());
130 IsIsoActive = false;
131
132 EXPECT_CALL(controller_interface_, GetIsoBufferCount())
133 .Times(AtLeast(1))
134 .WillRepeatedly(Return(6));
135 EXPECT_CALL(controller_interface_, GetIsoDataSize())
136 .Times(AtLeast(1))
137 .WillRepeatedly(Return(1024));
138
139 InitIsoManager();
140 }
141
TearDown()142 void TearDown() override {
143 CleanupIsoManager();
144
145 big_callbacks_.reset();
146 cig_callbacks_.reset();
147
148 bte::SetMockBteInterface(nullptr);
149 hcic::SetMockHcicInterface(nullptr);
150 controller::SetMockControllerInterface(nullptr);
151 }
152
InitIsoManager()153 virtual void InitIsoManager() {
154 manager_instance_ = IsoManager::GetInstance();
155 manager_instance_->Start();
156 manager_instance_->RegisterCigCallbacks(cig_callbacks_.get());
157 manager_instance_->RegisterBigCallbacks(big_callbacks_.get());
158 manager_instance_->RegisterOnIsoTrafficActiveCallback(iso_active_callback);
159
160 // Default mock SetCigParams action
161 volatile_test_cig_create_cmpl_evt_ = kDefaultCigParamsEvt;
162 ON_CALL(hcic_interface_, SetCigParams)
163 .WillByDefault([this](auto cig_id, auto,
164 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
165 uint8_t hci_mock_rsp_buffer
166 [3 + sizeof(uint16_t) * this->volatile_test_cig_create_cmpl_evt_
167 .conn_handles.size()];
168 uint8_t* p = hci_mock_rsp_buffer;
169
170 UINT8_TO_STREAM(p, this->volatile_test_cig_create_cmpl_evt_.status);
171 UINT8_TO_STREAM(p, cig_id);
172 UINT8_TO_STREAM(
173 p, this->volatile_test_cig_create_cmpl_evt_.conn_handles.size());
174 for (auto handle :
175 this->volatile_test_cig_create_cmpl_evt_.conn_handles) {
176 UINT16_TO_STREAM(p, handle);
177 }
178
179 std::move(cb).Run(
180 hci_mock_rsp_buffer,
181 3 + sizeof(uint16_t) * this->volatile_test_cig_create_cmpl_evt_
182 .conn_handles.size());
183 return 0;
184 });
185
186 // Default mock CreateCis action
187 ON_CALL(hcic_interface_, CreateCis)
188 .WillByDefault([](uint8_t num_cis, const EXT_CIS_CREATE_CFG* cis_cfg,
189 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
190 for (const EXT_CIS_CREATE_CFG* cis = cis_cfg; num_cis != 0;
191 num_cis--, cis++) {
192 std::vector<uint8_t> buf(28);
193 uint8_t* p = buf.data();
194 UINT8_TO_STREAM(p, HCI_SUCCESS);
195 UINT16_TO_STREAM(p, cis->cis_conn_handle);
196 UINT24_TO_STREAM(p, 0xEA); // CIG sync delay
197 UINT24_TO_STREAM(p, 0xEB); // CIS sync delay
198 UINT24_TO_STREAM(p, 0xEC); // transport latency mtos
199 UINT24_TO_STREAM(p, 0xED); // transport latency stom
200 UINT8_TO_STREAM(p, 0x01); // phy mtos
201 UINT8_TO_STREAM(p, 0x02); // phy stom
202 UINT8_TO_STREAM(p, 0x01); // nse
203 UINT8_TO_STREAM(p, 0x02); // bn mtos
204 UINT8_TO_STREAM(p, 0x03); // bn stom
205 UINT8_TO_STREAM(p, 0x04); // ft mtos
206 UINT8_TO_STREAM(p, 0x05); // ft stom
207 UINT16_TO_STREAM(p, 0x00FA); // Max PDU mtos
208 UINT16_TO_STREAM(p, 0x00FB); // Max PDU stom
209 UINT16_TO_STREAM(p, 0x0C60); // ISO interval
210
211 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_CIS_EST_EVT,
212 buf.data(), buf.size());
213 }
214 });
215
216 // Default mock disconnect action
217 ON_CALL(hcic_interface_, Disconnect)
218 .WillByDefault([](uint16_t handle, uint8_t reason) {
219 IsoManager::GetInstance()->HandleDisconnect(handle, reason);
220 });
221
222 // Default mock CreateBig HCI action
223 volatile_test_big_params_evt_ = kDefaultBigParamsEvt;
224 ON_CALL(hcic_interface_, CreateBig)
225 .WillByDefault(
226 [this](auto big_handle,
227 bluetooth::hci::iso_manager::big_create_params big_params) {
228 std::vector<uint8_t> buf(big_params.num_bis * sizeof(uint16_t) +
229 18);
230 uint8_t* p = buf.data();
231 UINT8_TO_STREAM(p, HCI_SUCCESS);
232 UINT8_TO_STREAM(p, big_handle);
233
234 ASSERT_TRUE(big_params.num_bis <=
235 volatile_test_big_params_evt_.conn_handles.size());
236
237 UINT24_TO_STREAM(p, volatile_test_big_params_evt_.big_sync_delay);
238 UINT24_TO_STREAM(
239 p, volatile_test_big_params_evt_.transport_latency_big);
240 UINT8_TO_STREAM(p, big_params.phy);
241 UINT8_TO_STREAM(p, volatile_test_big_params_evt_.nse);
242 UINT8_TO_STREAM(p, volatile_test_big_params_evt_.bn);
243 UINT8_TO_STREAM(p, volatile_test_big_params_evt_.pto);
244 UINT8_TO_STREAM(p, volatile_test_big_params_evt_.irc);
245 UINT16_TO_STREAM(p, volatile_test_big_params_evt_.max_pdu);
246 UINT16_TO_STREAM(p, volatile_test_big_params_evt_.iso_interval);
247
248 UINT8_TO_STREAM(p, big_params.num_bis);
249 for (auto i = 0; i < big_params.num_bis; ++i) {
250 UINT16_TO_STREAM(p,
251 volatile_test_big_params_evt_.conn_handles[i]);
252 }
253
254 IsoManager::GetInstance()->HandleHciEvent(
255 HCI_BLE_CREATE_BIG_CPL_EVT, buf.data(), buf.size());
256 });
257
258 // Default mock TerminateBig HCI action
259 ON_CALL(hcic_interface_, TerminateBig)
260 .WillByDefault([](auto big_handle, uint8_t reason) {
261 std::vector<uint8_t> buf(2);
262 uint8_t* p = buf.data();
263 UINT8_TO_STREAM(p, big_handle);
264 UINT8_TO_STREAM(p, reason);
265
266 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_TERM_BIG_CPL_EVT,
267 buf.data(), buf.size());
268 });
269
270 // Default mock SetupIsoDataPath HCI action
271 ON_CALL(hcic_interface_, SetupIsoDataPath)
272 .WillByDefault(
273 [](uint16_t iso_handle, uint8_t /* data_path_dir */,
274 uint8_t /* data_path_id */, uint8_t /* codec_id_format */,
275 uint16_t /* codec_id_company */, uint16_t /* codec_id_vendor */,
276 uint32_t /* controller_delay */,
277 std::vector<uint8_t> /* codec_conf */,
278 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
279 std::vector<uint8_t> buf(3);
280 uint8_t* p = buf.data();
281 UINT8_TO_STREAM(p, HCI_SUCCESS);
282 UINT16_TO_STREAM(p, iso_handle);
283
284 std::move(cb).Run(buf.data(), buf.size());
285 });
286
287 // Default mock RemoveIsoDataPath HCI action
288 ON_CALL(hcic_interface_, RemoveIsoDataPath)
289 .WillByDefault([](uint16_t iso_handle, uint8_t data_path_dir,
290 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
291 std::vector<uint8_t> buf(3);
292 uint8_t* p = buf.data();
293 UINT8_TO_STREAM(p, HCI_SUCCESS);
294 UINT16_TO_STREAM(p, iso_handle);
295
296 std::move(cb).Run(buf.data(), buf.size());
297 });
298 }
299
CleanupIsoManager()300 virtual void CleanupIsoManager() {
301 manager_instance_->Stop();
302 manager_instance_ = nullptr;
303 }
304
305 static const bluetooth::hci::iso_manager::big_create_params kDefaultBigParams;
306 static const bluetooth::hci::iso_manager::cig_create_params kDefaultCigParams;
307 static const bluetooth::hci::iso_manager::cig_create_params
308 kDefaultCigParams2;
309 static const bluetooth::hci::iso_manager::cig_create_cmpl_evt
310 kDefaultCigParamsEvt;
311 static const bluetooth::hci::iso_manager::big_create_cmpl_evt
312 kDefaultBigParamsEvt;
313 static const bluetooth::hci::iso_manager::iso_data_path_params
314 kDefaultIsoDataPathParams;
315
316 bluetooth::hci::iso_manager::cig_create_cmpl_evt
317 volatile_test_cig_create_cmpl_evt_;
318 bluetooth::hci::iso_manager::big_create_cmpl_evt
319 volatile_test_big_params_evt_;
320
321 IsoManager* manager_instance_;
322 bte::MockBteInterface bte_interface_;
323 hcic::MockHcicInterface hcic_interface_;
324 controller::MockControllerInterface controller_interface_;
325
326 std::unique_ptr<MockBigCallbacks> big_callbacks_;
327 std::unique_ptr<MockCigCallbacks> cig_callbacks_;
__anonfbb242670902(bool active) 328 void (*iso_active_callback)(bool) = [](bool active) { IsIsoActive = active; };
329 };
330
331 const bluetooth::hci::iso_manager::cig_create_cmpl_evt
332 IsoManagerTest::kDefaultCigParamsEvt = {
333 .cig_id = 128,
334 .status = 0x00,
335 .conn_handles = std::vector<uint16_t>({0x0EFF, 0x00FF}),
336 };
337
338 const bluetooth::hci::iso_manager::big_create_cmpl_evt
339 IsoManagerTest::kDefaultBigParamsEvt = {
340 .status = 0x00,
341 .big_id = 0,
342 .big_sync_delay = 0x0080de,
343 .transport_latency_big = 0x00cefe,
344 .phy = 0x02,
345 .nse = 4,
346 .bn = 1,
347 .pto = 0,
348 .irc = 4,
349 .max_pdu = 108,
350 .iso_interval = 6,
351 .conn_handles = std::vector<uint16_t>({0x0EFE, 0x0E00}),
352 };
353
354 const bluetooth::hci::iso_manager::iso_data_path_params
355 IsoManagerTest::kDefaultIsoDataPathParams = {
356 .data_path_dir = bluetooth::hci::iso_manager::kIsoDataPathDirectionOut,
357 .data_path_id = bluetooth::hci::iso_manager::kIsoDataPathHci,
358 .codec_id_format = 0x06,
359 .codec_id_company = 0,
360 .codec_id_vendor = 0,
361 .controller_delay = 0,
362 .codec_conf = {0x02, 0x01, 0x02},
363 };
364
365 const bluetooth::hci::iso_manager::big_create_params
366 IsoManagerTest::kDefaultBigParams = {
367 .adv_handle = 0x00,
368 .num_bis = 2,
369 .sdu_itv = 0x002710,
370 .max_sdu_size = 108,
371 .max_transport_latency = 0x3c,
372 .rtn = 3,
373 .phy = 0x02,
374 .packing = 0x00,
375 .framing = 0x00,
376 .enc = 0,
377 .enc_code = std::array<uint8_t, 16>({0}),
378 };
379
380 const bluetooth::hci::iso_manager::cig_create_params
381 IsoManagerTest::kDefaultCigParams = {
382 .sdu_itv_mtos = 0x00002710,
383 .sdu_itv_stom = 0x00002711,
384 .sca = bluetooth::hci::iso_manager::kIsoSca0To20Ppm,
385 .packing = 0x00,
386 .framing = 0x01,
387 .max_trans_lat_stom = 0x000A,
388 .max_trans_lat_mtos = 0x0009,
389 .cis_cfgs =
390 {
391 // CIS #1
392 {
393 .cis_id = 1,
394 .max_sdu_size_mtos = 0x0028,
395 .max_sdu_size_stom = 0x0027,
396 .phy_mtos = 0x04,
397 .phy_stom = 0x03,
398 .rtn_mtos = 0x02,
399 .rtn_stom = 0x01,
400 },
401 // CIS #2
402 {
403 .cis_id = 2,
404 .max_sdu_size_mtos = 0x0029,
405 .max_sdu_size_stom = 0x002A,
406 .phy_mtos = 0x09,
407 .phy_stom = 0x08,
408 .rtn_mtos = 0x07,
409 .rtn_stom = 0x06,
410 },
411 },
412 };
413
414 const bluetooth::hci::iso_manager::cig_create_params
415 IsoManagerTest::kDefaultCigParams2 = {
416 .sdu_itv_mtos = 0x00002709,
417 .sdu_itv_stom = 0x00002700,
418 .sca = bluetooth::hci::iso_manager::kIsoSca0To20Ppm,
419 .packing = 0x01,
420 .framing = 0x00,
421 .max_trans_lat_stom = 0x000B,
422 .max_trans_lat_mtos = 0x0006,
423 .cis_cfgs =
424 {
425 // CIS #1
426 {
427 .cis_id = 1,
428 .max_sdu_size_mtos = 0x0022,
429 .max_sdu_size_stom = 0x0022,
430 .phy_mtos = 0x01,
431 .phy_stom = 0x02,
432 .rtn_mtos = 0x02,
433 .rtn_stom = 0x01,
434 },
435 // CIS #2
436 {
437 .cis_id = 2,
438 .max_sdu_size_mtos = 0x002A,
439 .max_sdu_size_stom = 0x002B,
440 .phy_mtos = 0x06,
441 .phy_stom = 0x06,
442 .rtn_mtos = 0x07,
443 .rtn_stom = 0x07,
444 },
445 },
446 };
447
448 class IsoManagerDeathTest : public IsoManagerTest {};
449
450 class IsoManagerDeathTestNoInit : public IsoManagerTest {
451 protected:
InitIsoManager()452 void InitIsoManager() override { /* DO NOTHING */
453 }
454
CleanupIsoManager()455 void CleanupIsoManager() override { /* DO NOTHING */
456 }
457 };
458
459 class IsoManagerDeathTestNoCleanup : public IsoManagerTest {
460 protected:
CleanupIsoManager()461 void CleanupIsoManager() override { /* DO NOTHING */
462 }
463 };
464
operator ==(const EXT_CIS_CFG & x,const EXT_CIS_CFG & y)465 bool operator==(const EXT_CIS_CFG& x, const EXT_CIS_CFG& y) {
466 return ((x.cis_id == y.cis_id) &&
467 (x.max_sdu_size_mtos == y.max_sdu_size_mtos) &&
468 (x.max_sdu_size_stom == y.max_sdu_size_stom) &&
469 (x.phy_mtos == y.phy_mtos) && (x.phy_stom == y.phy_stom) &&
470 (x.rtn_mtos == y.rtn_mtos) && (x.rtn_stom == y.rtn_stom));
471 }
472
operator ==(const struct bluetooth::hci::iso_manager::cig_create_params & x,const struct bluetooth::hci::iso_manager::cig_create_params & y)473 bool operator==(
474 const struct bluetooth::hci::iso_manager::cig_create_params& x,
475 const struct bluetooth::hci::iso_manager::cig_create_params& y) {
476 return ((x.sdu_itv_mtos == y.sdu_itv_mtos) &&
477 (x.sdu_itv_stom == y.sdu_itv_stom) && (x.sca == y.sca) &&
478 (x.packing == y.packing) && (x.framing == y.framing) &&
479 (x.max_trans_lat_stom == y.max_trans_lat_stom) &&
480 (x.max_trans_lat_mtos == y.max_trans_lat_mtos) &&
481 std::is_permutation(x.cis_cfgs.begin(), x.cis_cfgs.end(),
482 y.cis_cfgs.begin()));
483 }
484
operator ==(const struct bluetooth::hci::iso_manager::big_create_params & x,const struct bluetooth::hci::iso_manager::big_create_params & y)485 bool operator==(
486 const struct bluetooth::hci::iso_manager::big_create_params& x,
487 const struct bluetooth::hci::iso_manager::big_create_params& y) {
488 return ((x.adv_handle == y.adv_handle) && (x.num_bis == y.num_bis) &&
489 (x.sdu_itv == y.sdu_itv) && (x.max_sdu_size == y.max_sdu_size) &&
490 (x.max_transport_latency == y.max_transport_latency) &&
491 (x.rtn == y.rtn) && (x.phy == y.phy) && (x.packing == y.packing) &&
492 (x.framing == y.framing) && (x.enc == y.enc) &&
493 (x.enc_code == y.enc_code));
494 }
495
496 namespace iso_matchers {
497 MATCHER_P(Eq, value, "") { return (arg == value); }
498 MATCHER_P2(EqPointedArray, value, len, "") {
499 return (!std::memcmp(arg, value, len));
500 }
501 } // namespace iso_matchers
502
TEST_F(IsoManagerTest,SingletonAccess)503 TEST_F(IsoManagerTest, SingletonAccess) {
504 auto* iso_mgr = IsoManager::GetInstance();
505 ASSERT_EQ(manager_instance_, iso_mgr);
506 }
507
TEST_F(IsoManagerTest,RegisterCallbacks)508 TEST_F(IsoManagerTest, RegisterCallbacks) {
509 auto* iso_mgr = IsoManager::GetInstance();
510 ASSERT_EQ(manager_instance_, iso_mgr);
511
512 iso_mgr->RegisterBigCallbacks(big_callbacks_.get());
513 iso_mgr->RegisterCigCallbacks(cig_callbacks_.get());
514 iso_mgr->RegisterOnIsoTrafficActiveCallback(iso_active_callback);
515 }
516
TEST_F(IsoManagerDeathTestNoInit,RegisterNullBigCallbacks)517 TEST_F(IsoManagerDeathTestNoInit, RegisterNullBigCallbacks) {
518 IsoManager::GetInstance()->Start();
519
520 ASSERT_EXIT(IsoManager::GetInstance()->RegisterBigCallbacks(nullptr),
521 ::testing::KilledBySignal(SIGABRT), "Invalid BIG callbacks");
522
523 // Manual cleanup as IsoManagerDeathTest has no 'generic' cleanup
524 IsoManager::GetInstance()->Stop();
525 }
526
TEST_F(IsoManagerDeathTestNoInit,RegisterNullCigCallbacks)527 TEST_F(IsoManagerDeathTestNoInit, RegisterNullCigCallbacks) {
528 IsoManager::GetInstance()->Start();
529
530 ASSERT_EXIT(IsoManager::GetInstance()->RegisterCigCallbacks(nullptr),
531 ::testing::KilledBySignal(SIGABRT), "Invalid CIG callbacks");
532
533 // Manual cleanup as IsoManagerDeathTest has no 'generic' cleanup
534 IsoManager::GetInstance()->Stop();
535 }
536
537 // Verify hci layer being called by the Iso Manager
TEST_F(IsoManagerTest,CreateCigHciCall)538 TEST_F(IsoManagerTest, CreateCigHciCall) {
539 for (uint8_t i = 220; i != 60; ++i) {
540 EXPECT_CALL(hcic_interface_,
541 SetCigParams(i, iso_matchers::Eq(kDefaultCigParams), _))
542 .Times(1)
543 .RetiresOnSaturation();
544 IsoManager::GetInstance()->CreateCig(i, kDefaultCigParams);
545 }
546 }
547
548 // Check handling create cig request twice with the same CIG id
TEST_F(IsoManagerDeathTest,CreateSameCigTwice)549 TEST_F(IsoManagerDeathTest, CreateSameCigTwice) {
550 bluetooth::hci::iso_manager::cig_create_cmpl_evt evt;
551 evt.status = 0x01;
552 EXPECT_CALL(
553 *cig_callbacks_,
554 OnCigEvent(bluetooth::hci::iso_manager::kIsoEventCigOnCreateCmpl, _))
555 .WillOnce([&evt](uint8_t type, void* data) {
556 evt = *static_cast<bluetooth::hci::iso_manager::cig_create_cmpl_evt*>(
557 data);
558 return 0;
559 });
560
561 volatile_test_cig_create_cmpl_evt_.cig_id = 127;
562 IsoManager::GetInstance()->CreateCig(
563 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
564 ASSERT_EQ(evt.status, HCI_SUCCESS);
565
566 // Second call with the same CIG ID should fail
567 ASSERT_EXIT(IsoManager::GetInstance()->CreateCig(
568 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams),
569 ::testing::KilledBySignal(SIGABRT), "already exists");
570 }
571
572 // Check for handling invalid length response from the faulty controller
TEST_F(IsoManagerDeathTest,CreateCigCallbackInvalidRspPacket)573 TEST_F(IsoManagerDeathTest, CreateCigCallbackInvalidRspPacket) {
574 uint8_t hci_mock_rsp_buffer[] = {0x00, 0x00};
575 ON_CALL(hcic_interface_, SetCigParams)
576 .WillByDefault(
577 [&hci_mock_rsp_buffer](
578 auto, auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
579 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
580 return 0;
581 });
582
583 ASSERT_EXIT(IsoManager::GetInstance()->CreateCig(128, kDefaultCigParams),
584 ::testing::KilledBySignal(SIGABRT), "Invalid packet length");
585 }
586
587 // Check for handling invalid length response from the faulty controller
TEST_F(IsoManagerDeathTest,CreateCigCallbackInvalidRspPacket2)588 TEST_F(IsoManagerDeathTest, CreateCigCallbackInvalidRspPacket2) {
589 uint8_t hci_mock_rsp_buffer[] = {0x00, 0x00, 0x02, 0x01, 0x00};
590 ON_CALL(hcic_interface_, SetCigParams)
591 .WillByDefault(
592 [&hci_mock_rsp_buffer](
593 auto, auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
594 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
595 return 0;
596 });
597
598 ASSERT_EXIT(IsoManager::GetInstance()->CreateCig(128, kDefaultCigParams),
599 ::testing::KilledBySignal(SIGABRT), "Invalid CIS count");
600 }
601
602 // Check if IsoManager properly handles error responses from HCI layer
TEST_F(IsoManagerTest,CreateCigCallbackInvalidStatus)603 TEST_F(IsoManagerTest, CreateCigCallbackInvalidStatus) {
604 uint8_t rsp_cig_id = 128;
605 uint8_t rsp_status = 0x01;
606 uint8_t rsp_cis_cnt = 3;
607 uint8_t hci_mock_rsp_buffer[] = {rsp_status, rsp_cig_id, rsp_cis_cnt};
608
609 ON_CALL(hcic_interface_, SetCigParams)
610 .WillByDefault(
611 [&hci_mock_rsp_buffer](
612 auto, auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
613 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
614 return 0;
615 });
616
617 bluetooth::hci::iso_manager::cig_create_cmpl_evt evt;
618 EXPECT_CALL(
619 *cig_callbacks_,
620 OnCigEvent(bluetooth::hci::iso_manager::kIsoEventCigOnCreateCmpl, _))
621 .WillOnce([&evt](uint8_t type, void* data) {
622 evt = *static_cast<bluetooth::hci::iso_manager::cig_create_cmpl_evt*>(
623 data);
624 return 0;
625 });
626
627 IsoManager::GetInstance()->CreateCig(rsp_cig_id, kDefaultCigParams);
628 ASSERT_EQ(evt.cig_id, rsp_cig_id);
629 ASSERT_EQ(evt.status, rsp_status);
630 ASSERT_TRUE(evt.conn_handles.empty());
631 }
632
633 // Check valid callback response
TEST_F(IsoManagerTest,CreateCigCallbackValid)634 TEST_F(IsoManagerTest, CreateCigCallbackValid) {
635 bluetooth::hci::iso_manager::cig_create_cmpl_evt evt;
636 EXPECT_CALL(
637 *cig_callbacks_,
638 OnCigEvent(bluetooth::hci::iso_manager::kIsoEventCigOnCreateCmpl, _))
639 .WillOnce([&evt](uint8_t type, void* data) {
640 evt = *static_cast<bluetooth::hci::iso_manager::cig_create_cmpl_evt*>(
641 data);
642 return 0;
643 });
644
645 IsoManager::GetInstance()->CreateCig(
646 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
647 ASSERT_EQ(evt.cig_id, volatile_test_cig_create_cmpl_evt_.cig_id);
648 ASSERT_EQ(evt.status, volatile_test_cig_create_cmpl_evt_.status);
649 ASSERT_EQ(evt.conn_handles.size(), 2u);
650 ASSERT_TRUE(
651 std::is_permutation(evt.conn_handles.begin(), evt.conn_handles.end(),
652 std::vector<uint16_t>({0x0EFF, 0x00FF}).begin()));
653 }
654
655 // Check if CIG reconfigure triggers HCI layer call
TEST_F(IsoManagerTest,ReconfigureCigHciCall)656 TEST_F(IsoManagerTest, ReconfigureCigHciCall) {
657 IsoManager::GetInstance()->CreateCig(
658 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
659
660 EXPECT_CALL(hcic_interface_,
661 SetCigParams(volatile_test_cig_create_cmpl_evt_.cig_id,
662 iso_matchers::Eq(kDefaultCigParams), _))
663 .Times(1);
664 IsoManager::GetInstance()->ReconfigureCig(
665 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
666 }
667
668 // Verify handlidng invalid call - reconfiguring invalid CIG
TEST_F(IsoManagerDeathTest,ReconfigureCigWithNoSuchCig)669 TEST_F(IsoManagerDeathTest, ReconfigureCigWithNoSuchCig) {
670 ASSERT_EXIT(IsoManager::GetInstance()->ReconfigureCig(128, kDefaultCigParams),
671 ::testing::KilledBySignal(SIGABRT), "No such cig");
672 }
673
TEST_F(IsoManagerDeathTest,ReconfigureCigInvalidRspPacket)674 TEST_F(IsoManagerDeathTest, ReconfigureCigInvalidRspPacket) {
675 uint8_t hci_mock_rsp_buffer[] = {0x00, 0x00};
676
677 IsoManager::GetInstance()->CreateCig(
678 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
679
680 ON_CALL(hcic_interface_, SetCigParams)
681 .WillByDefault(
682 [&hci_mock_rsp_buffer](
683 auto, auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
684 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
685 return 0;
686 });
687 ASSERT_EXIT(IsoManager::GetInstance()->ReconfigureCig(
688 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams),
689 ::testing::KilledBySignal(SIGABRT), "Invalid packet length");
690 }
691
TEST_F(IsoManagerDeathTest,ReconfigureCigInvalidRspPacket2)692 TEST_F(IsoManagerDeathTest, ReconfigureCigInvalidRspPacket2) {
693 uint8_t hci_mock_rsp_buffer[] = {0x00, 0x00, 0x02, 0x01, 0x00};
694
695 IsoManager::GetInstance()->CreateCig(
696 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
697
698 ON_CALL(hcic_interface_, SetCigParams)
699 .WillByDefault(
700 [&hci_mock_rsp_buffer](
701 auto, auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
702 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
703 return 0;
704 });
705 ASSERT_EXIT(
706 IsoManager::GetInstance()->ReconfigureCig(
707 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams2),
708 ::testing::KilledBySignal(SIGABRT), "Invalid CIS count");
709 }
710
TEST_F(IsoManagerTest,ReconfigureCigInvalidStatus)711 TEST_F(IsoManagerTest, ReconfigureCigInvalidStatus) {
712 uint8_t rsp_cig_id = 128;
713 uint8_t rsp_status = 0x01;
714 uint8_t rsp_cis_cnt = 3;
715 uint8_t hci_mock_rsp_buffer[] = {rsp_status, rsp_cig_id, rsp_cis_cnt};
716
717 IsoManager::GetInstance()->CreateCig(rsp_cig_id, kDefaultCigParams);
718
719 // Set-up the invalid response
720 ON_CALL(hcic_interface_, SetCigParams)
721 .WillByDefault(
722 [&hci_mock_rsp_buffer](
723 auto, auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
724 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
725 return 0;
726 });
727
728 bluetooth::hci::iso_manager::cig_create_cmpl_evt evt;
729 EXPECT_CALL(
730 *cig_callbacks_,
731 OnCigEvent(bluetooth::hci::iso_manager::kIsoEventCigOnReconfigureCmpl, _))
732 .WillOnce([&evt](uint8_t type, void* data) {
733 evt = *static_cast<bluetooth::hci::iso_manager::cig_create_cmpl_evt*>(
734 data);
735 return 0;
736 });
737 IsoManager::GetInstance()->ReconfigureCig(rsp_cig_id, kDefaultCigParams2);
738
739 ASSERT_EQ(evt.cig_id, rsp_cig_id);
740 ASSERT_EQ(evt.status, rsp_status);
741 ASSERT_TRUE(evt.conn_handles.empty());
742 }
743
TEST_F(IsoManagerTest,ReconfigureCigValid)744 TEST_F(IsoManagerTest, ReconfigureCigValid) {
745 IsoManager::GetInstance()->CreateCig(
746 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
747
748 bluetooth::hci::iso_manager::cig_create_cmpl_evt evt;
749 EXPECT_CALL(
750 *cig_callbacks_,
751 OnCigEvent(bluetooth::hci::iso_manager::kIsoEventCigOnReconfigureCmpl, _))
752 .WillOnce([&evt](uint8_t type, void* data) {
753 evt = *static_cast<bluetooth::hci::iso_manager::cig_create_cmpl_evt*>(
754 data);
755 return 0;
756 });
757
758 // Verify valid reconfiguration request
759 IsoManager::GetInstance()->ReconfigureCig(
760 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams2);
761 ASSERT_EQ(evt.cig_id, volatile_test_cig_create_cmpl_evt_.cig_id);
762 ASSERT_EQ(evt.status, volatile_test_cig_create_cmpl_evt_.status);
763 ASSERT_TRUE(std::is_permutation(
764 evt.conn_handles.begin(), evt.conn_handles.end(),
765 volatile_test_cig_create_cmpl_evt_.conn_handles.begin()));
766 }
767
TEST_F(IsoManagerTest,RemoveCigHciCall)768 TEST_F(IsoManagerTest, RemoveCigHciCall) {
769 IsoManager::GetInstance()->CreateCig(
770 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
771
772 EXPECT_CALL(hcic_interface_,
773 RemoveCig(volatile_test_cig_create_cmpl_evt_.cig_id, _))
774 .Times(1);
775 IsoManager::GetInstance()->RemoveCig(
776 volatile_test_cig_create_cmpl_evt_.cig_id);
777 }
778
TEST_F(IsoManagerDeathTest,RemoveCigWithNoSuchCig)779 TEST_F(IsoManagerDeathTest, RemoveCigWithNoSuchCig) {
780 ASSERT_EXIT(IsoManager::GetInstance()->RemoveCig(
781 volatile_test_cig_create_cmpl_evt_.cig_id),
782 ::testing::KilledBySignal(SIGABRT), "No such cig");
783 }
784
TEST_F(IsoManagerDeathTest,RemoveCigForceNoSuchCig)785 TEST_F(IsoManagerDeathTest, RemoveCigForceNoSuchCig) {
786 EXPECT_CALL(hcic_interface_,
787 RemoveCig(volatile_test_cig_create_cmpl_evt_.cig_id, _))
788 .Times(1);
789 IsoManager::GetInstance()->RemoveCig(
790 volatile_test_cig_create_cmpl_evt_.cig_id, true);
791 }
792
TEST_F(IsoManagerDeathTest,RemoveSameCigTwice)793 TEST_F(IsoManagerDeathTest, RemoveSameCigTwice) {
794 IsoManager::GetInstance()->CreateCig(
795 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
796
797 ON_CALL(hcic_interface_, RemoveCig)
798 .WillByDefault(
799 [this](auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
800 uint8_t hci_mock_rsp_buffer[2];
801 uint8_t* p = hci_mock_rsp_buffer;
802
803 UINT8_TO_STREAM(p, HCI_SUCCESS);
804 UINT8_TO_STREAM(p, this->volatile_test_cig_create_cmpl_evt_.cig_id);
805
806 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
807 return 0;
808 });
809
810 IsoManager::GetInstance()->RemoveCig(
811 volatile_test_cig_create_cmpl_evt_.cig_id);
812
813 ASSERT_EXIT(IsoManager::GetInstance()->RemoveCig(
814 volatile_test_cig_create_cmpl_evt_.cig_id),
815 ::testing::KilledBySignal(SIGABRT), "No such cig");
816 }
817
TEST_F(IsoManagerDeathTest,RemoveCigInvalidRspPacket)818 TEST_F(IsoManagerDeathTest, RemoveCigInvalidRspPacket) {
819 IsoManager::GetInstance()->CreateCig(
820 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
821
822 ON_CALL(hcic_interface_, RemoveCig)
823 .WillByDefault([](auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
824 uint8_t hci_mock_rsp_buffer[] = {0x00}; // status byte only
825
826 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
827 return 0;
828 });
829 ASSERT_EXIT(IsoManager::GetInstance()->RemoveCig(
830 volatile_test_cig_create_cmpl_evt_.cig_id),
831 ::testing::KilledBySignal(SIGABRT), "Invalid packet length");
832 }
833
TEST_F(IsoManagerTest,RemoveCigInvalidStatus)834 TEST_F(IsoManagerTest, RemoveCigInvalidStatus) {
835 uint8_t rsp_status = 0x02;
836 uint8_t hci_mock_rsp_buffer[] = {rsp_status,
837 volatile_test_cig_create_cmpl_evt_.cig_id};
838
839 IsoManager::GetInstance()->CreateCig(
840 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
841
842 ON_CALL(hcic_interface_, RemoveCig)
843 .WillByDefault(
844 [&hci_mock_rsp_buffer](
845 auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
846 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
847 return 0;
848 });
849
850 bluetooth::hci::iso_manager::cig_remove_cmpl_evt evt;
851 ON_CALL(*cig_callbacks_,
852 OnCigEvent(bluetooth::hci::iso_manager::kIsoEventCigOnRemoveCmpl, _))
853 .WillByDefault([&evt](uint8_t type, void* data) {
854 evt = *static_cast<bluetooth::hci::iso_manager::cig_remove_cmpl_evt*>(
855 data);
856 return 0;
857 });
858
859 IsoManager::GetInstance()->RemoveCig(
860 volatile_test_cig_create_cmpl_evt_.cig_id);
861 ASSERT_EQ(evt.cig_id, volatile_test_cig_create_cmpl_evt_.cig_id);
862 ASSERT_EQ(evt.status, rsp_status);
863 }
864
TEST_F(IsoManagerTest,RemoveCigValid)865 TEST_F(IsoManagerTest, RemoveCigValid) {
866 uint8_t hci_mock_rsp_buffer[] = {HCI_SUCCESS,
867 volatile_test_cig_create_cmpl_evt_.cig_id};
868
869 ASSERT_EQ(IsIsoActive, false);
870 IsoManager::GetInstance()->CreateCig(
871 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
872 ASSERT_EQ(IsIsoActive, true);
873
874 ON_CALL(hcic_interface_, RemoveCig)
875 .WillByDefault(
876 [&hci_mock_rsp_buffer](
877 auto, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
878 std::move(cb).Run(hci_mock_rsp_buffer, sizeof(hci_mock_rsp_buffer));
879 return 0;
880 });
881
882 bluetooth::hci::iso_manager::cig_remove_cmpl_evt evt;
883 EXPECT_CALL(
884 *cig_callbacks_,
885 OnCigEvent(bluetooth::hci::iso_manager::kIsoEventCigOnRemoveCmpl, _))
886 .WillOnce([&evt](uint8_t type, void* data) {
887 evt = *static_cast<bluetooth::hci::iso_manager::cig_remove_cmpl_evt*>(
888 data);
889 return 0;
890 });
891
892 IsoManager::GetInstance()->RemoveCig(
893 volatile_test_cig_create_cmpl_evt_.cig_id);
894 ASSERT_EQ(evt.cig_id, volatile_test_cig_create_cmpl_evt_.cig_id);
895 ASSERT_EQ(evt.status, HCI_SUCCESS);
896 ASSERT_EQ(IsIsoActive, false);
897 }
898
TEST_F(IsoManagerTest,EstablishCisHciCall)899 TEST_F(IsoManagerTest, EstablishCisHciCall) {
900 IsoManager::GetInstance()->CreateCig(
901 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
902
903 bluetooth::hci::iso_manager::cis_establish_params params;
904 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
905 params.conn_pairs.push_back({handle, 1});
906 }
907
908 EXPECT_CALL(hcic_interface_,
909 CreateCis(2,
910 iso_matchers::EqPointedArray(
911 params.conn_pairs.data(),
912 params.conn_pairs.size() *
913 sizeof(params.conn_pairs.data()[0])),
914 _))
915 .Times(1);
916 IsoManager::GetInstance()->EstablishCis(params);
917 }
918
TEST_F(IsoManagerDeathTest,EstablishCisWithNoSuchCis)919 TEST_F(IsoManagerDeathTest, EstablishCisWithNoSuchCis) {
920 bluetooth::hci::iso_manager::cis_establish_params params;
921 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
922 params.conn_pairs.push_back({handle, 1});
923 }
924
925 ASSERT_EXIT(
926 IsoManager::GetInstance()->IsoManager::GetInstance()->EstablishCis(
927 params),
928 ::testing::KilledBySignal(SIGABRT), "No such cis");
929 }
930
TEST_F(IsoManagerDeathTest,ConnectSameCisTwice)931 TEST_F(IsoManagerDeathTest, ConnectSameCisTwice) {
932 IsoManager::GetInstance()->CreateCig(
933 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
934
935 bluetooth::hci::iso_manager::cis_establish_params params;
936 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
937 params.conn_pairs.push_back({handle, 1});
938 }
939 IsoManager::GetInstance()->EstablishCis(params);
940
941 ASSERT_EXIT(
942 IsoManager::GetInstance()->IsoManager::GetInstance()->EstablishCis(
943 params),
944 ::testing::KilledBySignal(SIGABRT), "Already connected or connecting");
945 }
946
TEST_F(IsoManagerDeathTest,EstablishCisInvalidResponsePacket)947 TEST_F(IsoManagerDeathTest, EstablishCisInvalidResponsePacket) {
948 IsoManager::GetInstance()->CreateCig(
949 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
950
951 ON_CALL(hcic_interface_, CreateCis)
952 .WillByDefault([this](uint8_t num_cis, const EXT_CIS_CREATE_CFG* cis_cfg,
953 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
954 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
955 std::vector<uint8_t> buf(27);
956 uint8_t* p = buf.data();
957 UINT8_TO_STREAM(p, HCI_SUCCESS);
958 UINT16_TO_STREAM(p, handle);
959 UINT24_TO_STREAM(p, 0xEA); // CIG sync delay
960 UINT24_TO_STREAM(p, 0xEB); // CIS sync delay
961 UINT24_TO_STREAM(p, 0xEC); // transport latency mtos
962 UINT24_TO_STREAM(p, 0xED); // transport latency stom
963 UINT8_TO_STREAM(p, 0x01); // phy mtos
964 UINT8_TO_STREAM(p, 0x02); // phy stom
965 UINT8_TO_STREAM(p, 0x01); // nse
966 UINT8_TO_STREAM(p, 0x02); // bn mtos
967 UINT8_TO_STREAM(p, 0x03); // bn stom
968 UINT8_TO_STREAM(p, 0x04); // ft mtos
969 UINT8_TO_STREAM(p, 0x05); // ft stom
970 UINT16_TO_STREAM(p, 0x00FA); // Max PDU mtos
971 UINT16_TO_STREAM(p, 0x00FB); // Max PDU stom
972
973 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_CIS_EST_EVT,
974 buf.data(), buf.size());
975 }
976 });
977
978 bluetooth::hci::iso_manager::cis_establish_params params;
979 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
980 params.conn_pairs.push_back({handle, 1});
981 }
982
983 ASSERT_EXIT(
984 IsoManager::GetInstance()->IsoManager::GetInstance()->EstablishCis(
985 params),
986 ::testing::KilledBySignal(SIGABRT), "Invalid packet length");
987 }
988
TEST_F(IsoManagerTest,EstablishCisInvalidCommandStatus)989 TEST_F(IsoManagerTest, EstablishCisInvalidCommandStatus) {
990 IsoManager::GetInstance()->CreateCig(
991 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
992 uint16_t invalid_status = 0x0001;
993
994 ON_CALL(hcic_interface_, CreateCis)
995 .WillByDefault([invalid_status](
996 uint8_t num_cis, const EXT_CIS_CREATE_CFG* cis_cfg,
997 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
998 std::move(cb).Run((uint8_t*)&invalid_status, sizeof(invalid_status));
999 return 0;
1000 });
1001
1002 EXPECT_CALL(
1003 *cig_callbacks_,
1004 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisEstablishCmpl, _))
1005 .Times(kDefaultCigParams.cis_cfgs.size())
1006 .WillRepeatedly([this, invalid_status](uint8_t type, void* data) {
1007 bluetooth::hci::iso_manager::cis_establish_cmpl_evt* evt =
1008 static_cast<bluetooth::hci::iso_manager::cis_establish_cmpl_evt*>(
1009 data);
1010
1011 ASSERT_EQ(evt->status, invalid_status);
1012 ASSERT_TRUE(
1013 std::find(volatile_test_cig_create_cmpl_evt_.conn_handles.begin(),
1014 volatile_test_cig_create_cmpl_evt_.conn_handles.end(),
1015 evt->cis_conn_hdl) !=
1016 volatile_test_cig_create_cmpl_evt_.conn_handles.end());
1017 });
1018
1019 // Establish all CISes
1020 bluetooth::hci::iso_manager::cis_establish_params params;
1021 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1022 params.conn_pairs.push_back({handle, 1});
1023 }
1024 IsoManager::GetInstance()->EstablishCis(params);
1025 }
1026
TEST_F(IsoManagerTest,EstablishCisInvalidStatus)1027 TEST_F(IsoManagerTest, EstablishCisInvalidStatus) {
1028 IsoManager::GetInstance()->CreateCig(
1029 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1030 uint8_t invalid_status = 0x01;
1031
1032 ON_CALL(hcic_interface_, CreateCis)
1033 .WillByDefault([this, invalid_status](
1034 uint8_t num_cis, const EXT_CIS_CREATE_CFG* cis_cfg,
1035 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
1036 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1037 std::vector<uint8_t> buf(28);
1038 uint8_t* p = buf.data();
1039 UINT8_TO_STREAM(p, invalid_status);
1040 UINT16_TO_STREAM(p, handle);
1041 UINT24_TO_STREAM(p, 0xEA); // CIG sync delay
1042 UINT24_TO_STREAM(p, 0xEB); // CIS sync delay
1043 UINT24_TO_STREAM(p, 0xEC); // transport latency mtos
1044 UINT24_TO_STREAM(p, 0xED); // transport latency stom
1045 UINT8_TO_STREAM(p, 0x01); // phy mtos
1046 UINT8_TO_STREAM(p, 0x02); // phy stom
1047 UINT8_TO_STREAM(p, 0x01); // nse
1048 UINT8_TO_STREAM(p, 0x02); // bn mtos
1049 UINT8_TO_STREAM(p, 0x03); // bn stom
1050 UINT8_TO_STREAM(p, 0x04); // ft mtos
1051 UINT8_TO_STREAM(p, 0x05); // ft stom
1052 UINT16_TO_STREAM(p, 0x00FA); // Max PDU mtos
1053 UINT16_TO_STREAM(p, 0x00FB); // Max PDU stom
1054 UINT16_TO_STREAM(p, 0x0C60); // ISO interval
1055
1056 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_CIS_EST_EVT,
1057 buf.data(), buf.size());
1058 }
1059 });
1060
1061 EXPECT_CALL(
1062 *cig_callbacks_,
1063 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisEstablishCmpl, _))
1064 .Times(kDefaultCigParams.cis_cfgs.size())
1065 .WillRepeatedly([this, invalid_status](uint8_t type, void* data) {
1066 bluetooth::hci::iso_manager::cis_establish_cmpl_evt* evt =
1067 static_cast<bluetooth::hci::iso_manager::cis_establish_cmpl_evt*>(
1068 data);
1069
1070 ASSERT_EQ(evt->status, invalid_status);
1071 ASSERT_TRUE(
1072 std::find(volatile_test_cig_create_cmpl_evt_.conn_handles.begin(),
1073 volatile_test_cig_create_cmpl_evt_.conn_handles.end(),
1074 evt->cis_conn_hdl) !=
1075 volatile_test_cig_create_cmpl_evt_.conn_handles.end());
1076 });
1077
1078 // Establish all CISes before setting up their data paths
1079 bluetooth::hci::iso_manager::cis_establish_params params;
1080 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1081 params.conn_pairs.push_back({handle, 1});
1082 }
1083 IsoManager::GetInstance()->EstablishCis(params);
1084 }
1085
TEST_F(IsoManagerTest,EstablishCisValid)1086 TEST_F(IsoManagerTest, EstablishCisValid) {
1087 IsoManager::GetInstance()->CreateCig(
1088 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1089
1090 EXPECT_CALL(
1091 *cig_callbacks_,
1092 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisEstablishCmpl, _))
1093 .Times(kDefaultCigParams.cis_cfgs.size())
1094 .WillRepeatedly([this](uint8_t type, void* data) {
1095 bluetooth::hci::iso_manager::cis_establish_cmpl_evt* evt =
1096 static_cast<bluetooth::hci::iso_manager::cis_establish_cmpl_evt*>(
1097 data);
1098
1099 ASSERT_EQ(evt->status, HCI_SUCCESS);
1100 ASSERT_TRUE(
1101 std::find(volatile_test_cig_create_cmpl_evt_.conn_handles.begin(),
1102 volatile_test_cig_create_cmpl_evt_.conn_handles.end(),
1103 evt->cis_conn_hdl) !=
1104 volatile_test_cig_create_cmpl_evt_.conn_handles.end());
1105 });
1106
1107 // Establish all CISes before setting up their data paths
1108 bluetooth::hci::iso_manager::cis_establish_params params;
1109 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1110 params.conn_pairs.push_back({handle, 1});
1111 }
1112 IsoManager::GetInstance()->EstablishCis(params);
1113 }
1114
TEST_F(IsoManagerTest,ReconnectCisValid)1115 TEST_F(IsoManagerTest, ReconnectCisValid) {
1116 IsoManager::GetInstance()->CreateCig(
1117 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1118
1119 // Establish all CISes before setting up their data paths
1120 bluetooth::hci::iso_manager::cis_establish_params params;
1121 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1122 params.conn_pairs.push_back({handle, 1});
1123 }
1124 IsoManager::GetInstance()->EstablishCis(params);
1125
1126 // trigger HCI disconnection event
1127 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1128 IsoManager::GetInstance()->HandleDisconnect(handle, 0x16);
1129 }
1130
1131 EXPECT_CALL(
1132 *cig_callbacks_,
1133 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisEstablishCmpl, _))
1134 .Times(kDefaultCigParams.cis_cfgs.size())
1135 .WillRepeatedly([this](uint8_t type, void* data) {
1136 bluetooth::hci::iso_manager::cis_establish_cmpl_evt* evt =
1137 static_cast<bluetooth::hci::iso_manager::cis_establish_cmpl_evt*>(
1138 data);
1139
1140 ASSERT_EQ(evt->status, HCI_SUCCESS);
1141 ASSERT_TRUE(
1142 std::find(volatile_test_cig_create_cmpl_evt_.conn_handles.begin(),
1143 volatile_test_cig_create_cmpl_evt_.conn_handles.end(),
1144 evt->cis_conn_hdl) !=
1145 volatile_test_cig_create_cmpl_evt_.conn_handles.end());
1146 });
1147 IsoManager::GetInstance()->EstablishCis(params);
1148 }
1149
TEST_F(IsoManagerTest,DisconnectCisHciCall)1150 TEST_F(IsoManagerTest, DisconnectCisHciCall) {
1151 IsoManager::GetInstance()->CreateCig(
1152 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1153
1154 // Establish all CISes before setting up their data paths
1155 bluetooth::hci::iso_manager::cis_establish_params params;
1156 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1157 params.conn_pairs.push_back({handle, 1});
1158 }
1159 IsoManager::GetInstance()->EstablishCis(params);
1160
1161 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1162 EXPECT_CALL(hcic_interface_, Disconnect(handle, 0x16))
1163 .Times(1)
1164 .RetiresOnSaturation();
1165 IsoManager::GetInstance()->IsoManager::GetInstance()->DisconnectCis(handle,
1166 0x16);
1167 }
1168 }
1169
TEST_F(IsoManagerDeathTest,DisconnectCisWithNoSuchCis)1170 TEST_F(IsoManagerDeathTest, DisconnectCisWithNoSuchCis) {
1171 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1172 ASSERT_EXIT(
1173 IsoManager::GetInstance()->IsoManager::GetInstance()->DisconnectCis(
1174 handle, 0x16),
1175 ::testing::KilledBySignal(SIGABRT), "No such cis");
1176 }
1177 }
1178
TEST_F(IsoManagerDeathTest,DisconnectSameCisTwice)1179 TEST_F(IsoManagerDeathTest, DisconnectSameCisTwice) {
1180 IsoManager::GetInstance()->CreateCig(
1181 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1182
1183 // Establish all CISes before setting up their data paths
1184 bluetooth::hci::iso_manager::cis_establish_params params;
1185 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1186 params.conn_pairs.push_back({handle, 1});
1187 }
1188 IsoManager::GetInstance()->EstablishCis(params);
1189
1190 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1191 IsoManager::GetInstance()->IsoManager::GetInstance()->DisconnectCis(handle,
1192 0x16);
1193 }
1194
1195 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1196 ASSERT_EXIT(
1197 IsoManager::GetInstance()->IsoManager::GetInstance()->DisconnectCis(
1198 handle, 0x16),
1199 ::testing::KilledBySignal(SIGABRT), "Not connected");
1200 }
1201 }
1202
TEST_F(IsoManagerTest,DisconnectCisValid)1203 TEST_F(IsoManagerTest, DisconnectCisValid) {
1204 IsoManager::GetInstance()->CreateCig(
1205 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1206
1207 // Establish all CISes before setting up their data paths
1208 bluetooth::hci::iso_manager::cis_establish_params params;
1209 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1210 params.conn_pairs.push_back({handle, 1});
1211 }
1212 IsoManager::GetInstance()->EstablishCis(params);
1213
1214 uint8_t disconnect_reason = 0x16;
1215 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1216 EXPECT_CALL(*cig_callbacks_, OnCisEvent)
1217 .WillOnce([this, handle, disconnect_reason](uint8_t event_code,
1218 void* data) {
1219 ASSERT_EQ(event_code,
1220 bluetooth::hci::iso_manager::kIsoEventCisDisconnected);
1221 auto* event =
1222 static_cast<bluetooth::hci::iso_manager::cis_disconnected_evt*>(
1223 data);
1224 ASSERT_EQ(event->reason, disconnect_reason);
1225 ASSERT_EQ(event->cig_id, volatile_test_cig_create_cmpl_evt_.cig_id);
1226 ASSERT_EQ(event->cis_conn_hdl, handle);
1227 })
1228 .RetiresOnSaturation();
1229 IsoManager::GetInstance()->IsoManager::GetInstance()->DisconnectCis(
1230 handle, disconnect_reason);
1231 }
1232 }
1233
1234 // Check if we properly ignore not ISO related disconnect events
TEST_F(IsoManagerDeathTest,DisconnectCisInvalidResponse)1235 TEST_F(IsoManagerDeathTest, DisconnectCisInvalidResponse) {
1236 IsoManager::GetInstance()->CreateCig(
1237 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1238
1239 bluetooth::hci::iso_manager::cis_establish_params params;
1240 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1241 params.conn_pairs.push_back({handle, 1});
1242 }
1243 IsoManager::GetInstance()->EstablishCis(params);
1244
1245 // Make the HCI layer send invalid handles in disconnect event
1246 ON_CALL(hcic_interface_, Disconnect)
1247 .WillByDefault([](uint16_t handle, uint8_t reason) {
1248 IsoManager::GetInstance()->HandleDisconnect(handle + 1, reason);
1249 });
1250
1251 // We don't expect any calls as these are not ISO handles
1252 ON_CALL(*cig_callbacks_,
1253 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisDisconnected, _))
1254 .WillByDefault([](uint8_t event_code, void* data) { FAIL(); });
1255
1256 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1257 IsoManager::GetInstance()->IsoManager::GetInstance()->DisconnectCis(handle,
1258 0x16);
1259 }
1260 }
1261
TEST_F(IsoManagerTest,CreateBigHciCall)1262 TEST_F(IsoManagerTest, CreateBigHciCall) {
1263 for (uint8_t i = 220; i != 60; ++i) {
1264 EXPECT_CALL(hcic_interface_,
1265 CreateBig(i, iso_matchers::Eq(kDefaultBigParams)))
1266 .Times(1)
1267 .RetiresOnSaturation();
1268 IsoManager::GetInstance()->CreateBig(i, kDefaultBigParams);
1269 }
1270 }
1271
TEST_F(IsoManagerTest,CreateBigValid)1272 TEST_F(IsoManagerTest, CreateBigValid) {
1273 bluetooth::hci::iso_manager::big_create_cmpl_evt evt;
1274 evt.status = 0x01;
1275 EXPECT_CALL(
1276 *big_callbacks_,
1277 OnBigEvent(bluetooth::hci::iso_manager::kIsoEventBigOnCreateCmpl, _))
1278 .WillOnce([&evt](uint8_t type, void* data) {
1279 evt = *static_cast<bluetooth::hci::iso_manager::big_create_cmpl_evt*>(
1280 data);
1281 return 0;
1282 });
1283
1284 IsoManager::GetInstance()->CreateBig(0x01, kDefaultBigParams);
1285 ASSERT_EQ(evt.status, HCI_SUCCESS);
1286 }
1287
TEST_F(IsoManagerDeathTest,CreateBigInvalidResponsePacket)1288 TEST_F(IsoManagerDeathTest, CreateBigInvalidResponsePacket) {
1289 ON_CALL(hcic_interface_, CreateBig)
1290 .WillByDefault(
1291 [](auto big_handle,
1292 bluetooth::hci::iso_manager::big_create_params big_params) {
1293 std::vector<uint8_t> buf(18);
1294 uint8_t* p = buf.data();
1295 UINT8_TO_STREAM(p, 0x00);
1296 UINT8_TO_STREAM(p, big_handle);
1297
1298 UINT24_TO_STREAM(p, 0x0080de); // big_sync_delay
1299 UINT24_TO_STREAM(p, 0x00cefe); // transport_latency_big
1300 UINT8_TO_STREAM(p, big_params.phy); // phy
1301 UINT8_TO_STREAM(p, 4); // nse
1302 UINT8_TO_STREAM(p, 1); // bn
1303 UINT8_TO_STREAM(p, 0); // pto
1304 UINT8_TO_STREAM(p, 4); // irc
1305 UINT16_TO_STREAM(p, 108); // max_pdu
1306 UINT16_TO_STREAM(p, 6); // iso_interval
1307 UINT8_TO_STREAM(p, 0); // num BISes
1308
1309 IsoManager::GetInstance()->HandleHciEvent(
1310 HCI_BLE_CREATE_BIG_CPL_EVT, buf.data(), buf.size());
1311 });
1312
1313 ASSERT_EXIT(IsoManager::GetInstance()->CreateBig(0x01, kDefaultBigParams),
1314 ::testing::KilledBySignal(SIGABRT),
1315 "num_bis != 0. Bis count is 0");
1316 }
1317
TEST_F(IsoManagerDeathTest,CreateBigInvalidResponsePacket2)1318 TEST_F(IsoManagerDeathTest, CreateBigInvalidResponsePacket2) {
1319 ON_CALL(hcic_interface_, CreateBig)
1320 .WillByDefault(
1321 [](auto big_handle,
1322 bluetooth::hci::iso_manager::big_create_params big_params) {
1323 std::vector<uint8_t> buf(18);
1324 uint8_t* p = buf.data();
1325 UINT8_TO_STREAM(p, 0x00);
1326 UINT8_TO_STREAM(p, big_handle);
1327
1328 UINT24_TO_STREAM(p, 0x0080de); // big_sync_delay
1329 UINT24_TO_STREAM(p, 0x00cefe); // transport_latency_big
1330 UINT8_TO_STREAM(p, big_params.phy); // phy
1331 UINT8_TO_STREAM(p, 4); // nse
1332 UINT8_TO_STREAM(p, 1); // bn
1333 UINT8_TO_STREAM(p, 0); // pto
1334 UINT8_TO_STREAM(p, 4); // irc
1335 UINT16_TO_STREAM(p, 108); // max_pdu
1336 UINT16_TO_STREAM(p, 6); // iso_interval
1337 UINT8_TO_STREAM(p, big_params.num_bis);
1338
1339 IsoManager::GetInstance()->HandleHciEvent(
1340 HCI_BLE_CREATE_BIG_CPL_EVT, buf.data(), buf.size());
1341 });
1342
1343 ASSERT_EXIT(IsoManager::GetInstance()->CreateBig(0x01, kDefaultBigParams),
1344 ::testing::KilledBySignal(SIGABRT), "Invalid packet length");
1345 }
1346
TEST_F(IsoManagerTest,CreateBigInvalidStatus)1347 TEST_F(IsoManagerTest, CreateBigInvalidStatus) {
1348 bluetooth::hci::iso_manager::big_create_cmpl_evt evt;
1349 evt.status = 0x00;
1350 EXPECT_CALL(
1351 *big_callbacks_,
1352 OnBigEvent(bluetooth::hci::iso_manager::kIsoEventBigOnCreateCmpl, _))
1353 .WillOnce([&evt](uint8_t type, void* data) {
1354 evt = *static_cast<bluetooth::hci::iso_manager::big_create_cmpl_evt*>(
1355 data);
1356 return 0;
1357 });
1358
1359 ON_CALL(hcic_interface_, CreateBig)
1360 .WillByDefault(
1361 [](auto big_handle,
1362 bluetooth::hci::iso_manager::big_create_params big_params) {
1363 std::vector<uint8_t> buf(big_params.num_bis * sizeof(uint16_t) +
1364 18);
1365 uint8_t* p = buf.data();
1366 UINT8_TO_STREAM(p, 0x01);
1367 UINT8_TO_STREAM(p, big_handle);
1368
1369 UINT24_TO_STREAM(p, 0x0080de); // big_sync_delay
1370 UINT24_TO_STREAM(p, 0x00cefe); // transport_latency_big
1371 UINT8_TO_STREAM(p, big_params.phy); // phy
1372 UINT8_TO_STREAM(p, 4); // nse
1373 UINT8_TO_STREAM(p, 1); // bn
1374 UINT8_TO_STREAM(p, 0); // pto
1375 UINT8_TO_STREAM(p, 4); // irc
1376 UINT16_TO_STREAM(p, 108); // max_pdu
1377 UINT16_TO_STREAM(p, 6); // iso_interval
1378
1379 UINT8_TO_STREAM(p, big_params.num_bis);
1380 static uint8_t conn_hdl = 0x01;
1381 for (auto i = 0; i < big_params.num_bis; ++i) {
1382 UINT16_TO_STREAM(p, conn_hdl++);
1383 }
1384
1385 IsoManager::GetInstance()->HandleHciEvent(
1386 HCI_BLE_CREATE_BIG_CPL_EVT, buf.data(), buf.size());
1387 });
1388
1389 IsoManager::GetInstance()->CreateBig(0x01, kDefaultBigParams);
1390 ASSERT_EQ(evt.status, 0x01);
1391 ASSERT_EQ(evt.big_id, 0x01);
1392 ASSERT_EQ(evt.conn_handles.size(), kDefaultBigParams.num_bis);
1393 }
1394
TEST_F(IsoManagerDeathTest,CreateSameBigTwice)1395 TEST_F(IsoManagerDeathTest, CreateSameBigTwice) {
1396 bluetooth::hci::iso_manager::big_create_cmpl_evt evt;
1397 evt.status = 0x01;
1398 EXPECT_CALL(
1399 *big_callbacks_,
1400 OnBigEvent(bluetooth::hci::iso_manager::kIsoEventBigOnCreateCmpl, _))
1401 .WillOnce([&evt](uint8_t type, void* data) {
1402 evt = *static_cast<bluetooth::hci::iso_manager::big_create_cmpl_evt*>(
1403 data);
1404 return 0;
1405 });
1406
1407 IsoManager::GetInstance()->CreateBig(0x01, kDefaultBigParams);
1408 ASSERT_EQ(evt.status, HCI_SUCCESS);
1409 ASSERT_EQ(evt.big_id, 0x01);
1410 ASSERT_EQ(evt.conn_handles.size(), kDefaultBigParams.num_bis);
1411 }
1412
TEST_F(IsoManagerTest,TerminateBigHciCall)1413 TEST_F(IsoManagerTest, TerminateBigHciCall) {
1414 const uint8_t big_id = 0x22;
1415 const uint8_t reason = 0x16; // Terminated by local host
1416
1417 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
1418 EXPECT_CALL(hcic_interface_, TerminateBig(big_id, reason)).Times(1);
1419 IsoManager::GetInstance()->TerminateBig(big_id, reason);
1420 }
1421
TEST_F(IsoManagerDeathTest,TerminateSameBigTwice)1422 TEST_F(IsoManagerDeathTest, TerminateSameBigTwice) {
1423 const uint8_t big_id = 0x22;
1424 const uint8_t reason = 0x16; // Terminated by local host
1425
1426 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
1427 EXPECT_CALL(
1428 *big_callbacks_,
1429 OnBigEvent(bluetooth::hci::iso_manager::kIsoEventBigOnTerminateCmpl, _));
1430
1431 IsoManager::GetInstance()->TerminateBig(big_id, reason);
1432 ASSERT_EXIT(IsoManager::GetInstance()->TerminateBig(big_id, reason),
1433 ::testing::KilledBySignal(SIGABRT), "No such big");
1434 }
1435
TEST_F(IsoManagerDeathTest,TerminateBigNoSuchBig)1436 TEST_F(IsoManagerDeathTest, TerminateBigNoSuchBig) {
1437 const uint8_t big_id = 0x01;
1438 const uint8_t reason = 0x16; // Terminated by local host
1439
1440 EXPECT_CALL(
1441 *big_callbacks_,
1442 OnBigEvent(bluetooth::hci::iso_manager::kIsoEventBigOnCreateCmpl, _));
1443 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
1444
1445 ASSERT_EXIT(IsoManager::GetInstance()->TerminateBig(big_id + 1, reason),
1446 ::testing::KilledBySignal(SIGABRT), "No such big");
1447 }
1448
TEST_F(IsoManagerDeathTest,TerminateBigInvalidResponsePacket)1449 TEST_F(IsoManagerDeathTest, TerminateBigInvalidResponsePacket) {
1450 ON_CALL(hcic_interface_, TerminateBig)
1451 .WillByDefault([](auto big_handle, uint8_t reason) {
1452 std::vector<uint8_t> buf(1);
1453 uint8_t* p = buf.data();
1454 UINT8_TO_STREAM(p, reason);
1455
1456 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_TERM_BIG_CPL_EVT,
1457 buf.data(), buf.size());
1458 });
1459
1460 const uint8_t big_id = 0x22;
1461 const uint8_t reason = 0x16; // Terminated by local host
1462
1463 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
1464 ASSERT_EXIT(IsoManager::GetInstance()->TerminateBig(big_id, reason),
1465 ::testing::KilledBySignal(SIGABRT), "Invalid packet length");
1466 }
1467
TEST_F(IsoManagerDeathTest,TerminateBigInvalidResponsePacket2)1468 TEST_F(IsoManagerDeathTest, TerminateBigInvalidResponsePacket2) {
1469 const uint8_t big_id = 0x22;
1470 const uint8_t reason = 0x16; // Terminated by local host
1471
1472 ON_CALL(hcic_interface_, TerminateBig)
1473 .WillByDefault([](auto big_handle, uint8_t reason) {
1474 std::vector<uint8_t> buf(3);
1475 uint8_t* p = buf.data();
1476 UINT8_TO_STREAM(p, reason);
1477
1478 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_TERM_BIG_CPL_EVT,
1479 buf.data(), buf.size());
1480 });
1481
1482 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
1483 ASSERT_EXIT(IsoManager::GetInstance()->TerminateBig(big_id, reason),
1484 ::testing::KilledBySignal(SIGABRT), "Invalid packet length");
1485 }
1486
TEST_F(IsoManagerTest,TerminateBigInvalidResponseBigId)1487 TEST_F(IsoManagerTest, TerminateBigInvalidResponseBigId) {
1488 const uint8_t big_id = 0x22;
1489 const uint8_t reason = 0x16; // Terminated by local host
1490
1491 ON_CALL(hcic_interface_, TerminateBig)
1492 .WillByDefault([](auto big_handle, uint8_t reason) {
1493 std::vector<uint8_t> buf(2);
1494 uint8_t* p = buf.data();
1495 UINT8_TO_STREAM(p, reason);
1496 UINT8_TO_STREAM(p, big_handle + 1);
1497
1498 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_TERM_BIG_CPL_EVT,
1499 buf.data(), buf.size());
1500 });
1501
1502 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
1503 ASSERT_EXIT(IsoManager::GetInstance()->TerminateBig(big_id, reason),
1504 ::testing::KilledBySignal(SIGABRT), "No such big");
1505 }
1506
TEST_F(IsoManagerTest,TerminateBigValid)1507 TEST_F(IsoManagerTest, TerminateBigValid) {
1508 const uint8_t big_id = 0x22;
1509 const uint8_t reason = 0x16; // Terminated by local host
1510 bluetooth::hci::iso_manager::big_terminate_cmpl_evt evt;
1511 ASSERT_EQ(IsIsoActive, false);
1512
1513 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
1514 ASSERT_EQ(IsIsoActive, true);
1515
1516 EXPECT_CALL(
1517 *big_callbacks_,
1518 OnBigEvent(bluetooth::hci::iso_manager::kIsoEventBigOnTerminateCmpl, _))
1519 .WillOnce([&evt](uint8_t type, void* data) {
1520 evt =
1521 *static_cast<bluetooth::hci::iso_manager::big_terminate_cmpl_evt*>(
1522 data);
1523 return 0;
1524 });
1525
1526 IsoManager::GetInstance()->TerminateBig(big_id, reason);
1527 ASSERT_EQ(evt.big_id, big_id);
1528 ASSERT_EQ(evt.reason, reason);
1529 ASSERT_EQ(IsIsoActive, false);
1530 }
1531
TEST_F(IsoManagerTest,SetupIsoDataPathValid)1532 TEST_F(IsoManagerTest, SetupIsoDataPathValid) {
1533 IsoManager::GetInstance()->CreateCig(
1534 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1535 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1536 kDefaultBigParams);
1537
1538 // Establish all CISes before setting up their data paths
1539 bluetooth::hci::iso_manager::cis_establish_params params;
1540 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1541 params.conn_pairs.push_back({handle, 1});
1542 }
1543 IsoManager::GetInstance()->EstablishCis(params);
1544
1545 bluetooth::hci::iso_manager::iso_data_path_params path_params =
1546 kDefaultIsoDataPathParams;
1547
1548 // Setup data paths for all CISes
1549 path_params.data_path_dir =
1550 bluetooth::hci::iso_manager::kIsoDataPathDirectionIn;
1551 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1552 EXPECT_CALL(*cig_callbacks_,
1553 OnSetupIsoDataPath(HCI_SUCCESS, handle,
1554 volatile_test_cig_create_cmpl_evt_.cig_id))
1555 .Times(1)
1556 .RetiresOnSaturation();
1557
1558 path_params.data_path_dir =
1559 (bluetooth::hci::iso_manager::kIsoDataPathDirectionIn + handle) % 2;
1560
1561 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1562 }
1563
1564 // Setup data paths for all BISes
1565 path_params.data_path_dir =
1566 bluetooth::hci::iso_manager::kIsoDataPathDirectionOut;
1567 for (auto& handle : volatile_test_big_params_evt_.conn_handles) {
1568 std::cerr << "setting up BIS data path on conn_hdl: " << int{handle};
1569 EXPECT_CALL(*big_callbacks_,
1570 OnSetupIsoDataPath(HCI_SUCCESS, handle,
1571 volatile_test_big_params_evt_.big_id))
1572 .Times(1)
1573 .RetiresOnSaturation();
1574
1575 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1576 }
1577 }
1578
TEST_F(IsoManagerTest,SetupIsoDataPathTwice)1579 TEST_F(IsoManagerTest, SetupIsoDataPathTwice) {
1580 IsoManager::GetInstance()->CreateCig(
1581 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1582
1583 // Establish CISes
1584 bluetooth::hci::iso_manager::cis_establish_params params;
1585 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1586 params.conn_pairs.push_back({handle, 1});
1587 }
1588 IsoManager::GetInstance()->EstablishCis(params);
1589
1590 // Setup data paths for all CISes twice
1591 bluetooth::hci::iso_manager::iso_data_path_params path_params =
1592 kDefaultIsoDataPathParams;
1593 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1594 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1595 // Should be possible to reconfigure
1596 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1597 }
1598
1599 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1600 kDefaultBigParams);
1601 // Setup data paths for all BISes twice
1602 for (auto& handle : volatile_test_big_params_evt_.conn_handles) {
1603 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1604 // Should be possible to reconfigure
1605 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1606 }
1607 }
1608
TEST_F(IsoManagerTest,SetupIsoDataPathInvalidStatus)1609 TEST_F(IsoManagerTest, SetupIsoDataPathInvalidStatus) {
1610 IsoManager::GetInstance()->CreateCig(
1611 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1612 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1613 kDefaultBigParams);
1614
1615 // Establish all CISes before setting up their data paths
1616 bluetooth::hci::iso_manager::cis_establish_params params;
1617 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1618 params.conn_pairs.push_back({handle, 1});
1619 }
1620 IsoManager::GetInstance()->EstablishCis(params);
1621
1622 bluetooth::hci::iso_manager::iso_data_path_params path_params =
1623 kDefaultIsoDataPathParams;
1624
1625 uint8_t setup_datapath_rsp_status = HCI_SUCCESS;
1626 ON_CALL(hcic_interface_, SetupIsoDataPath)
1627 .WillByDefault([&setup_datapath_rsp_status](
1628 uint16_t iso_handle, uint8_t, uint8_t, uint8_t,
1629 uint16_t, uint16_t, uint32_t, std::vector<uint8_t>,
1630 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
1631 std::vector<uint8_t> buf(3);
1632 uint8_t* p = buf.data();
1633 UINT8_TO_STREAM(p, setup_datapath_rsp_status);
1634 UINT16_TO_STREAM(p, iso_handle);
1635
1636 std::move(cb).Run(buf.data(), buf.size());
1637 });
1638
1639 // Try to setup data paths for all CISes
1640 path_params.data_path_dir =
1641 bluetooth::hci::iso_manager::kIsoDataPathDirectionIn;
1642 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1643 // Mock the response with status != HCI_SUCCESS
1644 EXPECT_CALL(*cig_callbacks_,
1645 OnSetupIsoDataPath(0x11, handle,
1646 volatile_test_cig_create_cmpl_evt_.cig_id))
1647 .Times(1)
1648 .RetiresOnSaturation();
1649 setup_datapath_rsp_status = 0x11;
1650 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1651
1652 // It should be possible to retry on the same handle after the first
1653 // failure
1654 EXPECT_CALL(*cig_callbacks_,
1655 OnSetupIsoDataPath(HCI_SUCCESS, handle,
1656 volatile_test_cig_create_cmpl_evt_.cig_id))
1657 .Times(1)
1658 .RetiresOnSaturation();
1659 setup_datapath_rsp_status = HCI_SUCCESS;
1660 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1661 }
1662
1663 // Try to setup data paths for all BISes
1664 path_params.data_path_dir =
1665 bluetooth::hci::iso_manager::kIsoDataPathDirectionOut;
1666 for (auto& handle : volatile_test_big_params_evt_.conn_handles) {
1667 EXPECT_CALL(
1668 *big_callbacks_,
1669 OnSetupIsoDataPath(0x11, handle, volatile_test_big_params_evt_.big_id))
1670 .Times(1)
1671 .RetiresOnSaturation();
1672 setup_datapath_rsp_status = 0x11;
1673 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1674
1675 EXPECT_CALL(*big_callbacks_,
1676 OnSetupIsoDataPath(HCI_SUCCESS, handle,
1677 volatile_test_big_params_evt_.big_id))
1678 .Times(1)
1679 .RetiresOnSaturation();
1680 setup_datapath_rsp_status = HCI_SUCCESS;
1681 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1682 }
1683 }
1684
TEST_F(IsoManagerTest,RemoveIsoDataPathValid)1685 TEST_F(IsoManagerTest, RemoveIsoDataPathValid) {
1686 IsoManager::GetInstance()->CreateCig(
1687 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1688 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1689 kDefaultBigParams);
1690
1691 // Establish all CISes before setting up their data paths
1692 bluetooth::hci::iso_manager::cis_establish_params params;
1693 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1694 params.conn_pairs.push_back({handle, 1});
1695 }
1696 IsoManager::GetInstance()->EstablishCis(params);
1697
1698 bluetooth::hci::iso_manager::iso_data_path_params path_params =
1699 kDefaultIsoDataPathParams;
1700
1701 // Setup and remove data paths for all CISes
1702 path_params.data_path_dir =
1703 bluetooth::hci::iso_manager::kRemoveIsoDataPathDirectionInput;
1704 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1705 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1706
1707 EXPECT_CALL(*cig_callbacks_,
1708 OnRemoveIsoDataPath(HCI_SUCCESS, handle,
1709 volatile_test_cig_create_cmpl_evt_.cig_id))
1710 .Times(1)
1711 .RetiresOnSaturation();
1712 IsoManager::GetInstance()->RemoveIsoDataPath(handle,
1713 path_params.data_path_dir);
1714 }
1715
1716 // Setup and remove data paths for all BISes
1717 path_params.data_path_dir =
1718 bluetooth::hci::iso_manager::kIsoDataPathDirectionOut;
1719 for (auto& handle : volatile_test_big_params_evt_.conn_handles) {
1720 std::cerr << "setting up BIS data path on conn_hdl: " << int{handle};
1721 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1722
1723 EXPECT_CALL(*big_callbacks_,
1724 OnRemoveIsoDataPath(HCI_SUCCESS, handle,
1725 volatile_test_big_params_evt_.big_id))
1726 .Times(1)
1727 .RetiresOnSaturation();
1728 IsoManager::GetInstance()->RemoveIsoDataPath(handle,
1729 path_params.data_path_dir);
1730 }
1731 }
1732
TEST_F(IsoManagerDeathTest,RemoveIsoDataPathNoSuchPath)1733 TEST_F(IsoManagerDeathTest, RemoveIsoDataPathNoSuchPath) {
1734 // Check on CIS
1735 IsoManager::GetInstance()->CreateCig(
1736 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1737 uint16_t iso_handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
1738 ASSERT_EXIT(
1739 IsoManager::GetInstance()->RemoveIsoDataPath(
1740 iso_handle, bluetooth::hci::iso_manager::kIsoDataPathDirectionOut),
1741 ::testing::KilledBySignal(SIGABRT), "path not set");
1742
1743 IsoManager::GetInstance()->EstablishCis({.conn_pairs = {{iso_handle, 1}}});
1744 ASSERT_EXIT(
1745 IsoManager::GetInstance()->RemoveIsoDataPath(
1746 iso_handle, bluetooth::hci::iso_manager::kIsoDataPathDirectionOut),
1747 ::testing::KilledBySignal(SIGABRT), "path not set");
1748
1749 // Check on BIS
1750 iso_handle = volatile_test_big_params_evt_.conn_handles[0];
1751 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1752 kDefaultBigParams);
1753 ASSERT_EXIT(
1754 IsoManager::GetInstance()->RemoveIsoDataPath(
1755 iso_handle, bluetooth::hci::iso_manager::kIsoDataPathDirectionOut),
1756 ::testing::KilledBySignal(SIGABRT), "path not set");
1757 }
1758
TEST_F(IsoManagerDeathTest,RemoveIsoDataPathTwice)1759 TEST_F(IsoManagerDeathTest, RemoveIsoDataPathTwice) {
1760 // Check on CIS
1761 IsoManager::GetInstance()->CreateCig(
1762 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1763 uint16_t iso_handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
1764 IsoManager::GetInstance()->EstablishCis({.conn_pairs = {{iso_handle, 1}}});
1765 IsoManager::GetInstance()->SetupIsoDataPath(iso_handle,
1766 kDefaultIsoDataPathParams);
1767 IsoManager::GetInstance()->RemoveIsoDataPath(
1768 iso_handle, kDefaultIsoDataPathParams.data_path_dir);
1769 ASSERT_EXIT(
1770 IsoManager::GetInstance()->RemoveIsoDataPath(
1771 iso_handle, bluetooth::hci::iso_manager::kIsoDataPathDirectionOut),
1772 ::testing::KilledBySignal(SIGABRT), "path not set");
1773
1774 // Check on BIS
1775 iso_handle = volatile_test_big_params_evt_.conn_handles[0];
1776 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1777 kDefaultBigParams);
1778 IsoManager::GetInstance()->SetupIsoDataPath(iso_handle,
1779 kDefaultIsoDataPathParams);
1780 IsoManager::GetInstance()->RemoveIsoDataPath(
1781 iso_handle, kDefaultIsoDataPathParams.data_path_dir);
1782 ASSERT_EXIT(
1783 IsoManager::GetInstance()->RemoveIsoDataPath(
1784 iso_handle, bluetooth::hci::iso_manager::kIsoDataPathDirectionOut),
1785 ::testing::KilledBySignal(SIGABRT), "path not set");
1786 }
1787
1788 // Check if HCI status other than HCI_SUCCESS is being propagated to the caller
TEST_F(IsoManagerTest,RemoveIsoDataPathInvalidStatus)1789 TEST_F(IsoManagerTest, RemoveIsoDataPathInvalidStatus) {
1790 // Mock invalid status response
1791 uint8_t remove_datapath_rsp_status = 0x12;
1792 ON_CALL(hcic_interface_, RemoveIsoDataPath)
1793 .WillByDefault([&remove_datapath_rsp_status](
1794 uint16_t iso_handle, uint8_t data_path_dir,
1795 base::OnceCallback<void(uint8_t*, uint16_t)> cb) {
1796 std::vector<uint8_t> buf(3);
1797 uint8_t* p = buf.data();
1798 UINT8_TO_STREAM(p, remove_datapath_rsp_status);
1799 UINT16_TO_STREAM(p, iso_handle);
1800
1801 std::move(cb).Run(buf.data(), buf.size());
1802 });
1803
1804 // Check on CIS
1805 IsoManager::GetInstance()->CreateCig(
1806 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1807 uint16_t iso_handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
1808 IsoManager::GetInstance()->EstablishCis({.conn_pairs = {{iso_handle, 1}}});
1809 IsoManager::GetInstance()->SetupIsoDataPath(iso_handle,
1810 kDefaultIsoDataPathParams);
1811
1812 EXPECT_CALL(*cig_callbacks_,
1813 OnRemoveIsoDataPath(remove_datapath_rsp_status, iso_handle,
1814 volatile_test_cig_create_cmpl_evt_.cig_id))
1815 .Times(1);
1816 IsoManager::GetInstance()->RemoveIsoDataPath(
1817 iso_handle, kDefaultIsoDataPathParams.data_path_dir);
1818
1819 // Check on BIS
1820 iso_handle = volatile_test_big_params_evt_.conn_handles[0];
1821 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1822 kDefaultBigParams);
1823 IsoManager::GetInstance()->SetupIsoDataPath(iso_handle,
1824 kDefaultIsoDataPathParams);
1825
1826 EXPECT_CALL(*big_callbacks_,
1827 OnRemoveIsoDataPath(remove_datapath_rsp_status, iso_handle,
1828 volatile_test_big_params_evt_.big_id))
1829 .Times(1);
1830 IsoManager::GetInstance()->RemoveIsoDataPath(
1831 iso_handle, kDefaultIsoDataPathParams.data_path_dir);
1832 }
1833
TEST_F(IsoManagerTest,SendIsoDataWithNoCigConnected)1834 TEST_F(IsoManagerTest, SendIsoDataWithNoCigConnected) {
1835 std::vector<uint8_t> data_vec(108, 0);
1836 IsoManager::GetInstance()->CreateCig(
1837 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1838
1839 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
1840 IsoManager::GetInstance()->SendIsoData(handle, data_vec.data(),
1841 data_vec.size());
1842 EXPECT_CALL(bte_interface_, HciSend).Times(0);
1843 }
1844
TEST_F(IsoManagerTest,SendIsoDataCigValid)1845 TEST_F(IsoManagerTest, SendIsoDataCigValid) {
1846 IsoManager::GetInstance()->CreateCig(
1847 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1848
1849 bluetooth::hci::iso_manager::cis_establish_params params;
1850 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1851 params.conn_pairs.push_back({handle, 1});
1852 }
1853 IsoManager::GetInstance()->EstablishCis(params);
1854
1855 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1856 bluetooth::hci::iso_manager::iso_data_path_params path_params =
1857 kDefaultIsoDataPathParams;
1858 path_params.data_path_dir =
1859 bluetooth::hci::iso_manager::kIsoDataPathDirectionOut;
1860 IsoManager::GetInstance()->SetupIsoDataPath(handle, path_params);
1861
1862 for (uint8_t num_pkts = 2; num_pkts != 0; num_pkts--) {
1863 constexpr uint8_t data_len = 108;
1864
1865 EXPECT_CALL(bte_interface_, HciSend)
1866 .WillOnce([handle, data_len](BT_HDR* p_msg, uint16_t event) {
1867 uint8_t* p = p_msg->data;
1868 uint16_t msg_handle;
1869 uint16_t iso_load_len;
1870
1871 ASSERT_TRUE((event & MSG_STACK_TO_HC_HCI_ISO) != 0);
1872 ASSERT_NE(p_msg, nullptr);
1873 ASSERT_EQ(p_msg->len, data_len + ((p_msg->layer_specific &
1874 BT_ISO_HDR_CONTAINS_TS)
1875 ? 12
1876 : 8));
1877
1878 // Verify packet internals
1879 STREAM_TO_UINT16(msg_handle, p);
1880 ASSERT_EQ(msg_handle, handle);
1881
1882 STREAM_TO_UINT16(iso_load_len, p);
1883 ASSERT_EQ(
1884 iso_load_len,
1885 data_len +
1886 ((p_msg->layer_specific & BT_ISO_HDR_CONTAINS_TS) ? 8 : 4));
1887
1888 if (p_msg->layer_specific & BT_ISO_HDR_CONTAINS_TS) {
1889 STREAM_SKIP_UINT16(p); // skip ts LSB halfword
1890 STREAM_SKIP_UINT16(p); // skip ts MSB halfword
1891 }
1892 STREAM_SKIP_UINT16(p); // skip seq_nb
1893
1894 uint16_t msg_data_len;
1895 STREAM_TO_UINT16(msg_data_len, p);
1896 ASSERT_EQ(msg_data_len, data_len);
1897 })
1898 .RetiresOnSaturation();
1899
1900 std::vector<uint8_t> data_vec(data_len, 0);
1901 IsoManager::GetInstance()->SendIsoData(handle, data_vec.data(),
1902 data_vec.size());
1903 }
1904 }
1905 }
1906
TEST_F(IsoManagerTest,SendIsoDataBigValid)1907 TEST_F(IsoManagerTest, SendIsoDataBigValid) {
1908 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1909 kDefaultBigParams);
1910
1911 for (auto& handle : volatile_test_big_params_evt_.conn_handles) {
1912 IsoManager::GetInstance()->SetupIsoDataPath(handle,
1913 kDefaultIsoDataPathParams);
1914 for (uint8_t num_pkts = 2; num_pkts != 0; num_pkts--) {
1915 constexpr uint8_t data_len = 108;
1916
1917 EXPECT_CALL(bte_interface_, HciSend)
1918 .WillOnce([handle, data_len](BT_HDR* p_msg, uint16_t event) {
1919 uint8_t* p = p_msg->data;
1920 uint16_t msg_handle;
1921 uint16_t iso_load_len;
1922
1923 ASSERT_TRUE((event & MSG_STACK_TO_HC_HCI_ISO) != 0);
1924 ASSERT_NE(p_msg, nullptr);
1925 ASSERT_EQ(p_msg->len, data_len + ((p_msg->layer_specific &
1926 BT_ISO_HDR_CONTAINS_TS)
1927 ? 12
1928 : 8));
1929
1930 // Verify packet internals
1931 STREAM_TO_UINT16(msg_handle, p);
1932 ASSERT_EQ(msg_handle, handle);
1933
1934 STREAM_TO_UINT16(iso_load_len, p);
1935 ASSERT_EQ(
1936 iso_load_len,
1937 data_len +
1938 ((p_msg->layer_specific & BT_ISO_HDR_CONTAINS_TS) ? 8 : 4));
1939
1940 uint16_t msg_data_len;
1941 uint16_t msg_dummy;
1942 if (p_msg->layer_specific & BT_ISO_HDR_CONTAINS_TS) {
1943 STREAM_TO_UINT16(msg_dummy, p); // skip ts LSB halfword
1944 STREAM_TO_UINT16(msg_dummy, p); // skip ts MSB halfword
1945 }
1946 STREAM_TO_UINT16(msg_dummy, p); // skip seq_nb
1947
1948 STREAM_TO_UINT16(msg_data_len, p);
1949 ASSERT_EQ(msg_data_len, data_len);
1950 })
1951 .RetiresOnSaturation();
1952
1953 std::vector<uint8_t> data_vec(data_len, 0);
1954 IsoManager::GetInstance()->SendIsoData(handle, data_vec.data(),
1955 data_vec.size());
1956 }
1957 }
1958 }
1959
TEST_F(IsoManagerTest,SendIsoDataNoCredits)1960 TEST_F(IsoManagerTest, SendIsoDataNoCredits) {
1961 uint8_t num_buffers = controller_interface_.GetIsoBufferCount();
1962 std::vector<uint8_t> data_vec(108, 0);
1963
1964 // Check on CIG
1965 IsoManager::GetInstance()->CreateCig(
1966 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
1967
1968 bluetooth::hci::iso_manager::cis_establish_params params;
1969 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
1970 params.conn_pairs.push_back({handle, 1});
1971 }
1972 IsoManager::GetInstance()->EstablishCis(params);
1973
1974 IsoManager::GetInstance()->SetupIsoDataPath(
1975 volatile_test_cig_create_cmpl_evt_.conn_handles[0],
1976 kDefaultIsoDataPathParams);
1977
1978 /* Try sending twice as much data as we can ignoring the credit limits and
1979 * expect the redundant packets to be ignored and not propagated down to the
1980 * HCI.
1981 */
1982 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers).RetiresOnSaturation();
1983 for (uint8_t i = 0; i < (2 * num_buffers); i++) {
1984 IsoManager::GetInstance()->SendIsoData(
1985 volatile_test_cig_create_cmpl_evt_.conn_handles[0], data_vec.data(),
1986 data_vec.size());
1987 }
1988
1989 // Return all credits for this one handle
1990 uint8_t mock_rsp[5];
1991 uint8_t* p = mock_rsp;
1992 UINT8_TO_STREAM(p, 1);
1993 UINT16_TO_STREAM(p, volatile_test_cig_create_cmpl_evt_.conn_handles[0]);
1994 UINT16_TO_STREAM(p, num_buffers);
1995 IsoManager::GetInstance()->HandleNumComplDataPkts(mock_rsp, sizeof(mock_rsp));
1996
1997 // Check on BIG
1998 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
1999 kDefaultBigParams);
2000 IsoManager::GetInstance()->SetupIsoDataPath(
2001 volatile_test_big_params_evt_.conn_handles[0], kDefaultIsoDataPathParams);
2002
2003 /* Try sending twice as much data as we can ignoring the credit limits and
2004 * expect the redundant packets to be ignored and not propagated down to the
2005 * HCI.
2006 */
2007 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers);
2008 for (uint8_t i = 0; i < (2 * num_buffers); i++) {
2009 IsoManager::GetInstance()->SendIsoData(
2010 volatile_test_big_params_evt_.conn_handles[0], data_vec.data(),
2011 data_vec.size());
2012 }
2013 }
2014
TEST_F(IsoManagerTest,SendIsoDataCreditsReturned)2015 TEST_F(IsoManagerTest, SendIsoDataCreditsReturned) {
2016 uint8_t num_buffers = controller_interface_.GetIsoBufferCount();
2017 std::vector<uint8_t> data_vec(108, 0);
2018
2019 // Check on CIG
2020 IsoManager::GetInstance()->CreateCig(
2021 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2022
2023 bluetooth::hci::iso_manager::cis_establish_params params;
2024 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
2025 params.conn_pairs.push_back({handle, 1});
2026 }
2027 IsoManager::GetInstance()->EstablishCis(params);
2028
2029 IsoManager::GetInstance()->SetupIsoDataPath(
2030 volatile_test_cig_create_cmpl_evt_.conn_handles[0],
2031 kDefaultIsoDataPathParams);
2032
2033 /* Try sending twice as much data as we can, ignoring the credits limit and
2034 * expect the redundant packets to be ignored and not propagated down to the
2035 * HCI.
2036 */
2037 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers).RetiresOnSaturation();
2038 for (uint8_t i = 0; i < (2 * num_buffers); i++) {
2039 IsoManager::GetInstance()->SendIsoData(
2040 volatile_test_cig_create_cmpl_evt_.conn_handles[0], data_vec.data(),
2041 data_vec.size());
2042 }
2043
2044 // Return all credits for this one handle
2045 uint8_t mock_rsp[5];
2046 uint8_t* p = mock_rsp;
2047 UINT8_TO_STREAM(p, 1);
2048 UINT16_TO_STREAM(p, volatile_test_cig_create_cmpl_evt_.conn_handles[0]);
2049 UINT16_TO_STREAM(p, num_buffers);
2050 IsoManager::GetInstance()->HandleNumComplDataPkts(mock_rsp, sizeof(mock_rsp));
2051
2052 // Expect some more events go down the HCI
2053 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers).RetiresOnSaturation();
2054 for (uint8_t i = 0; i < (2 * num_buffers); i++) {
2055 IsoManager::GetInstance()->SendIsoData(
2056 volatile_test_cig_create_cmpl_evt_.conn_handles[0], data_vec.data(),
2057 data_vec.size());
2058 }
2059
2060 // Return all credits for this one handle
2061 p = mock_rsp;
2062 UINT8_TO_STREAM(p, 1);
2063 UINT16_TO_STREAM(p, volatile_test_cig_create_cmpl_evt_.conn_handles[0]);
2064 UINT16_TO_STREAM(p, num_buffers);
2065 IsoManager::GetInstance()->HandleNumComplDataPkts(mock_rsp, sizeof(mock_rsp));
2066
2067 // Check on BIG
2068 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
2069 kDefaultBigParams);
2070 IsoManager::GetInstance()->SetupIsoDataPath(
2071 volatile_test_big_params_evt_.conn_handles[0], kDefaultIsoDataPathParams);
2072
2073 /* Try sending twice as much data as we can, ignoring the credits limit and
2074 * expect the redundant packets to be ignored and not propagated down to the
2075 * HCI.
2076 */
2077 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers).RetiresOnSaturation();
2078 for (uint8_t i = 0; i < (2 * num_buffers); i++) {
2079 IsoManager::GetInstance()->SendIsoData(
2080 volatile_test_big_params_evt_.conn_handles[0], data_vec.data(),
2081 data_vec.size());
2082 }
2083
2084 // Return all credits for this one handle
2085 p = mock_rsp;
2086 UINT8_TO_STREAM(p, 1);
2087 UINT16_TO_STREAM(p, volatile_test_big_params_evt_.conn_handles[0]);
2088 UINT16_TO_STREAM(p, num_buffers);
2089 IsoManager::GetInstance()->HandleNumComplDataPkts(mock_rsp, sizeof(mock_rsp));
2090
2091 // Expect some more events go down the HCI
2092 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers).RetiresOnSaturation();
2093 for (uint8_t i = 0; i < (2 * num_buffers); i++) {
2094 IsoManager::GetInstance()->SendIsoData(
2095 volatile_test_big_params_evt_.conn_handles[0], data_vec.data(),
2096 data_vec.size());
2097 }
2098 }
2099
TEST_F(IsoManagerTest,SendIsoDataCreditsReturnedByDisconnection)2100 TEST_F(IsoManagerTest, SendIsoDataCreditsReturnedByDisconnection) {
2101 uint8_t num_buffers = controller_interface_.GetIsoBufferCount();
2102 std::vector<uint8_t> data_vec(108, 0);
2103
2104 // Check on CIG
2105 IsoManager::GetInstance()->CreateCig(
2106 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2107
2108 bluetooth::hci::iso_manager::cis_establish_params params;
2109 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
2110 params.conn_pairs.push_back({handle, 1});
2111 }
2112 IsoManager::GetInstance()->EstablishCis(params);
2113
2114 for (auto& handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
2115 IsoManager::GetInstance()->SetupIsoDataPath(handle,
2116 kDefaultIsoDataPathParams);
2117 }
2118
2119 /* Sending lot of ISO data to first ISO and getting all the credits */
2120 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers).RetiresOnSaturation();
2121 for (uint8_t i = 0; i < num_buffers; i++) {
2122 IsoManager::GetInstance()->SendIsoData(
2123 volatile_test_cig_create_cmpl_evt_.conn_handles[0], data_vec.data(),
2124 data_vec.size());
2125 }
2126
2127 /* Return all credits by disconnecting CIS */
2128 IsoManager::GetInstance()->HandleDisconnect(
2129 volatile_test_cig_create_cmpl_evt_.conn_handles[0], 16);
2130
2131 /* Try to send ISO data on the second ISO. Expect credits being available.*/
2132 EXPECT_CALL(bte_interface_, HciSend).Times(num_buffers).RetiresOnSaturation();
2133 for (uint8_t i = 0; i < num_buffers; i++) {
2134 IsoManager::GetInstance()->SendIsoData(
2135 volatile_test_cig_create_cmpl_evt_.conn_handles[1], data_vec.data(),
2136 data_vec.size());
2137 }
2138 }
2139
TEST_F(IsoManagerDeathTest,SendIsoDataWithNoDataPath)2140 TEST_F(IsoManagerDeathTest, SendIsoDataWithNoDataPath) {
2141 std::vector<uint8_t> data_vec(108, 0);
2142
2143 // Check on CIG
2144 IsoManager::GetInstance()->CreateCig(
2145 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2146
2147 bluetooth::hci::iso_manager::cis_establish_params params;
2148 for (auto& conn_handle : volatile_test_cig_create_cmpl_evt_.conn_handles) {
2149 params.conn_pairs.push_back({conn_handle, 1});
2150 }
2151 IsoManager::GetInstance()->EstablishCis(params);
2152
2153 EXPECT_CALL(bte_interface_, HciSend).Times(0);
2154 IsoManager::GetInstance()->SendIsoData(
2155 volatile_test_cig_create_cmpl_evt_.conn_handles[0], data_vec.data(),
2156 data_vec.size());
2157
2158 // Check on BIG
2159 IsoManager::GetInstance()->CreateBig(volatile_test_big_params_evt_.big_id,
2160 kDefaultBigParams);
2161
2162 EXPECT_CALL(bte_interface_, HciSend).Times(0);
2163 IsoManager::GetInstance()->SendIsoData(
2164 volatile_test_big_params_evt_.conn_handles[0], data_vec.data(),
2165 data_vec.size());
2166 }
2167
TEST_F(IsoManagerDeathTest,SendIsoDataWithNoCigBigHandle)2168 TEST_F(IsoManagerDeathTest, SendIsoDataWithNoCigBigHandle) {
2169 std::vector<uint8_t> data_vec(108, 0);
2170 ASSERT_EXIT(IsoManager::GetInstance()->SendIsoData(134, data_vec.data(),
2171 data_vec.size()),
2172 ::testing::KilledBySignal(SIGABRT), "No such iso");
2173 }
2174
TEST_F(IsoManagerTest,HandleDisconnectNoSuchHandle)2175 TEST_F(IsoManagerTest, HandleDisconnectNoSuchHandle) {
2176 // Don't expect any callbacks when connection handle is not for ISO.
2177 EXPECT_CALL(*cig_callbacks_, OnCigEvent).Times(0);
2178 EXPECT_CALL(*cig_callbacks_, OnCisEvent).Times(0);
2179 EXPECT_CALL(*big_callbacks_, OnBigEvent).Times(0);
2180
2181 IsoManager::GetInstance()->HandleDisconnect(123, 16);
2182 }
2183
TEST_F(IsoManagerTest,HandleDisconnectValidCig)2184 TEST_F(IsoManagerTest, HandleDisconnectValidCig) {
2185 IsoManager::GetInstance()->CreateCig(
2186 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2187
2188 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
2189 IsoManager::GetInstance()->EstablishCis({{{handle, 1}}});
2190
2191 EXPECT_CALL(*big_callbacks_, OnBigEvent).Times(0);
2192 EXPECT_CALL(*cig_callbacks_, OnCigEvent).Times(0);
2193 EXPECT_CALL(*cig_callbacks_, OnCisEvent).Times(0);
2194
2195 // Expect disconnect event exactly once
2196 EXPECT_CALL(*cig_callbacks_, OnCisEvent)
2197 .WillOnce([this, handle](uint8_t event_code, void* data) {
2198 ASSERT_EQ(event_code,
2199 bluetooth::hci::iso_manager::kIsoEventCisDisconnected);
2200 auto* event =
2201 static_cast<bluetooth::hci::iso_manager::cis_disconnected_evt*>(
2202 data);
2203 ASSERT_EQ(event->reason, 16);
2204 ASSERT_EQ(event->cig_id, volatile_test_cig_create_cmpl_evt_.cig_id);
2205 ASSERT_EQ(event->cis_conn_hdl, handle);
2206 });
2207
2208 IsoManager::GetInstance()->HandleDisconnect(handle, 16);
2209 }
2210
TEST_F(IsoManagerTest,HandleDisconnectDisconnectedCig)2211 TEST_F(IsoManagerTest, HandleDisconnectDisconnectedCig) {
2212 IsoManager::GetInstance()->CreateCig(
2213 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2214
2215 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
2216 IsoManager::GetInstance()->EstablishCis({{{handle, 1}}});
2217
2218 EXPECT_CALL(*big_callbacks_, OnBigEvent).Times(0);
2219 EXPECT_CALL(*cig_callbacks_, OnCigEvent).Times(0);
2220 EXPECT_CALL(*cig_callbacks_, OnCisEvent).Times(0);
2221
2222 // Expect disconnect event exactly once
2223 EXPECT_CALL(
2224 *cig_callbacks_,
2225 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisDisconnected, _))
2226 .Times(1)
2227 .RetiresOnSaturation();
2228 IsoManager::GetInstance()->HandleDisconnect(handle, 16);
2229
2230 // This one was once connected - expect no events
2231 IsoManager::GetInstance()->HandleDisconnect(handle, 16);
2232
2233 // This one was never connected - expect no events
2234 handle = volatile_test_cig_create_cmpl_evt_.conn_handles[1];
2235 IsoManager::GetInstance()->HandleDisconnect(handle, 16);
2236 }
2237
TEST_F(IsoManagerTest,HandleIsoData)2238 TEST_F(IsoManagerTest, HandleIsoData) {
2239 IsoManager::GetInstance()->CreateCig(
2240 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2241
2242 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
2243 IsoManager::GetInstance()->EstablishCis({{{handle, 1}}});
2244
2245 EXPECT_CALL(
2246 *cig_callbacks_,
2247 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisDataAvailable, _))
2248 .Times(1);
2249
2250 std::vector<uint8_t> dummy_msg(18);
2251 uint8_t* p = dummy_msg.data();
2252 UINT16_TO_STREAM(p, BT_EVT_TO_BTU_HCI_ISO);
2253 UINT16_TO_STREAM(p, 10); // .len
2254 UINT16_TO_STREAM(p, 0); // .offset
2255 UINT16_TO_STREAM(p, 0); // .layer_specific
2256 UINT16_TO_STREAM(p, handle);
2257 IsoManager::GetInstance()->HandleIsoData(dummy_msg.data());
2258 }
2259
2260 /* This test case simulates HCI thread scheduling events on the main thread,
2261 * without knowing the we are already shutting down the stack and Iso Manager
2262 * is already stopped.
2263 */
TEST_F(IsoManagerDeathTestNoCleanup,HandleLateArivingEventHandleIsoData)2264 TEST_F(IsoManagerDeathTestNoCleanup, HandleLateArivingEventHandleIsoData) {
2265 IsoManager::GetInstance()->CreateCig(
2266 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2267
2268 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
2269 IsoManager::GetInstance()->EstablishCis({{{handle, 1}}});
2270
2271 // Stop iso manager before trying to call the HCI callbacks
2272 IsoManager::GetInstance()->Stop();
2273
2274 EXPECT_CALL(
2275 *cig_callbacks_,
2276 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisDataAvailable, _))
2277 .Times(0);
2278
2279 // Expect no assert on this call - should be gracefully ignored
2280 std::vector<uint8_t> dummy_msg(18);
2281 uint8_t* p = dummy_msg.data();
2282 UINT16_TO_STREAM(p, BT_EVT_TO_BTU_HCI_ISO);
2283 UINT16_TO_STREAM(p, 10); // .len
2284 UINT16_TO_STREAM(p, 0); // .offset
2285 UINT16_TO_STREAM(p, 0); // .layer_specific
2286 UINT16_TO_STREAM(p, handle);
2287 IsoManager::GetInstance()->HandleIsoData(dummy_msg.data());
2288 }
2289
2290 /* This test case simulates HCI thread scheduling events on the main thread,
2291 * without knowing the we are already shutting down the stack and Iso Manager
2292 * is already stopped.
2293 */
TEST_F(IsoManagerDeathTestNoCleanup,HandleLateArivingEventHandleDisconnect)2294 TEST_F(IsoManagerDeathTestNoCleanup, HandleLateArivingEventHandleDisconnect) {
2295 IsoManager::GetInstance()->CreateCig(
2296 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2297
2298 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
2299 IsoManager::GetInstance()->EstablishCis({{{handle, 1}}});
2300
2301 // Stop iso manager before trying to call the HCI callbacks
2302 IsoManager::GetInstance()->Stop();
2303
2304 // Expect no event when callback is being called on a stopped iso manager
2305 EXPECT_CALL(*cig_callbacks_, OnCisEvent).Times(0);
2306 // Expect no assert on this call - should be gracefully ignored
2307 IsoManager::GetInstance()->HandleDisconnect(handle, 16);
2308 }
2309
2310 /* This test case simulates HCI thread scheduling events on the main thread,
2311 * without knowing the we are already shutting down the stack and Iso Manager
2312 * is already stopped.
2313 */
TEST_F(IsoManagerDeathTestNoCleanup,HandleLateArivingEventHandleNumComplDataPkts)2314 TEST_F(IsoManagerDeathTestNoCleanup,
2315 HandleLateArivingEventHandleNumComplDataPkts) {
2316 uint8_t num_buffers = controller_interface_.GetIsoBufferCount();
2317
2318 IsoManager::GetInstance()->CreateCig(
2319 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2320
2321 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
2322 IsoManager::GetInstance()->EstablishCis({{{handle, 1}}});
2323
2324 // Stop iso manager before trying to call the HCI callbacks
2325 IsoManager::GetInstance()->Stop();
2326
2327 // Expect no assert on this call - should be gracefully ignored
2328 uint8_t mock_rsp[5];
2329 uint8_t* p = mock_rsp;
2330 UINT8_TO_STREAM(p, 1);
2331 UINT16_TO_STREAM(p, handle);
2332 UINT16_TO_STREAM(p, num_buffers);
2333 IsoManager::GetInstance()->HandleNumComplDataPkts(mock_rsp, sizeof(mock_rsp));
2334 }
2335
2336 /* This test case simulates HCI thread scheduling events on the main thread,
2337 * without knowing the we are already shutting down the stack and Iso Manager
2338 * is already stopped.
2339 */
TEST_F(IsoManagerDeathTestNoCleanup,HandleLateArivingEventHandleHciEvent)2340 TEST_F(IsoManagerDeathTestNoCleanup, HandleLateArivingEventHandleHciEvent) {
2341 const uint8_t big_id = 0x22;
2342
2343 IsoManager::GetInstance()->CreateBig(big_id, kDefaultBigParams);
2344
2345 // Stop iso manager before trying to call the HCI callbacks
2346 IsoManager::GetInstance()->Stop();
2347 EXPECT_CALL(
2348 *big_callbacks_,
2349 OnBigEvent(bluetooth::hci::iso_manager::kIsoEventBigOnTerminateCmpl, _))
2350 .Times(0);
2351
2352 // Expect no assert on this call - should be gracefully ignored
2353 std::vector<uint8_t> buf(2);
2354 uint8_t* p = buf.data();
2355 UINT8_TO_STREAM(p, big_id);
2356 UINT8_TO_STREAM(p, 16); // Terminated by local host
2357 IsoManager::GetInstance()->HandleHciEvent(HCI_BLE_TERM_BIG_CPL_EVT,
2358 buf.data(), buf.size());
2359 }
2360
TEST_F(IsoManagerTest,HandleIsoDataSameSeqNb)2361 TEST_F(IsoManagerTest, HandleIsoDataSameSeqNb) {
2362 IsoManager::GetInstance()->CreateCig(
2363 volatile_test_cig_create_cmpl_evt_.cig_id, kDefaultCigParams);
2364
2365 auto handle = volatile_test_cig_create_cmpl_evt_.conn_handles[0];
2366 IsoManager::GetInstance()->EstablishCis({{{handle, 1}}});
2367
2368 EXPECT_CALL(
2369 *cig_callbacks_,
2370 OnCisEvent(bluetooth::hci::iso_manager::kIsoEventCisDataAvailable, _))
2371 .Times(2);
2372
2373 std::vector<uint8_t> dummy_msg(18);
2374 uint8_t* p = dummy_msg.data();
2375 UINT16_TO_STREAM(p, BT_EVT_TO_BTU_HCI_ISO);
2376 UINT16_TO_STREAM(p, 10); // .len
2377 UINT16_TO_STREAM(p, 0); // .offset
2378 UINT16_TO_STREAM(p, 0); // .layer_specific
2379 UINT16_TO_STREAM(p, handle);
2380
2381 IsoManager::GetInstance()->HandleIsoData(dummy_msg.data());
2382 IsoManager::GetInstance()->HandleIsoData(dummy_msg.data());
2383 }
2384