1 /****************************************************************************** 2 * 3 * Copyright 2016 The Android Open Source Project 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 19 #include <array> 20 #include <gmock/gmock.h> 21 #include <gtest/gtest.h> 22 23 #include "device/include/controller.h" 24 #include "stack/btm/ble_advertiser_hci_interface.h" 25 #include "stack/include/ble_advertiser.h" 26 27 using ::testing::Args; 28 using ::testing::Contains; 29 using ::testing::ElementsAreArray; 30 using ::testing::Exactly; 31 using ::testing::Field; 32 using ::testing::IsEmpty; 33 using ::testing::SaveArg; 34 using ::testing::SizeIs; 35 using ::testing::_; 36 using base::Bind; 37 using status_cb = BleAdvertiserHciInterface::status_cb; 38 using parameters_cb = BleAdvertiserHciInterface::parameters_cb; 39 using SetEnableData = BleAdvertiserHciInterface::SetEnableData; 40 41 const int num_adv_instances = 16; 42 43 /* Below are methods that must be implemented if we don't want to compile the 44 * whole stack. They will be removed, or changed into mocks one by one in the 45 * future, as the refactoring progresses */ 46 bool BTM_BleLocalPrivacyEnabled() { return true; } 47 uint16_t BTM_ReadDiscoverability(uint16_t* p_window, uint16_t* p_interval) { 48 return true; 49 } 50 bool SMP_Encrypt(uint8_t* key, uint8_t key_len, uint8_t* plain_text, 51 uint8_t pt_len, tSMP_ENC* p_out) { 52 return true; 53 } 54 void BTM_GetDeviceIDRoot(BT_OCTET16 irk) {} 55 void btm_ble_update_dmt_flag_bits(uint8_t* flag_value, 56 const uint16_t connect_mode, 57 const uint16_t disc_mode) {} 58 void btm_acl_update_conn_addr(uint16_t conn_handle, const RawAddress& address) { 59 } 60 void btm_gen_resolvable_private_addr(base::Callback<void(uint8_t[8])> cb) { 61 uint8_t fake_rand[8] = {0, 0, 0, 0, 0, 0, 0, 0}; 62 cb.Run(fake_rand); 63 } 64 65 alarm_callback_t last_alarm_cb = nullptr; 66 void* last_alarm_data = nullptr; 67 void alarm_set_on_mloop(alarm_t* alarm, period_ms_t interval_ms, 68 alarm_callback_t cb, void* data) { 69 last_alarm_cb = cb; 70 last_alarm_data = data; 71 } 72 73 void alarm_cancel(alarm_t* alarm) {} 74 alarm_t* alarm_new_periodic(const char* name) { return nullptr; } 75 alarm_t* alarm_new(const char* name) { return nullptr; } 76 void alarm_free(alarm_t* alarm) {} 77 const controller_t* controller_get_interface() { return nullptr; } 78 79 namespace { 80 void DoNothing(uint8_t) {} 81 82 void DoNothing2(uint8_t, uint8_t) {} 83 84 void TriggerRandomAddressUpdate() { 85 // Call to StartAdvertisingSet set the last_alarm_cb to random address timeout 86 // callback. Call it now in order to trigger address update 87 last_alarm_cb(last_alarm_data); 88 } 89 90 constexpr uint8_t INTERMEDIATE = 91 0x00; // Intermediate fragment of fragmented data 92 constexpr uint8_t FIRST = 0x01; // First fragment of fragmented data 93 constexpr uint8_t LAST = 0x02; // Last fragment of fragmented data 94 constexpr uint8_t COMPLETE = 0x03; // Complete extended advertising data 95 96 class AdvertiserHciMock : public BleAdvertiserHciInterface { 97 public: 98 AdvertiserHciMock() = default; 99 ~AdvertiserHciMock() override = default; 100 101 MOCK_METHOD1(ReadInstanceCount, 102 void(base::Callback<void(uint8_t /* inst_cnt*/)>)); 103 MOCK_METHOD1(SetAdvertisingEventObserver, 104 void(AdvertisingEventObserver* observer)); 105 MOCK_METHOD6(SetAdvertisingData, 106 void(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t*, status_cb)); 107 MOCK_METHOD6(SetScanResponseData, 108 void(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t*, status_cb)); 109 MOCK_METHOD3(SetRandomAddress, void(uint8_t, const RawAddress&, status_cb)); 110 MOCK_METHOD3(Enable, void(uint8_t, std::vector<SetEnableData>, status_cb)); 111 MOCK_METHOD5(SetPeriodicAdvertisingParameters, 112 void(uint8_t, uint16_t, uint16_t, uint16_t, status_cb)); 113 MOCK_METHOD5(SetPeriodicAdvertisingData, 114 void(uint8_t, uint8_t, uint8_t, uint8_t*, status_cb)); 115 MOCK_METHOD3(SetPeriodicAdvertisingEnable, void(uint8_t, uint8_t, status_cb)); 116 MOCK_METHOD2(RemoveAdvertisingSet, void(uint8_t, status_cb)); 117 MOCK_METHOD1(ClearAdvertisingSets, void(status_cb)); 118 119 MOCK_METHOD9(SetParameters1, 120 void(uint8_t, uint16_t, uint32_t, uint32_t, uint8_t, uint8_t, 121 const RawAddress&, uint8_t, const RawAddress&)); 122 MOCK_METHOD8(SetParameters2, void(uint8_t, int8_t, uint8_t, uint8_t, uint8_t, 123 uint8_t, uint8_t, parameters_cb)); 124 125 void SetParameters(uint8_t handle, uint16_t properties, uint32_t adv_int_min, 126 uint32_t adv_int_max, uint8_t channel_map, 127 uint8_t own_address_type, const RawAddress& own_address, 128 uint8_t peer_address_type, const RawAddress& peer_address, 129 uint8_t filter_policy, int8_t tx_power, 130 uint8_t primary_phy, uint8_t secondary_max_skip, 131 uint8_t secondary_phy, uint8_t advertising_sid, 132 uint8_t scan_request_notify_enable, 133 parameters_cb cmd_complete) override { 134 SetParameters1(handle, properties, adv_int_min, adv_int_max, channel_map, 135 own_address_type, own_address, peer_address_type, 136 peer_address); 137 SetParameters2(filter_policy, tx_power, primary_phy, secondary_max_skip, 138 secondary_phy, advertising_sid, scan_request_notify_enable, 139 cmd_complete); 140 }; 141 142 bool QuirkAdvertiserZeroHandle() { return false; } 143 144 private: 145 DISALLOW_COPY_AND_ASSIGN(AdvertiserHciMock); 146 }; 147 148 } // namespace 149 150 class BleAdvertisingManagerTest : public testing::Test { 151 protected: 152 int reg_inst_id = -1; 153 int reg_status = -1; 154 int set_params_status = -1; 155 int set_data_status = -1; 156 int enable_status = -1; 157 int start_advertising_status = -1; 158 int start_advertising_set_advertiser_id = -1; 159 int start_advertising_set_tx_power = -1; 160 int start_advertising_set_status = -1; 161 162 std::unique_ptr<AdvertiserHciMock> hci_mock; 163 164 virtual void SetUp() { 165 hci_mock.reset(new AdvertiserHciMock()); 166 167 base::Callback<void(uint8_t)> inst_cnt_Cb; 168 EXPECT_CALL(*hci_mock, ReadInstanceCount(_)) 169 .Times(Exactly(1)) 170 .WillOnce(SaveArg<0>(&inst_cnt_Cb)); 171 172 BleAdvertisingManager::Initialize(hci_mock.get()); 173 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 174 175 // we are a truly gracious fake controller, let the command succeed! 176 inst_cnt_Cb.Run(num_adv_instances); 177 } 178 179 virtual void TearDown() { 180 BleAdvertisingManager::CleanUp(); 181 hci_mock.reset(); 182 } 183 184 public: 185 void RegistrationCb(uint8_t inst_id, uint8_t status) { 186 reg_inst_id = inst_id; 187 reg_status = status; 188 } 189 190 void SetParametersCb(uint8_t status, int8_t tx_power) { 191 set_params_status = status; 192 } 193 void SetDataCb(uint8_t status) { set_data_status = status; } 194 void EnableCb(uint8_t status) { enable_status = status; } 195 void StartAdvertisingCb(uint8_t status) { start_advertising_status = status; } 196 void StartAdvertisingSetCb(uint8_t advertiser_id, int8_t tx_power, 197 uint8_t status) { 198 start_advertising_set_advertiser_id = advertiser_id; 199 start_advertising_set_tx_power = tx_power; 200 start_advertising_set_status = status; 201 } 202 }; 203 204 TEST_F(BleAdvertisingManagerTest, test_registration) { 205 for (int i = 0; i < num_adv_instances; i++) { 206 BleAdvertisingManager::Get()->RegisterAdvertiser(Bind( 207 &BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 208 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 209 EXPECT_EQ(i, reg_inst_id); 210 } 211 212 // This call should return an error - no more advertisers left. 213 BleAdvertisingManager::Get()->RegisterAdvertiser( 214 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 215 EXPECT_EQ(ADVERTISE_FAILED_TOO_MANY_ADVERTISERS, reg_status); 216 // Don't bother checking inst_id, it doesn't matter 217 218 status_cb remove_cb; 219 EXPECT_CALL(*hci_mock, RemoveAdvertisingSet(_, _)) 220 .Times(1) 221 .WillOnce(SaveArg<1>(&remove_cb)); 222 BleAdvertisingManager::Get()->Unregister(5); 223 remove_cb.Run(0); 224 225 // One advertiser was freed, so should be able to register one now 226 BleAdvertisingManager::Get()->RegisterAdvertiser( 227 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 228 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 229 EXPECT_EQ(5, reg_inst_id); 230 } 231 232 /* This test verifies that the following flow is working correctly: register, 233 * set parameters, set data, enable, ... (advertise) ..., unregister*/ 234 TEST_F(BleAdvertisingManagerTest, test_android_flow) { 235 BleAdvertisingManager::Get()->RegisterAdvertiser( 236 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 237 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 238 int advertiser_id = reg_inst_id; 239 240 parameters_cb set_params_cb; 241 tBTM_BLE_ADV_PARAMS params; 242 EXPECT_CALL(*hci_mock, SetParameters1(advertiser_id, _, _, _, _, _, _, _, _)) 243 .Times(1); 244 EXPECT_CALL(*hci_mock, SetParameters2(_, _, _, _, _, _, _, _)) 245 .Times(1) 246 .WillOnce(SaveArg<7>(&set_params_cb)); 247 BleAdvertisingManager::Get()->SetParameters( 248 advertiser_id, ¶ms, 249 Bind(&BleAdvertisingManagerTest::SetParametersCb, 250 base::Unretained(this))); 251 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 252 253 // we are a truly gracious fake controller, let the command succeed! 254 set_params_cb.Run(0, 0); 255 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_params_status); 256 257 status_cb set_data_cb; 258 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, _, _, _, _, _)) 259 .Times(1) 260 .WillOnce(SaveArg<5>(&set_data_cb)); 261 BleAdvertisingManager::Get()->SetData( 262 advertiser_id, false, std::vector<uint8_t>(), 263 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 264 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 265 266 set_data_cb.Run(0); 267 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 268 269 status_cb enable_cb; 270 EXPECT_CALL(*hci_mock, 271 Enable(0x01 /* enable */, 272 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 273 advertiser_id))), 274 _)) 275 .Times(1) 276 .WillOnce(SaveArg<2>(&enable_cb)); 277 BleAdvertisingManager::Get()->Enable( 278 advertiser_id, true, 279 Bind(&BleAdvertisingManagerTest::EnableCb, base::Unretained(this)), 0, 0, 280 base::Callback<void(uint8_t)>()); 281 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 282 283 enable_cb.Run(0); 284 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, enable_status); 285 286 /* fake controller should be advertising */ 287 288 EXPECT_CALL(*hci_mock, 289 Enable(0x00 /* disable */, 290 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 291 advertiser_id))), 292 _)) 293 .Times(1) 294 .WillOnce(SaveArg<2>(&enable_cb)); 295 status_cb remove_cb; 296 EXPECT_CALL(*hci_mock, RemoveAdvertisingSet(_, _)) 297 .Times(1) 298 .WillOnce(SaveArg<1>(&remove_cb)); 299 BleAdvertisingManager::Get()->Unregister(advertiser_id); 300 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 301 302 enable_cb.Run(0); 303 remove_cb.Run(0); 304 } 305 306 /* This test verifies that when advertising data is set, tx power and flags will 307 * be properly filled. */ 308 TEST_F(BleAdvertisingManagerTest, test_adv_data_filling) { 309 BleAdvertisingManager::Get()->RegisterAdvertiser( 310 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 311 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 312 int advertiser_id = reg_inst_id; 313 314 parameters_cb set_params_cb; 315 tBTM_BLE_ADV_PARAMS params; 316 params.advertising_event_properties = 317 BleAdvertisingManager::advertising_prop_legacy_connectable; 318 params.tx_power = -15; 319 EXPECT_CALL(*hci_mock, SetParameters1(advertiser_id, _, _, _, _, _, _, _, _)) 320 .Times(1); 321 EXPECT_CALL(*hci_mock, SetParameters2(_, params.tx_power, _, _, _, _, _, _)) 322 .Times(1) 323 .WillOnce(SaveArg<7>(&set_params_cb)); 324 BleAdvertisingManager::Get()->SetParameters( 325 advertiser_id, ¶ms, 326 Bind(&BleAdvertisingManagerTest::SetParametersCb, 327 base::Unretained(this))); 328 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 329 330 // let the set parameters command succeed! 331 set_params_cb.Run(0, 0); 332 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_params_status); 333 334 status_cb set_data_cb; 335 /* verify that flags will be added, and tx power filled, if call to SetData 336 * contained only tx power, and the advertisement is connectable */ 337 uint8_t expected_adv_data[] = { 338 0x02 /* len */, 0x01 /* flags */, 339 0x02 /* flags value */, 0x02 /* len */, 340 0x0A /* tx_power */, static_cast<uint8_t>(params.tx_power)}; 341 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, _, _, _, _, _)) 342 .With(Args<4, 3>(ElementsAreArray(expected_adv_data))) 343 .Times(1) 344 .WillOnce(SaveArg<5>(&set_data_cb)); 345 BleAdvertisingManager::Get()->SetData( 346 advertiser_id, false, 347 std::vector<uint8_t>({0x02 /* len */, 0x0A /* tx_power */, 0x00}), 348 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 349 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 350 351 set_data_cb.Run(0); 352 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 353 } 354 355 /* This test verifies that when advertising is non-connectable, flags will not 356 * be added. */ 357 TEST_F(BleAdvertisingManagerTest, test_adv_data_not_filling) { 358 BleAdvertisingManager::Get()->RegisterAdvertiser( 359 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 360 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 361 int advertiser_id = reg_inst_id; 362 363 parameters_cb set_params_cb; 364 tBTM_BLE_ADV_PARAMS params; 365 params.advertising_event_properties = 366 BleAdvertisingManager::advertising_prop_legacy_non_connectable; 367 params.tx_power = -15; 368 EXPECT_CALL(*hci_mock, SetParameters1(advertiser_id, _, _, _, _, _, _, _, _)) 369 .Times(1); 370 EXPECT_CALL(*hci_mock, 371 SetParameters2(_, (uint8_t)params.tx_power, _, _, _, _, _, _)) 372 .Times(1) 373 .WillOnce(SaveArg<7>(&set_params_cb)); 374 BleAdvertisingManager::Get()->SetParameters( 375 advertiser_id, ¶ms, 376 Bind(&BleAdvertisingManagerTest::SetParametersCb, 377 base::Unretained(this))); 378 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 379 380 // let the set parameters command succeed! 381 set_params_cb.Run(0, -15); 382 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_params_status); 383 384 status_cb set_data_cb; 385 /* verify that flags will not be added */ 386 uint8_t expected_adv_data[] = { 387 0x02 /* len */, 0xFF /* manufacturer specific */, 0x01 /* data */}; 388 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, _, _, _, _, _)) 389 .With(Args<4, 3>(ElementsAreArray(expected_adv_data))) 390 .Times(1) 391 .WillOnce(SaveArg<5>(&set_data_cb)); 392 BleAdvertisingManager::Get()->SetData( 393 advertiser_id, false, std::vector<uint8_t>({0x02 /* len */, 0xFF, 0x01}), 394 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 395 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 396 397 set_data_cb.Run(0); 398 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 399 } 400 401 TEST_F(BleAdvertisingManagerTest, test_reenabling) { 402 BleAdvertisingManager::Get()->RegisterAdvertiser( 403 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 404 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 405 EXPECT_EQ(0, reg_inst_id); 406 407 uint8_t advertiser_id = reg_inst_id; 408 status_cb enable_cb; 409 EXPECT_CALL(*hci_mock, 410 Enable(0x01 /* enable */, 411 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 412 advertiser_id))), 413 _)) 414 .Times(1) 415 .WillOnce(SaveArg<2>(&enable_cb)); 416 BleAdvertisingManager::Get()->Enable(advertiser_id, true, Bind(DoNothing), 0, 417 0, Bind(DoNothing)); 418 enable_cb.Run(0); 419 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 420 421 EXPECT_CALL(*hci_mock, 422 Enable(0x01 /* enable */, 423 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 424 advertiser_id))), 425 _)) 426 .Times(1) 427 .WillOnce(SaveArg<2>(&enable_cb)); 428 BleAdvertisingManager::Get()->OnAdvertisingSetTerminated(advertiser_id, 0x00, 429 0x01ed, 0x00); 430 enable_cb.Run(0); 431 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 432 } 433 434 /* Make sure that instance is not reenabled if it's already disabled */ 435 TEST_F(BleAdvertisingManagerTest, test_reenabling_disabled_instance) { 436 uint8_t advertiser_id = 1; // any unregistered value 437 438 EXPECT_CALL(*hci_mock, Enable(_, _, _)).Times(Exactly(0)); 439 BleAdvertisingManager::Get()->OnAdvertisingSetTerminated(advertiser_id, 0x00, 440 0x05, 0x00); 441 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 442 } 443 444 /* This test verifies that the only flow that is currently used on Android, is 445 * working correctly in happy case scenario. */ 446 TEST_F(BleAdvertisingManagerTest, test_start_advertising_set) { 447 std::vector<uint8_t> adv_data; 448 std::vector<uint8_t> scan_resp; 449 tBTM_BLE_ADV_PARAMS params; 450 tBLE_PERIODIC_ADV_PARAMS periodic_params; 451 periodic_params.enable = false; 452 std::vector<uint8_t> periodic_data; 453 454 parameters_cb set_params_cb; 455 status_cb set_address_cb; 456 status_cb set_data_cb; 457 status_cb set_scan_resp_data_cb; 458 status_cb enable_cb; 459 EXPECT_CALL(*hci_mock, SetParameters1(_, _, _, _, _, _, _, _, _)).Times(1); 460 EXPECT_CALL(*hci_mock, SetParameters2(_, _, _, _, _, _, _, _)) 461 .Times(1) 462 .WillOnce(SaveArg<7>(&set_params_cb)); 463 EXPECT_CALL(*hci_mock, SetRandomAddress(_, _, _)) 464 .Times(1) 465 .WillOnce(SaveArg<2>(&set_address_cb)); 466 EXPECT_CALL(*hci_mock, SetAdvertisingData(_, _, _, _, _, _)) 467 .Times(1) 468 .WillOnce(SaveArg<5>(&set_data_cb)); 469 EXPECT_CALL(*hci_mock, SetScanResponseData(_, _, _, _, _, _)) 470 .Times(1) 471 .WillOnce(SaveArg<5>(&set_scan_resp_data_cb)); 472 EXPECT_CALL(*hci_mock, Enable(0x01 /* enable */, _, _)) 473 .Times(1) 474 .WillOnce(SaveArg<2>(&enable_cb)); 475 476 BleAdvertisingManager::Get()->StartAdvertisingSet( 477 Bind(&BleAdvertisingManagerTest::StartAdvertisingSetCb, 478 base::Unretained(this)), 479 ¶ms, adv_data, scan_resp, &periodic_params, periodic_data, 480 0 /* duration */, 0 /* maxExtAdvEvents */, Bind(DoNothing2)); 481 482 // we are a truly gracious fake controller, let the commands succeed! 483 int selected_tx_power = -15; 484 set_params_cb.Run(0, selected_tx_power); 485 set_address_cb.Run(0); 486 set_data_cb.Run(0); 487 set_scan_resp_data_cb.Run(0); 488 enable_cb.Run(0); 489 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, start_advertising_set_status); 490 EXPECT_EQ(selected_tx_power, start_advertising_set_tx_power); 491 int advertiser_id = start_advertising_set_advertiser_id; 492 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 493 494 // ... advertising ... 495 496 // Disable advertiser 497 status_cb disable_cb; 498 EXPECT_CALL(*hci_mock, 499 Enable(0x00 /* disable */, 500 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 501 advertiser_id))), 502 _)) 503 .Times(1) 504 .WillOnce(SaveArg<2>(&disable_cb)); 505 status_cb remove_cb; 506 EXPECT_CALL(*hci_mock, RemoveAdvertisingSet(advertiser_id, _)) 507 .Times(1) 508 .WillOnce(SaveArg<1>(&remove_cb)); 509 BleAdvertisingManager::Get()->Unregister(advertiser_id); 510 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 511 512 disable_cb.Run(0); 513 remove_cb.Run(0); 514 } 515 516 TEST_F(BleAdvertisingManagerTest, test_start_advertising_set_params_failed) { 517 BleAdvertisingManager::Get()->RegisterAdvertiser( 518 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 519 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 520 int advertiser_id = reg_inst_id; 521 522 std::vector<uint8_t> adv_data; 523 std::vector<uint8_t> scan_resp; 524 tBTM_BLE_ADV_PARAMS params; 525 526 parameters_cb set_params_cb; 527 EXPECT_CALL(*hci_mock, SetParameters1(advertiser_id, _, _, _, _, _, _, _, _)) 528 .Times(1); 529 EXPECT_CALL(*hci_mock, SetParameters2(_, _, _, _, _, _, _, _)) 530 .Times(1) 531 .WillOnce(SaveArg<7>(&set_params_cb)); 532 533 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, _, _, _, _, _)) 534 .Times(Exactly(0)); 535 536 BleAdvertisingManager::Get()->StartAdvertising( 537 advertiser_id, 538 Bind(&BleAdvertisingManagerTest::StartAdvertisingCb, 539 base::Unretained(this)), 540 ¶ms, adv_data, scan_resp, 0, base::Callback<void(uint8_t)>()); 541 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 542 543 // set params failed 544 set_params_cb.Run(0x01, 0); 545 546 // Expect the whole flow to fail right away 547 EXPECT_EQ(BTM_BLE_MULTI_ADV_FAILURE, start_advertising_status); 548 } 549 550 TEST_F(BleAdvertisingManagerTest, test_data_sender) { 551 // prepare test input vector 552 const int max_data_size = 1650; 553 std::vector<uint8_t> data(max_data_size); 554 for (int i = 0; i < max_data_size; i++) data[i] = i; 555 556 BleAdvertisingManager::Get()->RegisterAdvertiser( 557 Bind(&BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 558 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 559 int advertiser_id = reg_inst_id; 560 561 status_cb set_data_cb; 562 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, FIRST, _, 251, _, _)) 563 .Times(1) 564 .WillOnce(SaveArg<5>(&set_data_cb)); 565 EXPECT_CALL(*hci_mock, 566 SetAdvertisingData(advertiser_id, INTERMEDIATE, _, 251, _, _)) 567 .Times(5) 568 .WillRepeatedly(SaveArg<5>(&set_data_cb)); 569 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, LAST, _, 144, _, _)) 570 .Times(1) 571 .WillOnce(SaveArg<5>(&set_data_cb)); 572 BleAdvertisingManager::Get()->SetData( 573 advertiser_id, false, data, 574 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 575 for (int i = 0; i < 7; i++) { 576 set_data_cb.Run(0x00); 577 } 578 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 579 // Expect the whole flow to succeed 580 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 581 582 // ***************** Try again with different data size ********************* 583 data.resize(503); 584 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, FIRST, _, 251, _, _)) 585 .Times(1) 586 .WillOnce(SaveArg<5>(&set_data_cb)); 587 EXPECT_CALL(*hci_mock, 588 SetAdvertisingData(advertiser_id, INTERMEDIATE, _, 251, _, _)) 589 .Times(1) 590 .WillRepeatedly(SaveArg<5>(&set_data_cb)); 591 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, LAST, _, 1, _, _)) 592 .Times(1) 593 .WillOnce(SaveArg<5>(&set_data_cb)); 594 BleAdvertisingManager::Get()->SetData( 595 advertiser_id, false, data, 596 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 597 for (int i = 0; i < 3; i++) { 598 set_data_cb.Run(0x00); 599 } 600 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 601 // Expect the whole flow to succeed 602 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 603 604 // ***************** Try again with different data size ********************* 605 data.resize(502); 606 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, FIRST, _, 251, _, _)) 607 .Times(1) 608 .WillOnce(SaveArg<5>(&set_data_cb)); 609 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, LAST, _, 251, _, _)) 610 .Times(1) 611 .WillOnce(SaveArg<5>(&set_data_cb)); 612 BleAdvertisingManager::Get()->SetData( 613 advertiser_id, false, data, 614 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 615 for (int i = 0; i < 2; i++) { 616 set_data_cb.Run(0x00); 617 } 618 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 619 // Expect the whole flow to succeed 620 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 621 622 // ***************** Try again with different data size ********************* 623 data.resize(501); 624 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, FIRST, _, 251, _, _)) 625 .Times(1) 626 .WillOnce(SaveArg<5>(&set_data_cb)); 627 EXPECT_CALL(*hci_mock, SetAdvertisingData(advertiser_id, LAST, _, 250, _, _)) 628 .Times(1) 629 .WillOnce(SaveArg<5>(&set_data_cb)); 630 BleAdvertisingManager::Get()->SetData( 631 advertiser_id, false, data, 632 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 633 for (int i = 0; i < 2; i++) { 634 set_data_cb.Run(0x00); 635 } 636 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 637 // Expect the whole flow to succeed 638 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 639 640 // ***************** Try again with different data size ********************* 641 data.resize(251); 642 EXPECT_CALL(*hci_mock, 643 SetAdvertisingData(advertiser_id, COMPLETE, _, 251, _, _)) 644 .Times(1) 645 .WillOnce(SaveArg<5>(&set_data_cb)); 646 BleAdvertisingManager::Get()->SetData( 647 advertiser_id, false, data, 648 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 649 set_data_cb.Run(0x00); 650 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 651 // Expect the whole flow to succeed 652 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 653 654 // ***************** Try again with different data size ********************* 655 data.resize(120); 656 EXPECT_CALL(*hci_mock, 657 SetAdvertisingData(advertiser_id, COMPLETE, _, 120, _, _)) 658 .Times(1) 659 .WillOnce(SaveArg<5>(&set_data_cb)); 660 BleAdvertisingManager::Get()->SetData( 661 advertiser_id, false, data, 662 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 663 set_data_cb.Run(0x00); 664 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 665 // Expect the whole flow to succeed 666 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 667 668 // ***************** Try again with different data size ********************* 669 data.resize(0); 670 EXPECT_CALL(*hci_mock, 671 SetAdvertisingData(advertiser_id, COMPLETE, _, 0, _, _)) 672 .Times(1) 673 .WillOnce(SaveArg<5>(&set_data_cb)); 674 BleAdvertisingManager::Get()->SetData( 675 advertiser_id, false, data, 676 Bind(&BleAdvertisingManagerTest::SetDataCb, base::Unretained(this))); 677 set_data_cb.Run(0x00); 678 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 679 // Expect the whole flow to succeed 680 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, set_data_status); 681 } 682 683 /* This test makes sure that conectable advertisment with timeout will get it's 684 * address updated once the timeout passes and one tries to enable it again.*/ 685 TEST_F(BleAdvertisingManagerTest, 686 test_connectable_address_update_during_timeout) { 687 std::vector<uint8_t> adv_data; 688 std::vector<uint8_t> scan_resp; 689 tBTM_BLE_ADV_PARAMS params; 690 params.advertising_event_properties = 0x1 /* connectable */; 691 tBLE_PERIODIC_ADV_PARAMS periodic_params; 692 periodic_params.enable = false; 693 std::vector<uint8_t> periodic_data; 694 695 uint8_t maxExtAdvEvents = 50; 696 697 parameters_cb set_params_cb; 698 status_cb set_address_cb; 699 status_cb set_data_cb; 700 status_cb set_scan_resp_data_cb; 701 status_cb enable_cb; 702 EXPECT_CALL(*hci_mock, SetParameters1(_, _, _, _, _, _, _, _, _)).Times(1); 703 EXPECT_CALL(*hci_mock, SetParameters2(_, _, _, _, _, _, _, _)) 704 .Times(1) 705 .WillOnce(SaveArg<7>(&set_params_cb)); 706 EXPECT_CALL(*hci_mock, SetRandomAddress(_, _, _)) 707 .Times(1) 708 .WillOnce(SaveArg<2>(&set_address_cb)); 709 EXPECT_CALL(*hci_mock, SetAdvertisingData(_, _, _, _, _, _)) 710 .Times(1) 711 .WillOnce(SaveArg<5>(&set_data_cb)); 712 EXPECT_CALL(*hci_mock, SetScanResponseData(_, _, _, _, _, _)) 713 .Times(1) 714 .WillOnce(SaveArg<5>(&set_scan_resp_data_cb)); 715 EXPECT_CALL( 716 *hci_mock, 717 Enable( 718 0x01 /* enable */, 719 AllOf(SizeIs(1), 720 Contains(Field(&SetEnableData::max_extended_advertising_events, 721 maxExtAdvEvents))), 722 _)) 723 .Times(1) 724 .WillOnce(SaveArg<2>(&enable_cb)); 725 726 BleAdvertisingManager::Get()->StartAdvertisingSet( 727 Bind(&BleAdvertisingManagerTest::StartAdvertisingSetCb, 728 base::Unretained(this)), 729 ¶ms, adv_data, scan_resp, &periodic_params, periodic_data, 730 0 /* duration */, maxExtAdvEvents, Bind(DoNothing2)); 731 732 // we are a truly gracious fake controller, let the commands succeed! 733 int selected_tx_power = -15; 734 set_params_cb.Run(0, selected_tx_power); 735 set_address_cb.Run(0); 736 set_data_cb.Run(0); 737 set_scan_resp_data_cb.Run(0); 738 enable_cb.Run(0); 739 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, start_advertising_set_status); 740 EXPECT_EQ(selected_tx_power, start_advertising_set_tx_power); 741 int advertiser_id = start_advertising_set_advertiser_id; 742 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 743 744 // ... advertising ... 745 746 // No HCI calls should be triggered, becuase there is a timeout on a 747 // connectable advertisement. 748 TriggerRandomAddressUpdate(); 749 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 750 751 // Set terminated because we advertised maxExtAdvEvents times! 752 BleAdvertisingManager::Get()->OnAdvertisingSetTerminated( 753 0x43 /*status */, advertiser_id, 0x00 /* conn_handle*/, maxExtAdvEvents); 754 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 755 756 // Try to Enable the advertiser. It should first update it's random address. 757 EXPECT_CALL(*hci_mock, SetRandomAddress(_, _, _)) 758 .Times(1) 759 .WillOnce(SaveArg<2>(&set_address_cb)); 760 EXPECT_CALL( 761 *hci_mock, 762 Enable( 763 0x01 /* enable */, 764 AllOf(SizeIs(1), 765 Contains(Field(&SetEnableData::max_extended_advertising_events, 766 maxExtAdvEvents))), 767 _)) 768 .Times(1) 769 .WillOnce(SaveArg<2>(&enable_cb)); 770 BleAdvertisingManager::Get()->Enable( 771 advertiser_id, true, 772 Bind(&BleAdvertisingManagerTest::EnableCb, base::Unretained(this)), 0, 773 maxExtAdvEvents, Bind(DoNothing)); 774 set_address_cb.Run(0); 775 enable_cb.Run(0); 776 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 777 778 // Disable advertiser 779 status_cb disable_cb; 780 EXPECT_CALL(*hci_mock, 781 Enable(0x00 /* disable */, 782 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 783 advertiser_id))), 784 _)) 785 .Times(1) 786 .WillOnce(SaveArg<2>(&disable_cb)); 787 status_cb remove_cb; 788 EXPECT_CALL(*hci_mock, RemoveAdvertisingSet(advertiser_id, _)) 789 .Times(1) 790 .WillOnce(SaveArg<1>(&remove_cb)); 791 BleAdvertisingManager::Get()->Unregister(advertiser_id); 792 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 793 794 disable_cb.Run(0); 795 remove_cb.Run(0); 796 } 797 798 /* This test makes sure that periodic advertising is stopped before 799 * unregistering the advertiser, if it was enabled. */ 800 TEST_F(BleAdvertisingManagerTest, test_periodic_adv_disable_on_unregister) { 801 std::vector<uint8_t> adv_data; 802 std::vector<uint8_t> scan_resp; 803 tBTM_BLE_ADV_PARAMS params; 804 params.advertising_event_properties = 0x1 /* connectable */; 805 tBLE_PERIODIC_ADV_PARAMS periodic_params; 806 periodic_params.enable = true; // enable periodic advertising 807 std::vector<uint8_t> periodic_data; 808 809 parameters_cb set_params_cb; 810 status_cb set_address_cb; 811 status_cb set_data_cb; 812 status_cb set_scan_resp_data_cb; 813 status_cb enable_cb; 814 status_cb set_periodic_params_cb; 815 status_cb set_periodic_data_cb; 816 status_cb set_periodic_enable_cb; 817 EXPECT_CALL(*hci_mock, SetParameters1(_, _, _, _, _, _, _, _, _)).Times(1); 818 EXPECT_CALL(*hci_mock, SetParameters2(_, _, _, _, _, _, _, _)) 819 .Times(1) 820 .WillOnce(SaveArg<7>(&set_params_cb)); 821 EXPECT_CALL(*hci_mock, SetRandomAddress(_, _, _)) 822 .Times(1) 823 .WillOnce(SaveArg<2>(&set_address_cb)); 824 EXPECT_CALL(*hci_mock, SetAdvertisingData(_, _, _, _, _, _)) 825 .Times(1) 826 .WillOnce(SaveArg<5>(&set_data_cb)); 827 EXPECT_CALL(*hci_mock, SetScanResponseData(_, _, _, _, _, _)) 828 .Times(1) 829 .WillOnce(SaveArg<5>(&set_scan_resp_data_cb)); 830 EXPECT_CALL(*hci_mock, SetPeriodicAdvertisingParameters(_, _, _, _, _)) 831 .Times(1) 832 .WillOnce(SaveArg<4>(&set_periodic_params_cb)); 833 EXPECT_CALL(*hci_mock, SetPeriodicAdvertisingData(_, _, _, _, _)) 834 .Times(1) 835 .WillOnce(SaveArg<4>(&set_periodic_data_cb)); 836 EXPECT_CALL(*hci_mock, SetPeriodicAdvertisingEnable(0x01 /* enable */, _, _)) 837 .Times(1) 838 .WillOnce(SaveArg<2>(&set_periodic_enable_cb)); 839 EXPECT_CALL(*hci_mock, Enable(0x01 /* enable */, _, _)) 840 .Times(1) 841 .WillOnce(SaveArg<2>(&enable_cb)); 842 843 BleAdvertisingManager::Get()->StartAdvertisingSet( 844 Bind(&BleAdvertisingManagerTest::StartAdvertisingSetCb, 845 base::Unretained(this)), 846 ¶ms, adv_data, scan_resp, &periodic_params, periodic_data, 847 0 /* duration */, 0 /* maxExtAdvEvents */, Bind(DoNothing2)); 848 849 // we are a truly gracious fake controller, let the commands succeed! 850 int selected_tx_power = -15; 851 set_params_cb.Run(0, selected_tx_power); 852 set_address_cb.Run(0); 853 set_data_cb.Run(0); 854 set_scan_resp_data_cb.Run(0); 855 set_periodic_params_cb.Run(0); 856 set_periodic_data_cb.Run(0); 857 set_periodic_enable_cb.Run(0); 858 enable_cb.Run(0); 859 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, start_advertising_set_status); 860 EXPECT_EQ(selected_tx_power, start_advertising_set_tx_power); 861 int advertiser_id = start_advertising_set_advertiser_id; 862 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 863 864 // ... advertising ... 865 866 // Unregister advertiser - should disable periodic advertising 867 status_cb disable_cb; 868 EXPECT_CALL(*hci_mock, 869 Enable(0x00 /* disable */, 870 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 871 advertiser_id))), 872 _)) 873 .Times(1) 874 .WillOnce(SaveArg<2>(&disable_cb)); 875 status_cb disable_periodic_cb; 876 EXPECT_CALL(*hci_mock, SetPeriodicAdvertisingEnable(0x00 /* disable */, 877 advertiser_id, _)) 878 .Times(1) 879 .WillOnce(SaveArg<2>(&disable_periodic_cb)); 880 status_cb remove_cb; 881 EXPECT_CALL(*hci_mock, RemoveAdvertisingSet(advertiser_id, _)) 882 .Times(1) 883 .WillOnce(SaveArg<1>(&remove_cb)); 884 BleAdvertisingManager::Get()->Unregister(advertiser_id); 885 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 886 887 disable_cb.Run(0); 888 disable_periodic_cb.Run(0); 889 remove_cb.Run(0); 890 } 891 892 TEST_F(BleAdvertisingManagerTest, test_suspend_resume) { 893 for (int i = 0; i < 10; i++) { 894 BleAdvertisingManager::Get()->RegisterAdvertiser(Bind( 895 &BleAdvertisingManagerTest::RegistrationCb, base::Unretained(this))); 896 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, reg_status); 897 EXPECT_EQ(i, reg_inst_id); 898 } 899 900 std::array<int, 3> enabled = {{1, 3, 9}}; 901 902 for (int advertiser_id : enabled) { 903 status_cb enable_cb; 904 EXPECT_CALL(*hci_mock, 905 Enable(0x01 /* enable */, 906 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 907 advertiser_id))), 908 _)) 909 .Times(1) 910 .WillOnce(SaveArg<2>(&enable_cb)); 911 BleAdvertisingManager::Get()->Enable( 912 advertiser_id, true, 913 Bind(&BleAdvertisingManagerTest::EnableCb, base::Unretained(this)), 0, 914 0, base::Callback<void(uint8_t)>()); 915 enable_cb.Run(0); 916 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 917 } 918 919 // we have some advertisers registered, three advertising. 920 921 // Call to Suspend() should disable all running advertisers 922 status_cb disable_cb; 923 EXPECT_CALL( 924 *hci_mock, 925 Enable(0x00 /* disable */, 926 AllOf(SizeIs(3), Contains(Field(&SetEnableData::handle, 1)), 927 Contains(Field(&SetEnableData::handle, 3)), 928 Contains(Field(&SetEnableData::handle, 9))), 929 _)) 930 .Times(1) 931 .WillOnce(SaveArg<2>(&disable_cb)); 932 933 BleAdvertisingManager::Get()->Suspend(); 934 935 disable_cb.Run(0); 936 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 937 938 // Call to Resume() should re-enable advertisers 939 status_cb enable_cb; 940 EXPECT_CALL( 941 *hci_mock, 942 Enable(0x01 /* enable */, 943 AllOf(SizeIs(3), Contains(Field(&SetEnableData::handle, 1)), 944 Contains(Field(&SetEnableData::handle, 3)), 945 Contains(Field(&SetEnableData::handle, 9))), 946 _)) 947 .Times(1) 948 .WillOnce(SaveArg<2>(&enable_cb)); 949 950 BleAdvertisingManager::Get()->Resume(); 951 952 enable_cb.Run(0); 953 954 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 955 } 956 957 /* This test makes sure that conectable advertisment with timeout will get it's 958 * duration and maxExtAdvEvents updated, when it's terminated due to incoming 959 * connection.*/ 960 TEST_F(BleAdvertisingManagerTest, test_duration_update_during_timeout) { 961 std::vector<uint8_t> adv_data; 962 std::vector<uint8_t> scan_resp; 963 tBTM_BLE_ADV_PARAMS params; 964 params.advertising_event_properties = 0x1 /* connectable */; 965 params.adv_int_min = params.adv_int_max = 0xA0 /* 100ms */; 966 tBLE_PERIODIC_ADV_PARAMS periodic_params; 967 periodic_params.enable = false; 968 std::vector<uint8_t> periodic_data; 969 970 uint8_t maxExtAdvEvents = 50; 971 uint16_t duration = 500 /* 5s */; 972 973 parameters_cb set_params_cb; 974 status_cb set_address_cb; 975 status_cb set_data_cb; 976 status_cb set_scan_resp_data_cb; 977 status_cb enable_cb; 978 EXPECT_CALL(*hci_mock, SetParameters1(_, _, _, _, _, _, _, _, _)).Times(1); 979 EXPECT_CALL(*hci_mock, SetParameters2(_, _, _, _, _, _, _, _)) 980 .Times(1) 981 .WillOnce(SaveArg<7>(&set_params_cb)); 982 EXPECT_CALL(*hci_mock, SetRandomAddress(_, _, _)) 983 .Times(1) 984 .WillOnce(SaveArg<2>(&set_address_cb)); 985 EXPECT_CALL(*hci_mock, SetAdvertisingData(_, _, _, _, _, _)) 986 .Times(1) 987 .WillOnce(SaveArg<5>(&set_data_cb)); 988 EXPECT_CALL(*hci_mock, SetScanResponseData(_, _, _, _, _, _)) 989 .Times(1) 990 .WillOnce(SaveArg<5>(&set_scan_resp_data_cb)); 991 EXPECT_CALL( 992 *hci_mock, 993 Enable(0x01 /* enable */, 994 AllOf(SizeIs(1), 995 Contains(AllOf( 996 Field(&SetEnableData::max_extended_advertising_events, 997 maxExtAdvEvents), 998 Field(&SetEnableData::duration, duration)))), 999 _)) 1000 .Times(1) 1001 .WillOnce(SaveArg<2>(&enable_cb)); 1002 1003 BleAdvertisingManager::Get()->StartAdvertisingSet( 1004 Bind(&BleAdvertisingManagerTest::StartAdvertisingSetCb, 1005 base::Unretained(this)), 1006 ¶ms, adv_data, scan_resp, &periodic_params, periodic_data, duration, 1007 maxExtAdvEvents, Bind(DoNothing2)); 1008 1009 // we are a truly gracious fake controller, let the commands succeed! 1010 int selected_tx_power = -15; 1011 set_params_cb.Run(0, selected_tx_power); 1012 set_address_cb.Run(0); 1013 set_data_cb.Run(0); 1014 set_scan_resp_data_cb.Run(0); 1015 enable_cb.Run(0); 1016 EXPECT_EQ(BTM_BLE_MULTI_ADV_SUCCESS, start_advertising_set_status); 1017 EXPECT_EQ(selected_tx_power, start_advertising_set_tx_power); 1018 int advertiser_id = start_advertising_set_advertiser_id; 1019 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 1020 1021 // ... advertising ... 1022 1023 sleep(1); 1024 1025 std::vector<SetEnableData> setEnableData; 1026 // Set terminated because we received connect request! Should trigger 1027 // re-enabling of the set 1028 EXPECT_CALL(*hci_mock, Enable(0x01 /* enable */, _, _)) 1029 .Times(1) 1030 .WillOnce(DoAll(SaveArg<1>(&setEnableData), SaveArg<2>(&enable_cb))); 1031 1032 BleAdvertisingManager::Get()->OnAdvertisingSetTerminated( 1033 0x00 /* Advertising successfully ended with a connection being created */, 1034 advertiser_id, 0x01fe /* conn_handle*/, 20 /* completed ExtAdvEvents */); 1035 enable_cb.Run(0); 1036 1037 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 1038 1039 uint16_t new_duration = setEnableData[0].duration; 1040 uint8_t new_extAdvEvents = setEnableData[0].max_extended_advertising_events; 1041 1042 // Sleep is not super-accurate, so assume the recomputed timeouts are around 1043 // 4s +/- 100ms 1044 EXPECT_NEAR((duration - new_duration), 100 /*4s */, 10); 1045 EXPECT_NEAR((maxExtAdvEvents - new_extAdvEvents), 10, 1); 1046 1047 // Disable advertiser 1048 status_cb disable_cb; 1049 EXPECT_CALL(*hci_mock, 1050 Enable(0x00 /* disable */, 1051 AllOf(SizeIs(1), Contains(Field(&SetEnableData::handle, 1052 advertiser_id))), 1053 _)) 1054 .Times(1) 1055 .WillOnce(SaveArg<2>(&disable_cb)); 1056 status_cb remove_cb; 1057 EXPECT_CALL(*hci_mock, RemoveAdvertisingSet(advertiser_id, _)) 1058 .Times(1) 1059 .WillOnce(SaveArg<1>(&remove_cb)); 1060 BleAdvertisingManager::Get()->Unregister(advertiser_id); 1061 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 1062 1063 disable_cb.Run(0); 1064 remove_cb.Run(0); 1065 } 1066 1067 /* This test verifies that stack cleanup, and shutdown happening while there is 1068 * outstanding HCI command is not triggering the callback */ 1069 TEST_F(BleAdvertisingManagerTest, test_cleanup_during_execution) { 1070 std::vector<uint8_t> adv_data; 1071 std::vector<uint8_t> scan_resp; 1072 tBTM_BLE_ADV_PARAMS params; 1073 tBLE_PERIODIC_ADV_PARAMS periodic_params; 1074 periodic_params.enable = false; 1075 std::vector<uint8_t> periodic_data; 1076 1077 parameters_cb set_params_cb; 1078 status_cb set_address_cb; 1079 status_cb set_data_cb; 1080 EXPECT_CALL(*hci_mock, SetParameters1(_, _, _, _, _, _, _, _, _)).Times(1); 1081 EXPECT_CALL(*hci_mock, SetParameters2(_, _, _, _, _, _, _, _)) 1082 .Times(1) 1083 .WillOnce(SaveArg<7>(&set_params_cb)); 1084 EXPECT_CALL(*hci_mock, SetRandomAddress(_, _, _)) 1085 .Times(1) 1086 .WillOnce(SaveArg<2>(&set_address_cb)); 1087 EXPECT_CALL(*hci_mock, SetAdvertisingData(_, _, _, _, _, _)) 1088 .Times(1) 1089 .WillOnce(SaveArg<5>(&set_data_cb)); 1090 1091 BleAdvertisingManager::Get()->StartAdvertisingSet( 1092 Bind(&BleAdvertisingManagerTest::StartAdvertisingSetCb, 1093 base::Unretained(this)), 1094 ¶ms, adv_data, scan_resp, &periodic_params, periodic_data, 1095 0 /* duration */, 0 /* maxExtAdvEvents */, Bind(DoNothing2)); 1096 1097 // we are a truly gracious fake controller, let the commands succeed! 1098 int selected_tx_power = -15; 1099 set_params_cb.Run(0, selected_tx_power); 1100 set_address_cb.Run(0); 1101 1102 // Someone shut down the stack in the middle of flow, when the HCI Set 1103 // Advertise Data was scheduled! 1104 BleAdvertisingManager::Get()->CleanUp(); 1105 1106 // The HCI call returns with status, and tries to execute the callback. This 1107 // should just silently drop the call. If it got executed, we would get crash, 1108 // because BleAdvertisingManager object was already deleted. 1109 set_data_cb.Run(0); 1110 1111 ::testing::Mock::VerifyAndClearExpectations(hci_mock.get()); 1112 } 1113 1114 extern void testRecomputeTimeout1(); 1115 extern void testRecomputeTimeout2(); 1116 extern void testRecomputeTimeout3(); 1117 1118 TEST_F(BleAdvertisingManagerTest, test_recompute_timeout) { 1119 testRecomputeTimeout1(); 1120 testRecomputeTimeout2(); 1121 testRecomputeTimeout3(); 1122 }
