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