1 //
2 // Copyright 2016 Google, Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at:
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "service/adapter.h"
21 #include "service/hal/fake_bluetooth_gatt_interface.h"
22 #include "service/low_energy_advertiser.h"
23 #include "stack/include/bt_types.h"
24 #include "stack/include/hcidefs.h"
25 #include "test/mock_adapter.h"
26
27 using ::testing::_;
28 using ::testing::DoAll;
29 using ::testing::Exactly;
30 using ::testing::Invoke;
31 using ::testing::Pointee;
32 using ::testing::Return;
33 using ::testing::SaveArg;
34 using ::testing::Matcher;
35 using status_cb = base::Callback<void(uint8_t)>;
36 using reg_cb =
37 base::Callback<void(uint8_t /* advertiser_id */, uint8_t /* status */)>;
38
39 namespace bluetooth {
40 namespace {
41
42 class MockAdvertiserHandler : public BleAdvertiserInterface {
43 public:
MockAdvertiserHandler()44 MockAdvertiserHandler() {}
45 MockAdvertiserHandler(const MockAdvertiserHandler&) = delete;
46 MockAdvertiserHandler& operator=(const MockAdvertiserHandler&) = delete;
47
48 ~MockAdvertiserHandler() override = default;
49
50 MOCK_METHOD1(RegisterAdvertiser, void(IdStatusCallback));
51 MOCK_METHOD1(Unregister, void(uint8_t));
52 MOCK_METHOD2(GetOwnAddress, void(uint8_t, GetAddressCallback));
53 MOCK_METHOD3(SetParameters,
54 void(uint8_t, AdvertiseParameters, ParametersCallback));
55 MOCK_METHOD4(SetData, void(int, bool, std::vector<uint8_t>, StatusCallback));
56 MOCK_METHOD6(Enable, void(uint8_t, bool, StatusCallback, uint16_t, uint8_t,
57 StatusCallback));
58 MOCK_METHOD7(StartAdvertising,
59 void(uint8_t advertiser_id, StatusCallback cb,
60 AdvertiseParameters, std::vector<uint8_t>,
61 std::vector<uint8_t>, int, StatusCallback));
62 MOCK_METHOD10(StartAdvertisingSet,
63 void(int reg_id, IdTxPowerStatusCallback cb,
64 AdvertiseParameters params,
65 std::vector<uint8_t> advertise_data,
66 std::vector<uint8_t> scan_response_data,
67 PeriodicAdvertisingParameters periodic_params,
68 std::vector<uint8_t> periodic_data, uint16_t duration,
69 uint8_t maxExtAdvEvents, IdStatusCallback timeout_cb));
70 MOCK_METHOD3(SetPeriodicAdvertisingParameters,
71 void(int, PeriodicAdvertisingParameters, StatusCallback));
72 MOCK_METHOD3(SetPeriodicAdvertisingData,
73 void(int, std::vector<uint8_t>, StatusCallback));
74 MOCK_METHOD3(SetPeriodicAdvertisingEnable, void(int, bool, StatusCallback));
75 MOCK_METHOD1(RegisterCallbacks, void(AdvertisingCallbacks* callbacks));
76 };
77
78 class LowEnergyAdvertiserTest : public ::testing::Test {
79 public:
80 LowEnergyAdvertiserTest() = default;
81 LowEnergyAdvertiserTest(const LowEnergyAdvertiserTest&) = delete;
82 LowEnergyAdvertiserTest& operator=(const LowEnergyAdvertiserTest&) = delete;
83
84 ~LowEnergyAdvertiserTest() override = default;
85
SetUp()86 void SetUp() override {
87 // Only set |mock_handler_| if a test hasn't set it.
88 if (!mock_handler_) mock_handler_.reset(new MockAdvertiserHandler());
89 hal::BluetoothGattInterface::InitializeForTesting(
90 new hal::FakeBluetoothGattInterface(
91 std::static_pointer_cast<BleAdvertiserInterface>(mock_handler_),
92 nullptr, nullptr, nullptr));
93 ble_advertiser_factory_.reset(new LowEnergyAdvertiserFactory());
94 }
95
TearDown()96 void TearDown() override {
97 ble_advertiser_factory_.reset();
98 hal::BluetoothGattInterface::CleanUp();
99 }
100
101 protected:
102 std::shared_ptr<MockAdvertiserHandler> mock_handler_;
103 std::unique_ptr<LowEnergyAdvertiserFactory> ble_advertiser_factory_;
104 };
105
106 // Used for tests that operate on a pre-registered advertiser.
107 class LowEnergyAdvertiserPostRegisterTest : public LowEnergyAdvertiserTest {
108 public:
LowEnergyAdvertiserPostRegisterTest()109 LowEnergyAdvertiserPostRegisterTest() : next_client_id_(0) {}
110 LowEnergyAdvertiserPostRegisterTest(
111 const LowEnergyAdvertiserPostRegisterTest&) = delete;
112 LowEnergyAdvertiserPostRegisterTest& operator=(
113 const LowEnergyAdvertiserPostRegisterTest&) = delete;
114
115 ~LowEnergyAdvertiserPostRegisterTest() override = default;
116
SetUp()117 void SetUp() override {
118 LowEnergyAdvertiserTest::SetUp();
119 auto callback = [&](std::unique_ptr<LowEnergyAdvertiser> advertiser) {
120 le_advertiser_ = std::move(advertiser);
121 };
122 RegisterTestAdvertiser(callback);
123 }
124
TearDown()125 void TearDown() override {
126 EXPECT_CALL(*mock_handler_, Enable(_, false, _, _, _, _)).Times(1);
127 EXPECT_CALL(*mock_handler_, Unregister(_)).Times(1);
128 le_advertiser_.reset();
129 LowEnergyAdvertiserTest::TearDown();
130 }
131
RegisterTestAdvertiser(const std::function<void (std::unique_ptr<LowEnergyAdvertiser> advertiser)> callback)132 void RegisterTestAdvertiser(
133 const std::function<void(std::unique_ptr<LowEnergyAdvertiser> advertiser)>
134 callback) {
135 Uuid uuid = Uuid::GetRandom();
136 auto api_callback = [&](BLEStatus status, const Uuid& in_uuid,
137 std::unique_ptr<BluetoothInstance> in_client) {
138 CHECK(in_uuid == uuid);
139 CHECK(in_client.get());
140 CHECK(status == BLE_STATUS_SUCCESS);
141
142 callback(std::unique_ptr<LowEnergyAdvertiser>(
143 static_cast<LowEnergyAdvertiser*>(in_client.release())));
144 };
145
146 reg_cb reg_adv_cb;
147 EXPECT_CALL(*mock_handler_, RegisterAdvertiser(_))
148 .Times(1)
149 .WillOnce(SaveArg<0>(®_adv_cb));
150
151 ble_advertiser_factory_->RegisterInstance(uuid, api_callback);
152
153 reg_adv_cb.Run(next_client_id_++, BT_STATUS_SUCCESS);
154 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
155 }
156
StartAdvertising()157 void StartAdvertising() {
158 ASSERT_FALSE(le_advertiser_->IsAdvertisingStarted());
159 ASSERT_FALSE(le_advertiser_->IsStartingAdvertising());
160 ASSERT_FALSE(le_advertiser_->IsStoppingAdvertising());
161
162 status_cb start_advertising_cb;
163 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
164 .Times(1)
165 .WillOnce(SaveArg<1>(&start_advertising_cb));
166 status_cb set_data_cb;
167
168 AdvertiseSettings settings;
169 AdvertiseData adv, scan_rsp;
170 ASSERT_TRUE(le_advertiser_->StartAdvertising(
171 settings, adv, scan_rsp, LowEnergyAdvertiser::StatusCallback()));
172 ASSERT_TRUE(le_advertiser_->IsStartingAdvertising());
173
174 start_advertising_cb.Run(BT_STATUS_SUCCESS);
175
176 ASSERT_TRUE(le_advertiser_->IsAdvertisingStarted());
177 ASSERT_FALSE(le_advertiser_->IsStartingAdvertising());
178 ASSERT_FALSE(le_advertiser_->IsStoppingAdvertising());
179 }
180
AdvertiseDataTestHelper(AdvertiseData data,std::function<void (BLEStatus)> callback,status_cb * set_data_cb)181 void AdvertiseDataTestHelper(AdvertiseData data,
182 std::function<void(BLEStatus)> callback,
183 status_cb* set_data_cb) {
184 AdvertiseSettings settings;
185
186 LOG_ASSERT(set_data_cb) << "set_data_cb must be set";
187
188 EXPECT_TRUE(le_advertiser_->StartAdvertising(settings, data,
189 AdvertiseData(), callback));
190
191 set_data_cb->Run(BT_STATUS_SUCCESS);
192
193 status_cb disable_cb;
194 EXPECT_CALL(*mock_handler_, Enable(_, false, _, _, _, _))
195 .Times(1)
196 .WillOnce(SaveArg<2>(&disable_cb));
197
198 EXPECT_TRUE(
199 le_advertiser_->StopAdvertising(LowEnergyAdvertiser::StatusCallback()));
200 disable_cb.Run(BT_STATUS_SUCCESS);
201 }
202
203 protected:
204 std::unique_ptr<LowEnergyAdvertiser> le_advertiser_;
205
206 private:
207 int next_client_id_;
208 };
209
TEST_F(LowEnergyAdvertiserTest,RegisterInstance)210 TEST_F(LowEnergyAdvertiserTest, RegisterInstance) {
211 // These will be asynchronously populated with a result when the callback
212 // executes.
213 BLEStatus status = BLE_STATUS_SUCCESS;
214 Uuid cb_uuid;
215 std::unique_ptr<LowEnergyAdvertiser> advertiser;
216 int callback_count = 0;
217
218 auto callback = [&](BLEStatus in_status, const Uuid& uuid,
219 std::unique_ptr<BluetoothInstance> in_client) {
220 status = in_status;
221 cb_uuid = uuid;
222 advertiser = std::unique_ptr<LowEnergyAdvertiser>(
223 static_cast<LowEnergyAdvertiser*>(in_client.release()));
224 callback_count++;
225 };
226
227 Uuid uuid0 = Uuid::GetRandom();
228
229 reg_cb reg_adv1_cb;
230 EXPECT_CALL(*mock_handler_, RegisterAdvertiser(_))
231 .Times(1)
232 .WillOnce(SaveArg<0>(®_adv1_cb));
233
234 // Success.
235 EXPECT_TRUE(ble_advertiser_factory_->RegisterInstance(uuid0, callback));
236 EXPECT_EQ(0, callback_count);
237
238 // Calling twice with the same Uuid should fail with no additional call into
239 // the stack.
240 EXPECT_FALSE(ble_advertiser_factory_->RegisterInstance(uuid0, callback));
241
242 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
243
244 // Call with a different Uuid while one is pending.
245 Uuid uuid1 = Uuid::GetRandom();
246 reg_cb reg_adv2_cb;
247 EXPECT_CALL(*mock_handler_, RegisterAdvertiser(_))
248 .Times(1)
249 .WillOnce(SaveArg<0>(®_adv2_cb));
250 EXPECT_TRUE(ble_advertiser_factory_->RegisterInstance(uuid1, callback));
251
252 // |uuid0| succeeds.
253 int client_if0 = 2; // Pick something that's not 0.
254 reg_adv1_cb.Run(client_if0, BT_STATUS_SUCCESS);
255
256 EXPECT_EQ(1, callback_count);
257 ASSERT_TRUE(advertiser.get() !=
258 nullptr); // Assert to terminate in case of error
259 EXPECT_EQ(BLE_STATUS_SUCCESS, status);
260 EXPECT_EQ(client_if0, advertiser->GetInstanceId());
261 EXPECT_EQ(uuid0, advertiser->GetAppIdentifier());
262 EXPECT_EQ(uuid0, cb_uuid);
263
264 // The advertiser should unregister itself when deleted.
265 EXPECT_CALL(*mock_handler_, Enable(client_if0, false, _, _, _, _)).Times(1);
266 EXPECT_CALL(*mock_handler_, Unregister(client_if0)).Times(1);
267 advertiser.reset();
268 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
269
270 // |uuid1| fails.
271 uint8_t client_if1 = 10;
272 reg_adv2_cb.Run(client_if1, BT_STATUS_FAIL);
273
274 EXPECT_EQ(2, callback_count);
275 ASSERT_TRUE(advertiser.get() ==
276 nullptr); // Assert to terminate in case of error
277 EXPECT_EQ(BLE_STATUS_FAILURE, status);
278 EXPECT_EQ(uuid1, cb_uuid);
279 }
280
TEST_F(LowEnergyAdvertiserPostRegisterTest,StartAdvertisingBasic)281 TEST_F(LowEnergyAdvertiserPostRegisterTest, StartAdvertisingBasic) {
282 EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());
283 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
284 EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());
285
286 // Use default advertising settings and data.
287 AdvertiseSettings settings;
288 AdvertiseData adv_data, scan_rsp;
289 int callback_count = 0;
290 BLEStatus last_status = BLE_STATUS_FAILURE;
291 auto callback = [&](BLEStatus status) {
292 last_status = status;
293 callback_count++;
294 };
295
296 status_cb start_advertising_cb;
297 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
298 .Times(2)
299 .WillRepeatedly(SaveArg<1>(&start_advertising_cb));
300
301 // Stack call returns success.
302 EXPECT_TRUE(
303 le_advertiser_->StartAdvertising(settings, adv_data, scan_rsp, callback));
304
305 EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());
306 EXPECT_TRUE(le_advertiser_->IsStartingAdvertising());
307 EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());
308 EXPECT_EQ(0, callback_count);
309
310 // Already starting.
311 EXPECT_FALSE(
312 le_advertiser_->StartAdvertising(settings, adv_data, scan_rsp, callback));
313
314 // Notify failure.
315 start_advertising_cb.Run(BT_STATUS_FAIL);
316
317 EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());
318 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
319 EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());
320 EXPECT_EQ(1, callback_count);
321 EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
322
323 // Try again.
324 EXPECT_TRUE(
325 le_advertiser_->StartAdvertising(settings, adv_data, scan_rsp, callback));
326 EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());
327 EXPECT_TRUE(le_advertiser_->IsStartingAdvertising());
328 EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());
329 EXPECT_EQ(1, callback_count);
330
331 start_advertising_cb.Run(BT_STATUS_SUCCESS);
332
333 EXPECT_TRUE(le_advertiser_->IsAdvertisingStarted());
334 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
335 EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());
336 EXPECT_EQ(2, callback_count);
337 EXPECT_EQ(BLE_STATUS_SUCCESS, last_status);
338
339 // Already started.
340 EXPECT_FALSE(
341 le_advertiser_->StartAdvertising(settings, adv_data, scan_rsp, callback));
342 }
343
TEST_F(LowEnergyAdvertiserPostRegisterTest,StopAdvertisingBasic)344 TEST_F(LowEnergyAdvertiserPostRegisterTest, StopAdvertisingBasic) {
345 AdvertiseSettings settings;
346
347 // Not enabled.
348 EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());
349 EXPECT_FALSE(
350 le_advertiser_->StopAdvertising(LowEnergyAdvertiser::StatusCallback()));
351
352 // Start advertising for testing.
353 StartAdvertising();
354
355 int callback_count = 0;
356 BLEStatus last_status = BLE_STATUS_FAILURE;
357 auto callback = [&](BLEStatus status) {
358 last_status = status;
359 callback_count++;
360 };
361
362 status_cb enable_cb;
363 EXPECT_CALL(*mock_handler_, Enable(_, false, _, _, _, _))
364 .Times(2)
365 .WillRepeatedly(SaveArg<2>(&enable_cb));
366
367 // Stack returns success.
368 EXPECT_TRUE(le_advertiser_->StopAdvertising(callback));
369 EXPECT_TRUE(le_advertiser_->IsAdvertisingStarted());
370 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
371 EXPECT_TRUE(le_advertiser_->IsStoppingAdvertising());
372 EXPECT_EQ(0, callback_count);
373
374 // Already disabling.
375 EXPECT_FALSE(le_advertiser_->StopAdvertising(callback));
376 EXPECT_TRUE(le_advertiser_->IsAdvertisingStarted());
377 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
378 EXPECT_TRUE(le_advertiser_->IsStoppingAdvertising());
379 EXPECT_EQ(0, callback_count);
380
381 // Notify failure.
382 enable_cb.Run(BT_STATUS_FAIL);
383 EXPECT_TRUE(le_advertiser_->IsAdvertisingStarted());
384 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
385 EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());
386 EXPECT_EQ(1, callback_count);
387 EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
388
389 // Try again.
390 EXPECT_TRUE(le_advertiser_->StopAdvertising(callback));
391 EXPECT_TRUE(le_advertiser_->IsAdvertisingStarted());
392 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
393 EXPECT_TRUE(le_advertiser_->IsStoppingAdvertising());
394 EXPECT_EQ(1, callback_count);
395
396 // Notify success.
397 enable_cb.Run(BT_STATUS_SUCCESS);
398 EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());
399 EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
400 EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());
401 EXPECT_EQ(2, callback_count);
402 EXPECT_EQ(BLE_STATUS_SUCCESS, last_status);
403
404 // Already stopped.
405 EXPECT_FALSE(le_advertiser_->StopAdvertising(callback));
406 }
407
TEST_F(LowEnergyAdvertiserPostRegisterTest,InvalidAdvertiseData)408 TEST_F(LowEnergyAdvertiserPostRegisterTest, InvalidAdvertiseData) {
409 const std::vector<uint8_t> data0{0x02, HCI_EIR_FLAGS_TYPE, 0x00};
410 const std::vector<uint8_t> data1{0x04, HCI_EIR_MANUFACTURER_SPECIFIC_TYPE,
411 0x01, 0x02, 0x00};
412 AdvertiseData invalid_adv(data0);
413 AdvertiseData valid_adv(data1);
414
415 AdvertiseSettings settings;
416
417 EXPECT_FALSE(le_advertiser_->StartAdvertising(
418 settings, valid_adv, invalid_adv, LowEnergyAdvertiser::StatusCallback()));
419 EXPECT_FALSE(le_advertiser_->StartAdvertising(
420 settings, invalid_adv, valid_adv, LowEnergyAdvertiser::StatusCallback()));
421
422 // Manufacturer data not correctly formatted according to spec. We let the
423 // stack handle this case.
424 const std::vector<uint8_t> data2{0x01, HCI_EIR_MANUFACTURER_SPECIFIC_TYPE};
425 AdvertiseData invalid_mfc(data2);
426
427 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _)).Times(1);
428 EXPECT_TRUE(le_advertiser_->StartAdvertising(
429 settings, invalid_mfc, valid_adv, LowEnergyAdvertiser::StatusCallback()));
430 }
431
TEST_F(LowEnergyAdvertiserPostRegisterTest,AdvertiseDataParsing)432 TEST_F(LowEnergyAdvertiserPostRegisterTest, AdvertiseDataParsing) {
433 const std::vector<uint8_t> kUuid16BitData{
434 0x03, HCI_EIR_COMPLETE_16BITS_UUID_TYPE, 0xDE, 0xAD,
435 };
436
437 const std::vector<uint8_t> kUuid32BitData{
438 0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x02};
439
440 const std::vector<uint8_t> kUUID128BitData{
441 0x11, HCI_EIR_COMPLETE_128BITS_UUID_TYPE,
442 0xDE, 0xAD,
443 0x01, 0x02,
444 0x03, 0x04,
445 0x05, 0x06,
446 0x07, 0x08,
447 0x09, 0x0A,
448 0x0B, 0x0C,
449 0x0D, 0x0E};
450
451 const std::vector<uint8_t> kMultiUuidData{
452 0x11, HCI_EIR_COMPLETE_128BITS_UUID_TYPE,
453 0xDE, 0xAD,
454 0x01, 0x02,
455 0x03, 0x04,
456 0x05, 0x06,
457 0x07, 0x08,
458 0x09, 0x0A,
459 0x0B, 0x0C,
460 0x0D, 0x0E,
461 0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE,
462 0xDE, 0xAD,
463 0xBE, 0xEF};
464
465 const std::vector<uint8_t> kServiceData16Bit{
466 0x05, HCI_EIR_SERVICE_DATA_16BITS_UUID_TYPE, 0xDE, 0xAD, 0xBE, 0xEF};
467
468 const std::vector<uint8_t> kServiceData32Bit{
469 0x07, HCI_EIR_SERVICE_DATA_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x02, 0xBE,
470 0xEF};
471
472 const std::vector<uint8_t> kServiceData128Bit{
473 0x13, HCI_EIR_SERVICE_DATA_128BITS_UUID_TYPE,
474 0xDE, 0xAD,
475 0x01, 0x02,
476 0x03, 0x04,
477 0x05, 0x06,
478 0x07, 0x08,
479 0x09, 0x0A,
480 0x0B, 0x0C,
481 0x0D, 0x0E,
482 0xBE, 0xEF};
483
484 const std::vector<uint8_t> kMultiServiceData{
485 0x13, HCI_EIR_SERVICE_DATA_128BITS_UUID_TYPE,
486 0xDE, 0xAD,
487 0x01, 0x02,
488 0x03, 0x04,
489 0x05, 0x06,
490 0xBE, 0xEF,
491 0xDE, 0xAD,
492 0x01, 0x02,
493 0x03, 0x04,
494 0x05, 0x06,
495 0x05, HCI_EIR_SERVICE_DATA_16BITS_UUID_TYPE,
496 0xDE, 0xAD,
497 0xBE, 0xEF};
498
499 const std::vector<uint8_t> kServiceUuidMatch{
500 0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE,
501 0xDE, 0xAD,
502 0x01, 0x02,
503 0x07, HCI_EIR_SERVICE_DATA_32BITS_UUID_TYPE,
504 0xDE, 0xAD,
505 0x01, 0x02,
506 0xBE, 0xEF};
507
508 const std::vector<uint8_t> kServiceUuidMismatch{
509 0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE,
510 0xDE, 0xAD,
511 0x01, 0x01,
512 0x07, HCI_EIR_SERVICE_DATA_32BITS_UUID_TYPE,
513 0xDE, 0xAD,
514 0x01, 0x02,
515 0xBE, 0xEF};
516
517 AdvertiseData uuid_16bit_adv(kUuid16BitData);
518 AdvertiseData uuid_32bit_adv(kUuid32BitData);
519 AdvertiseData uuid_128bit_adv(kUUID128BitData);
520 AdvertiseData multi_uuid_adv(kMultiUuidData);
521
522 AdvertiseData service_16bit_adv(kServiceData16Bit);
523 AdvertiseData service_32bit_adv(kServiceData32Bit);
524 AdvertiseData service_128bit_adv(kServiceData128Bit);
525 AdvertiseData multi_service_adv(kMultiServiceData);
526
527 AdvertiseData service_uuid_match(kServiceUuidMatch);
528 AdvertiseData service_uuid_mismatch(kServiceUuidMismatch);
529
530 AdvertiseSettings settings;
531
532 int callback_count = 0;
533 BLEStatus last_status = BLE_STATUS_FAILURE;
534 auto callback = [&](BLEStatus status) {
535 last_status = status;
536 callback_count++;
537 };
538
539 status_cb start_advertising_cb;
540 // Multiple Uuid test
541 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
542 .Times(1)
543 .WillOnce(SaveArg<1>(&start_advertising_cb));
544 AdvertiseDataTestHelper(multi_uuid_adv, callback, &start_advertising_cb);
545 EXPECT_EQ(1, callback_count);
546 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
547
548 // Multiple Service Data test
549 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
550 .Times(1)
551 .WillOnce(SaveArg<1>(&start_advertising_cb));
552 AdvertiseDataTestHelper(multi_service_adv, callback, &start_advertising_cb);
553 EXPECT_EQ(2, callback_count);
554 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
555
556 // 16bit uuid test, should succeed with correctly parsed uuid in little-endian
557 // 128-bit format.
558 const std::vector<uint8_t> uuid_16bit_canonical{
559 0xFB, 0x34, 0x9b, 0x5F, 0x80, 0x00, 0x00, 0x80,
560 0x00, 0x10, 0x00, 0x00, 0xDE, 0xAD, 0x00, 0x00};
561 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
562 .Times(1)
563 .WillOnce(SaveArg<1>(&start_advertising_cb));
564 AdvertiseDataTestHelper(uuid_16bit_adv, callback, &start_advertising_cb);
565 EXPECT_EQ(3, callback_count);
566 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
567
568 // 32bit uuid test, should succeed with correctly parsed uuid
569 const std::vector<uint8_t> uuid_32bit_canonical{
570 0xFB, 0x34, 0x9b, 0x5F, 0x80, 0x00, 0x00, 0x80,
571 0x00, 0x10, 0x00, 0x00, 0xDE, 0xAD, 0x01, 0x02};
572 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
573 .Times(1)
574 .WillOnce(SaveArg<1>(&start_advertising_cb));
575 AdvertiseDataTestHelper(uuid_32bit_adv, callback, &start_advertising_cb);
576 EXPECT_EQ(4, callback_count);
577 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
578
579 // 128bit uuid test, should succeed with correctly parsed uuid
580 const std::vector<uint8_t> uuid_128bit{0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04,
581 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
582 0x0B, 0x0C, 0x0D, 0x0E};
583 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
584 .Times(1)
585 .WillOnce(SaveArg<1>(&start_advertising_cb));
586 AdvertiseDataTestHelper(uuid_128bit_adv, callback, &start_advertising_cb);
587 EXPECT_EQ(5, callback_count);
588 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
589
590 const std::vector<uint8_t> service_data{0xBE, 0xEF};
591
592 // Service data with 16bit uuid included, should succeed with
593 // uuid and service data parsed out
594 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
595 .Times(1)
596 .WillOnce(SaveArg<1>(&start_advertising_cb));
597 AdvertiseDataTestHelper(service_16bit_adv, callback, &start_advertising_cb);
598 EXPECT_EQ(6, callback_count);
599 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
600
601 // Service data with 32bit uuid included, should succeed with
602 // uuid and service data parsed out
603 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
604 .Times(1)
605 .WillOnce(SaveArg<1>(&start_advertising_cb));
606 AdvertiseDataTestHelper(service_32bit_adv, callback, &start_advertising_cb);
607 EXPECT_EQ(7, callback_count);
608 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
609
610 // Service data with 128bit uuid included, should succeed with
611 // uuid and service data parsed out
612 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
613 .Times(1)
614 .WillOnce(SaveArg<1>(&start_advertising_cb));
615 AdvertiseDataTestHelper(service_128bit_adv, callback, &start_advertising_cb);
616 EXPECT_EQ(8, callback_count);
617 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
618
619 // Service data and Uuid where the Uuid for both match, should succeed.
620 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
621 .Times(1)
622 .WillOnce(SaveArg<1>(&start_advertising_cb));
623 AdvertiseDataTestHelper(service_uuid_match, callback, &start_advertising_cb);
624 EXPECT_EQ(9, callback_count);
625 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
626
627 // Service data and Uuid where the Uuid for dont match, should fail
628 EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))
629 .Times(1)
630 .WillOnce(SaveArg<1>(&start_advertising_cb));
631 AdvertiseDataTestHelper(service_uuid_match, callback, &start_advertising_cb);
632 EXPECT_EQ(10, callback_count);
633 ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
634 }
635
636 MATCHER_P(BitEq, x, std::string(negation ? "isn't" : "is") +
637 " bitwise equal to " + ::testing::PrintToString(x)) {
638 static_assert(sizeof(x) == sizeof(arg), "Size mismatch");
639 return std::memcmp(&arg, &x, sizeof(x)) == 0;
640 }
641
642 } // namespace
643 } // namespace bluetooth
644