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