low_energy_client_unittest.cpp revision ff651b7fd11daaa29732cb8735d248910d9248f9 
1//
2//  Copyright (C) 2015 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/hal/fake_bluetooth_gatt_interface.h"
22#include "service/low_energy_client.h"
23#include "stack/include/bt_types.h"
24#include "stack/include/hcidefs.h"
25
26using ::testing::_;
27using ::testing::Return;
28
29namespace bluetooth {
30namespace {
31
32class MockGattHandler
33    : public hal::FakeBluetoothGattInterface::TestClientHandler {
34 public:
35  MockGattHandler() = default;
36  ~MockGattHandler() override = default;
37
38  MOCK_METHOD1(RegisterClient, bt_status_t(bt_uuid_t*));
39  MOCK_METHOD1(UnregisterClient, bt_status_t(int));
40  MOCK_METHOD7(MultiAdvEnable, bt_status_t(int, int, int, int, int, int, int));
41  MOCK_METHOD10(
42      MultiAdvSetInstDataMock,
43      bt_status_t(bool, bool, bool, int, int, char*, int, char*, int, char*));
44  MOCK_METHOD1(MultiAdvDisable, bt_status_t(int));
45
46  // GMock has macros for up to 10 arguments (11 is really just too many...).
47  // For now we forward this call to a 10 argument mock, omitting the
48  // |client_if| argument.
49  bt_status_t MultiAdvSetInstData(
50      int /* client_if */,
51      bool set_scan_rsp, bool include_name,
52      bool incl_txpower, int appearance,
53      int manufacturer_len, char* manufacturer_data,
54      int service_data_len, char* service_data,
55      int service_uuid_len, char* service_uuid) override {
56    return MultiAdvSetInstDataMock(
57        set_scan_rsp, include_name, incl_txpower, appearance,
58        manufacturer_len, manufacturer_data,
59        service_data_len, service_data,
60        service_uuid_len, service_uuid);
61  }
62
63 private:
64  DISALLOW_COPY_AND_ASSIGN(MockGattHandler);
65};
66
67// Created this class for testing Advertising Data Setting
68// It provides a work around in order to verify the arguments
69// in the arrays passed to MultiAdvSetInstData due to mocks
70// not having an easy way to verify entire arrays
71class AdvertiseDataHandler : public MockGattHandler {
72 public:
73  AdvertiseDataHandler() : call_count_(0) {}
74  ~AdvertiseDataHandler() override = default;
75
76  bt_status_t MultiAdvSetInstData(
77      int /* client_if */,
78      bool set_scan_rsp, bool include_name,
79      bool incl_txpower, int appearance,
80      int manufacturer_len, char* manufacturer_data,
81      int service_data_len, char* service_data,
82      int service_uuid_len, char* service_uuid) override {
83    call_count_++;
84    service_data_.assign(
85        service_data, service_data+service_data_len);
86    manufacturer_data_.assign(
87        manufacturer_data, manufacturer_data+manufacturer_len);
88    uuid_data_.assign(
89        service_uuid, service_uuid+service_uuid_len);
90    return BT_STATUS_SUCCESS;
91  }
92
93  const std::vector<uint8_t>& manufacturer_data() const {
94    return manufacturer_data_;
95  }
96  const std::vector<uint8_t>& service_data() const { return service_data_; }
97  const std::vector<uint8_t>& uuid_data() const { return uuid_data_; }
98  int call_count() const { return call_count_; }
99
100 private:
101  int call_count_;
102  std::vector<uint8_t> manufacturer_data_;
103  std::vector<uint8_t> service_data_;
104  std::vector<uint8_t> uuid_data_;
105
106
107};
108
109class LowEnergyClientTest : public ::testing::Test {
110 public:
111  LowEnergyClientTest() = default;
112  ~LowEnergyClientTest() override = default;
113
114  void SetUp() override {
115    // Only set |mock_handler_| if a test hasn't set it.
116    if (!mock_handler_)
117        mock_handler_.reset(new MockGattHandler());
118    fake_hal_gatt_iface_ = new hal::FakeBluetoothGattInterface(
119        std::static_pointer_cast<
120            hal::FakeBluetoothGattInterface::TestClientHandler>(mock_handler_),
121        nullptr);
122    hal::BluetoothGattInterface::InitializeForTesting(fake_hal_gatt_iface_);
123    ble_factory_.reset(new LowEnergyClientFactory());
124  }
125
126  void TearDown() override {
127    ble_factory_.reset();
128    hal::BluetoothGattInterface::CleanUp();
129  }
130
131 protected:
132  hal::FakeBluetoothGattInterface* fake_hal_gatt_iface_;
133  std::shared_ptr<MockGattHandler> mock_handler_;
134  std::unique_ptr<LowEnergyClientFactory> ble_factory_;
135
136 private:
137  DISALLOW_COPY_AND_ASSIGN(LowEnergyClientTest);
138};
139
140// Used for tests that operate on a pre-registered client.
141class LowEnergyClientPostRegisterTest : public LowEnergyClientTest {
142 public:
143  LowEnergyClientPostRegisterTest() = default;
144  ~LowEnergyClientPostRegisterTest() override = default;
145
146  void SetUp() override {
147    LowEnergyClientTest::SetUp();
148    UUID uuid = UUID::GetRandom();
149    auto callback = [&](BLEStatus status, const UUID& in_uuid,
150                        std::unique_ptr<BluetoothClientInstance> in_client) {
151      CHECK(in_uuid == uuid);
152      CHECK(in_client.get());
153      CHECK(status == BLE_STATUS_SUCCESS);
154
155      le_client_ = std::unique_ptr<LowEnergyClient>(
156          static_cast<LowEnergyClient*>(in_client.release()));
157    };
158
159    EXPECT_CALL(*mock_handler_, RegisterClient(_))
160        .Times(1)
161        .WillOnce(Return(BT_STATUS_SUCCESS));
162
163    ble_factory_->RegisterClient(uuid, callback);
164
165    bt_uuid_t hal_uuid = uuid.GetBlueDroid();
166    fake_hal_gatt_iface_->NotifyRegisterClientCallback(0, 0, hal_uuid);
167    testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
168  }
169
170  void TearDown() override {
171    EXPECT_CALL(*mock_handler_, MultiAdvDisable(_))
172        .Times(1)
173        .WillOnce(Return(BT_STATUS_SUCCESS));
174    EXPECT_CALL(*mock_handler_, UnregisterClient(_))
175        .Times(1)
176        .WillOnce(Return(BT_STATUS_SUCCESS));
177    le_client_.reset();
178    LowEnergyClientTest::TearDown();
179  }
180
181  void StartAdvertising() {
182    ASSERT_FALSE(le_client_->IsAdvertisingStarted());
183    ASSERT_FALSE(le_client_->IsStartingAdvertising());
184    ASSERT_FALSE(le_client_->IsStoppingAdvertising());
185
186    EXPECT_CALL(*mock_handler_, MultiAdvEnable(_, _, _, _, _, _, _))
187        .Times(1)
188        .WillOnce(Return(BT_STATUS_SUCCESS));
189    EXPECT_CALL(*mock_handler_,
190                MultiAdvSetInstDataMock(_, _, _, _, _, _, _, _, _, _))
191        .Times(1)
192        .WillOnce(Return(BT_STATUS_SUCCESS));
193
194    AdvertiseSettings settings;
195    AdvertiseData adv, scan_rsp;
196    ASSERT_TRUE(le_client_->StartAdvertising(
197        settings, adv, scan_rsp, LowEnergyClient::StatusCallback()));
198    ASSERT_TRUE(le_client_->IsStartingAdvertising());
199
200    fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
201        le_client_->GetClientId(), BT_STATUS_SUCCESS);
202    fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
203        le_client_->GetClientId(), BT_STATUS_SUCCESS);
204
205    ASSERT_TRUE(le_client_->IsAdvertisingStarted());
206    ASSERT_FALSE(le_client_->IsStartingAdvertising());
207    ASSERT_FALSE(le_client_->IsStoppingAdvertising());
208  }
209
210  void AdvertiseDataTestHelper(AdvertiseData data, std::function<void(BLEStatus)> callback){
211    AdvertiseSettings settings;
212    EXPECT_TRUE(le_client_->StartAdvertising(
213        settings, data, AdvertiseData(), callback));
214    fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
215        le_client_->GetClientId(), BT_STATUS_SUCCESS);
216    fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
217        le_client_->GetClientId(), BT_STATUS_SUCCESS);
218    EXPECT_TRUE(le_client_->StopAdvertising(LowEnergyClient::StatusCallback()));
219    fake_hal_gatt_iface_->NotifyMultiAdvDisableCallback(
220        le_client_->GetClientId(), BT_STATUS_SUCCESS);
221  }
222
223 protected:
224  std::unique_ptr<LowEnergyClient> le_client_;
225
226 private:
227  DISALLOW_COPY_AND_ASSIGN(LowEnergyClientPostRegisterTest);
228};
229
230TEST_F(LowEnergyClientTest, RegisterClient) {
231  EXPECT_CALL(*mock_handler_, RegisterClient(_))
232      .Times(2)
233      .WillOnce(Return(BT_STATUS_FAIL))
234      .WillOnce(Return(BT_STATUS_SUCCESS));
235
236  // These will be asynchronously populated with a result when the callback
237  // executes.
238  BLEStatus status = BLE_STATUS_SUCCESS;
239  UUID cb_uuid;
240  std::unique_ptr<LowEnergyClient> client;
241  int callback_count = 0;
242
243  auto callback = [&](BLEStatus in_status, const UUID& uuid,
244                      std::unique_ptr<BluetoothClientInstance> in_client) {
245        status = in_status;
246        cb_uuid = uuid;
247        client = std::unique_ptr<LowEnergyClient>(
248            static_cast<LowEnergyClient*>(in_client.release()));
249        callback_count++;
250      };
251
252  UUID uuid0 = UUID::GetRandom();
253
254  // HAL returns failure.
255  EXPECT_FALSE(ble_factory_->RegisterClient(uuid0, callback));
256  EXPECT_EQ(0, callback_count);
257
258  // HAL returns success.
259  EXPECT_TRUE(ble_factory_->RegisterClient(uuid0, callback));
260  EXPECT_EQ(0, callback_count);
261
262  // Calling twice with the same UUID should fail with no additional call into
263  // the stack.
264  EXPECT_FALSE(ble_factory_->RegisterClient(uuid0, callback));
265
266  testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
267
268  // Call with a different UUID while one is pending.
269  UUID uuid1 = UUID::GetRandom();
270  EXPECT_CALL(*mock_handler_, RegisterClient(_))
271      .Times(1)
272      .WillOnce(Return(BT_STATUS_SUCCESS));
273  EXPECT_TRUE(ble_factory_->RegisterClient(uuid1, callback));
274
275  // Trigger callback with an unknown UUID. This should get ignored.
276  UUID uuid2 = UUID::GetRandom();
277  bt_uuid_t hal_uuid = uuid2.GetBlueDroid();
278  fake_hal_gatt_iface_->NotifyRegisterClientCallback(0, 0, hal_uuid);
279  EXPECT_EQ(0, callback_count);
280
281  // |uuid0| succeeds.
282  int client_if0 = 2;  // Pick something that's not 0.
283  hal_uuid = uuid0.GetBlueDroid();
284  fake_hal_gatt_iface_->NotifyRegisterClientCallback(
285      BT_STATUS_SUCCESS, client_if0, hal_uuid);
286
287  EXPECT_EQ(1, callback_count);
288  ASSERT_TRUE(client.get() != nullptr);  // Assert to terminate in case of error
289  EXPECT_EQ(BLE_STATUS_SUCCESS, status);
290  EXPECT_EQ(client_if0, client->GetClientId());
291  EXPECT_EQ(uuid0, client->GetAppIdentifier());
292  EXPECT_EQ(uuid0, cb_uuid);
293
294  // The client should unregister itself when deleted.
295  EXPECT_CALL(*mock_handler_, MultiAdvDisable(client_if0))
296      .Times(1)
297      .WillOnce(Return(BT_STATUS_SUCCESS));
298  EXPECT_CALL(*mock_handler_, UnregisterClient(client_if0))
299      .Times(1)
300      .WillOnce(Return(BT_STATUS_SUCCESS));
301  client.reset();
302  testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
303
304  // |uuid1| fails.
305  int client_if1 = 3;
306  hal_uuid = uuid1.GetBlueDroid();
307  fake_hal_gatt_iface_->NotifyRegisterClientCallback(
308      BT_STATUS_FAIL, client_if1, hal_uuid);
309
310  EXPECT_EQ(2, callback_count);
311  ASSERT_TRUE(client.get() == nullptr);  // Assert to terminate in case of error
312  EXPECT_EQ(BLE_STATUS_FAILURE, status);
313  EXPECT_EQ(uuid1, cb_uuid);
314}
315
316TEST_F(LowEnergyClientPostRegisterTest, StartAdvertisingBasic) {
317  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
318  EXPECT_FALSE(le_client_->IsStartingAdvertising());
319  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
320
321  // Use default advertising settings and data.
322  AdvertiseSettings settings;
323  AdvertiseData adv_data, scan_rsp;
324  int callback_count = 0;
325  BLEStatus last_status = BLE_STATUS_FAILURE;
326  auto callback = [&](BLEStatus status) {
327    last_status = status;
328    callback_count++;
329  };
330
331  EXPECT_CALL(*mock_handler_, MultiAdvEnable(_, _, _, _, _, _, _))
332      .Times(5)
333      .WillOnce(Return(BT_STATUS_FAIL))
334      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
335
336  // Stack call returns failure.
337  EXPECT_FALSE(le_client_->StartAdvertising(
338      settings, adv_data, scan_rsp, callback));
339  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
340  EXPECT_FALSE(le_client_->IsStartingAdvertising());
341  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
342  EXPECT_EQ(0, callback_count);
343
344  // Stack call returns success.
345  EXPECT_TRUE(le_client_->StartAdvertising(
346      settings, adv_data, scan_rsp, callback));
347  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
348  EXPECT_TRUE(le_client_->IsStartingAdvertising());
349  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
350  EXPECT_EQ(0, callback_count);
351
352  // Already starting.
353  EXPECT_FALSE(le_client_->StartAdvertising(
354      settings, adv_data, scan_rsp, callback));
355
356  // Notify failure.
357  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
358      le_client_->GetClientId(), BT_STATUS_FAIL);
359  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
360  EXPECT_FALSE(le_client_->IsStartingAdvertising());
361  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
362  EXPECT_EQ(1, callback_count);
363  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
364
365  // Try again.
366  EXPECT_TRUE(le_client_->StartAdvertising(
367      settings, adv_data, scan_rsp, callback));
368  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
369  EXPECT_TRUE(le_client_->IsStartingAdvertising());
370  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
371  EXPECT_EQ(1, callback_count);
372
373  // Success notification should trigger advertise data update.
374  EXPECT_CALL(*mock_handler_,
375              MultiAdvSetInstDataMock(
376                  false,  // set_scan_rsp
377                  false,  // include_name
378                  false,  // incl_txpower
379                  _, _, _, _, _, _, _))
380      .Times(3)
381      .WillOnce(Return(BT_STATUS_FAIL))
382      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
383
384  // Notify success for enable. The procedure will fail since setting data will
385  // fail.
386  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
387      le_client_->GetClientId(), BT_STATUS_SUCCESS);
388  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
389  EXPECT_FALSE(le_client_->IsStartingAdvertising());
390  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
391  EXPECT_EQ(2, callback_count);
392  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
393
394  // Try again.
395  EXPECT_TRUE(le_client_->StartAdvertising(
396      settings, adv_data, scan_rsp, callback));
397  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
398  EXPECT_TRUE(le_client_->IsStartingAdvertising());
399  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
400  EXPECT_EQ(2, callback_count);
401
402  // Notify success for enable. the advertise data call should succeed but
403  // operation will remain pending.
404  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
405      le_client_->GetClientId(), BT_STATUS_SUCCESS);
406  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
407  EXPECT_TRUE(le_client_->IsStartingAdvertising());
408  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
409  EXPECT_EQ(2, callback_count);
410
411  // Notify failure from advertising call.
412  fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
413      le_client_->GetClientId(), BT_STATUS_FAIL);
414  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
415  EXPECT_FALSE(le_client_->IsStartingAdvertising());
416  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
417  EXPECT_EQ(3, callback_count);
418  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
419
420  // Try again. Make everything succeed.
421  EXPECT_TRUE(le_client_->StartAdvertising(
422      settings, adv_data, scan_rsp, callback));
423  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
424  EXPECT_TRUE(le_client_->IsStartingAdvertising());
425  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
426  EXPECT_EQ(3, callback_count);
427
428  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
429      le_client_->GetClientId(), BT_STATUS_SUCCESS);
430  fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
431      le_client_->GetClientId(), BT_STATUS_SUCCESS);
432  EXPECT_TRUE(le_client_->IsAdvertisingStarted());
433  EXPECT_FALSE(le_client_->IsStartingAdvertising());
434  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
435  EXPECT_EQ(4, callback_count);
436  EXPECT_EQ(BLE_STATUS_SUCCESS, last_status);
437
438  // Already started.
439  EXPECT_FALSE(le_client_->StartAdvertising(
440      settings, adv_data, scan_rsp, callback));
441}
442
443TEST_F(LowEnergyClientPostRegisterTest, StopAdvertisingBasic) {
444  AdvertiseSettings settings;
445
446  // Not enabled.
447  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
448  EXPECT_FALSE(le_client_->StopAdvertising(LowEnergyClient::StatusCallback()));
449
450  // Start advertising for testing.
451  StartAdvertising();
452
453  int callback_count = 0;
454  BLEStatus last_status = BLE_STATUS_FAILURE;
455  auto callback = [&](BLEStatus status) {
456    last_status = status;
457    callback_count++;
458  };
459
460  EXPECT_CALL(*mock_handler_, MultiAdvDisable(_))
461      .Times(3)
462      .WillOnce(Return(BT_STATUS_FAIL))
463      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
464
465  // Stack call returns failure.
466  EXPECT_FALSE(le_client_->StopAdvertising(callback));
467  EXPECT_TRUE(le_client_->IsAdvertisingStarted());
468  EXPECT_FALSE(le_client_->IsStartingAdvertising());
469  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
470  EXPECT_EQ(0, callback_count);
471
472  // Stack returns success.
473  EXPECT_TRUE(le_client_->StopAdvertising(callback));
474  EXPECT_TRUE(le_client_->IsAdvertisingStarted());
475  EXPECT_FALSE(le_client_->IsStartingAdvertising());
476  EXPECT_TRUE(le_client_->IsStoppingAdvertising());
477  EXPECT_EQ(0, callback_count);
478
479  // Already disabling.
480  EXPECT_FALSE(le_client_->StopAdvertising(callback));
481  EXPECT_TRUE(le_client_->IsAdvertisingStarted());
482  EXPECT_FALSE(le_client_->IsStartingAdvertising());
483  EXPECT_TRUE(le_client_->IsStoppingAdvertising());
484  EXPECT_EQ(0, callback_count);
485
486  // Notify failure.
487  fake_hal_gatt_iface_->NotifyMultiAdvDisableCallback(
488      le_client_->GetClientId(), BT_STATUS_FAIL);
489  EXPECT_TRUE(le_client_->IsAdvertisingStarted());
490  EXPECT_FALSE(le_client_->IsStartingAdvertising());
491  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
492  EXPECT_EQ(1, callback_count);
493  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
494
495  // Try again.
496  EXPECT_TRUE(le_client_->StopAdvertising(callback));
497  EXPECT_TRUE(le_client_->IsAdvertisingStarted());
498  EXPECT_FALSE(le_client_->IsStartingAdvertising());
499  EXPECT_TRUE(le_client_->IsStoppingAdvertising());
500  EXPECT_EQ(1, callback_count);
501
502  // Notify success.
503  fake_hal_gatt_iface_->NotifyMultiAdvDisableCallback(
504      le_client_->GetClientId(), BT_STATUS_SUCCESS);
505  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
506  EXPECT_FALSE(le_client_->IsStartingAdvertising());
507  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
508  EXPECT_EQ(2, callback_count);
509  EXPECT_EQ(BLE_STATUS_SUCCESS, last_status);
510
511  // Already stopped.
512  EXPECT_FALSE(le_client_->StopAdvertising(callback));
513}
514
515TEST_F(LowEnergyClientPostRegisterTest, InvalidAdvertiseData) {
516  const std::vector<uint8_t> data0{ 0x02, HCI_EIR_FLAGS_TYPE, 0x00 };
517  const std::vector<uint8_t> data1{
518      0x04, HCI_EIR_MANUFACTURER_SPECIFIC_TYPE, 0x01, 0x02, 0x00
519  };
520  AdvertiseData invalid_adv(data0);
521  AdvertiseData valid_adv(data1);
522
523  AdvertiseSettings settings;
524
525  EXPECT_FALSE(le_client_->StartAdvertising(
526      settings, valid_adv, invalid_adv, LowEnergyClient::StatusCallback()));
527  EXPECT_FALSE(le_client_->StartAdvertising(
528      settings, invalid_adv, valid_adv, LowEnergyClient::StatusCallback()));
529
530  // Manufacturer data not correctly formatted according to spec. We let the
531  // stack handle this case.
532  const std::vector<uint8_t> data2{ 0x01, HCI_EIR_MANUFACTURER_SPECIFIC_TYPE };
533  AdvertiseData invalid_mfc(data2);
534
535  EXPECT_CALL(*mock_handler_, MultiAdvEnable(_, _, _, _, _, _, _))
536      .Times(1)
537      .WillOnce(Return(BT_STATUS_SUCCESS));
538  EXPECT_TRUE(le_client_->StartAdvertising(
539      settings, invalid_mfc, valid_adv, LowEnergyClient::StatusCallback()));
540}
541
542TEST_F(LowEnergyClientPostRegisterTest, ScanResponse) {
543  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
544  EXPECT_FALSE(le_client_->IsStartingAdvertising());
545  EXPECT_FALSE(le_client_->IsStoppingAdvertising());
546
547  AdvertiseSettings settings(
548      AdvertiseSettings::MODE_LOW_POWER,
549      base::TimeDelta::FromMilliseconds(300),
550      AdvertiseSettings::TX_POWER_LEVEL_MEDIUM,
551      false /* connectable */);
552
553  const std::vector<uint8_t> data0;
554  const std::vector<uint8_t> data1{
555      0x04, HCI_EIR_MANUFACTURER_SPECIFIC_TYPE, 0x01, 0x02, 0x00
556  };
557
558  int callback_count = 0;
559  BLEStatus last_status = BLE_STATUS_FAILURE;
560  auto callback = [&](BLEStatus status) {
561    last_status = status;
562    callback_count++;
563  };
564
565  AdvertiseData adv0(data0);
566  adv0.set_include_tx_power_level(true);
567
568  AdvertiseData adv1(data1);
569  adv1.set_include_device_name(true);
570
571  EXPECT_CALL(*mock_handler_,
572              MultiAdvEnable(le_client_->GetClientId(), _, _,
573                             kAdvertisingEventTypeScannable,
574                             _, _, _))
575      .Times(2)
576      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
577  EXPECT_CALL(
578      *mock_handler_,
579      MultiAdvSetInstDataMock(
580          false,  // set_scan_rsp
581          false,  // include_name
582          true,  // incl_txpower,
583          _,
584          0,  // 0 bytes
585          _, _, _, _, _))
586      .Times(2)
587      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
588  EXPECT_CALL(
589      *mock_handler_,
590      MultiAdvSetInstDataMock(
591          true,  // set_scan_rsp
592          true,  // include_name
593          false,  // incl_txpower,
594          _,
595          data1.size() - 2,  // Mfc. Specific data field bytes.
596          _, _, _, _, _))
597      .Times(2)
598      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
599
600  // Enable success; Adv. data success; Scan rsp. fail.
601  EXPECT_TRUE(le_client_->StartAdvertising(settings, adv0, adv1, callback));
602  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
603      le_client_->GetClientId(), BT_STATUS_SUCCESS);
604  fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
605      le_client_->GetClientId(), BT_STATUS_SUCCESS);
606  fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
607      le_client_->GetClientId(), BT_STATUS_FAIL);
608
609  EXPECT_EQ(1, callback_count);
610  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
611  EXPECT_FALSE(le_client_->IsAdvertisingStarted());
612
613  // Second time everything succeeds.
614  EXPECT_TRUE(le_client_->StartAdvertising(settings, adv0, adv1, callback));
615  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
616      le_client_->GetClientId(), BT_STATUS_SUCCESS);
617  fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
618      le_client_->GetClientId(), BT_STATUS_SUCCESS);
619  fake_hal_gatt_iface_->NotifyMultiAdvDataCallback(
620      le_client_->GetClientId(), BT_STATUS_SUCCESS);
621
622  EXPECT_EQ(2, callback_count);
623  EXPECT_EQ(BLE_STATUS_SUCCESS, last_status);
624  EXPECT_TRUE(le_client_->IsAdvertisingStarted());
625}
626
627TEST_F(LowEnergyClientPostRegisterTest, AdvertiseDataParsing) {
628  // Re-initialize the test with our own custom handler.
629  TearDown();
630  std::shared_ptr<AdvertiseDataHandler> adv_handler(new AdvertiseDataHandler());
631  mock_handler_ = std::static_pointer_cast<MockGattHandler>(adv_handler);
632  SetUp();
633
634  const std::vector<uint8_t> kUUID16BitData{
635    0x03, HCI_EIR_COMPLETE_16BITS_UUID_TYPE, 0xDE, 0xAD,
636  };
637
638  const std::vector<uint8_t> kUUID32BitData{
639    0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x02
640  };
641
642  const std::vector<uint8_t> kUUID128BitData{
643    0x11, HCI_EIR_COMPLETE_128BITS_UUID_TYPE,
644    0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
645    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E
646  };
647
648  const std::vector<uint8_t> kMultiUUIDData{
649    0x11, HCI_EIR_COMPLETE_128BITS_UUID_TYPE,
650    0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
651    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
652    0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE, 0xDE, 0xAD, 0xBE, 0xEF
653  };
654
655  const std::vector<uint8_t> kServiceData16Bit{
656    0x05, HCI_EIR_SERVICE_DATA_16BITS_UUID_TYPE, 0xDE, 0xAD, 0xBE, 0xEF
657  };
658
659  const std::vector<uint8_t> kServiceData32Bit{
660    0x07, HCI_EIR_SERVICE_DATA_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x02, 0xBE, 0xEF
661  };
662
663  const std::vector<uint8_t> kServiceData128Bit{
664    0x13, HCI_EIR_SERVICE_DATA_128BITS_UUID_TYPE,
665    0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
666    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0xBE, 0xEF
667  };
668
669  const std::vector<uint8_t> kMultiServiceData{
670    0x13, HCI_EIR_SERVICE_DATA_128BITS_UUID_TYPE,
671    0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xBE, 0xEF,
672    0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
673    0x05, HCI_EIR_SERVICE_DATA_16BITS_UUID_TYPE, 0xDE, 0xAD, 0xBE, 0xEF
674  };
675
676  const std::vector<uint8_t> kServiceUUIDMatch{
677    0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x02,
678    0x07, HCI_EIR_SERVICE_DATA_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x02, 0xBE, 0xEF
679  };
680
681  const std::vector<uint8_t> kServiceUUIDMismatch{
682    0x05, HCI_EIR_COMPLETE_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x01,
683    0x07, HCI_EIR_SERVICE_DATA_32BITS_UUID_TYPE, 0xDE, 0xAD, 0x01, 0x02, 0xBE, 0xEF
684  };
685
686  AdvertiseData uuid_16bit_adv(kUUID16BitData);
687  AdvertiseData uuid_32bit_adv(kUUID32BitData);
688  AdvertiseData uuid_128bit_adv(kUUID128BitData);
689  AdvertiseData multi_uuid_adv(kMultiUUIDData);
690
691  AdvertiseData service_16bit_adv(kServiceData16Bit);
692  AdvertiseData service_32bit_adv(kServiceData32Bit);
693  AdvertiseData service_128bit_adv(kServiceData128Bit);
694  AdvertiseData multi_service_adv(kMultiServiceData);
695
696  AdvertiseData service_uuid_match(kServiceUUIDMatch);
697  AdvertiseData service_uuid_mismatch(kServiceUUIDMismatch);
698
699  AdvertiseSettings settings;
700
701  int callback_count = 0;
702  BLEStatus last_status = BLE_STATUS_FAILURE;
703  auto callback = [&](BLEStatus status) {
704    last_status = status;
705    callback_count++;
706  };
707
708  EXPECT_CALL(*mock_handler_, MultiAdvEnable(_, _, _, _, _, _, _))
709      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
710  EXPECT_CALL(*mock_handler_, MultiAdvDisable(_))
711      .WillRepeatedly(Return(BT_STATUS_SUCCESS));
712
713  // Multiple UUID test, should fail due to only one UUID allowed
714  EXPECT_TRUE(le_client_->StartAdvertising(
715              settings, multi_uuid_adv, AdvertiseData(), callback));
716  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
717          le_client_->GetClientId(), BT_STATUS_SUCCESS);
718  EXPECT_EQ(1, callback_count);
719  EXPECT_EQ(0, adv_handler->call_count());
720  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
721
722  // Multiple Service Data test, should fail due to only one service data allowed
723  EXPECT_TRUE(le_client_->StartAdvertising(
724              settings, multi_uuid_adv, AdvertiseData(), callback));
725  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
726          le_client_->GetClientId(), BT_STATUS_SUCCESS);
727  EXPECT_EQ(2, callback_count);
728  EXPECT_EQ(0, adv_handler->call_count());
729  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
730
731  // 16bit uuid test, should succeed with correctly parsed uuid
732  AdvertiseDataTestHelper(uuid_16bit_adv, callback);
733  EXPECT_EQ(3, callback_count);
734  EXPECT_EQ(1, adv_handler->call_count());
735  const std::vector<uint8_t> uuid_16bit{0xDE, 0xAD};
736  EXPECT_EQ(uuid_16bit, adv_handler->uuid_data());
737
738  // 32bit uuid test, should succeed with correctly parsed uuid
739  AdvertiseDataTestHelper(uuid_32bit_adv, callback);
740  EXPECT_EQ(4, callback_count);
741  EXPECT_EQ(2, adv_handler->call_count());
742  const std::vector<uint8_t> uuid_32bit{0xDE, 0xAD, 0x01, 0x02};
743  EXPECT_EQ(uuid_32bit, adv_handler->uuid_data());
744
745  // 128bit uuid test, should succeed with correctly parsed uuid
746  AdvertiseDataTestHelper(uuid_128bit_adv, callback);
747  EXPECT_EQ(5, callback_count);
748  EXPECT_EQ(3, adv_handler->call_count());
749  const std::vector<uint8_t> uuid_128bit{
750    0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
751    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E
752  };
753  EXPECT_EQ(uuid_128bit, adv_handler->uuid_data());
754
755  const std::vector<uint8_t> service_data{ 0xBE, 0xEF };
756
757  // Service data with 16bit uuid included, should succede with
758  // uuid and service data parsed out
759  AdvertiseDataTestHelper(service_16bit_adv, callback);
760  EXPECT_EQ(6, callback_count);
761  EXPECT_EQ(4, adv_handler->call_count());
762  EXPECT_EQ(service_data, adv_handler->service_data());
763  EXPECT_EQ(uuid_16bit, adv_handler->uuid_data());
764
765  // Service data with 32bit uuid included, should succede with
766  // uuid and service data parsed out
767  AdvertiseDataTestHelper(service_32bit_adv, callback);
768  EXPECT_EQ(7, callback_count);
769  EXPECT_EQ(5, adv_handler->call_count());
770  EXPECT_EQ(service_data, adv_handler->service_data());
771  EXPECT_EQ(uuid_32bit, adv_handler->uuid_data());
772
773  // Service data with 128bit uuid included, should succede with
774  // uuid and service data parsed out
775  AdvertiseDataTestHelper(service_128bit_adv, callback);
776  EXPECT_EQ(8, callback_count);
777  EXPECT_EQ(6, adv_handler->call_count());
778  EXPECT_EQ(service_data, adv_handler->service_data());
779  EXPECT_EQ(uuid_128bit, adv_handler->uuid_data());
780
781  // Service data and UUID where the UUID for both match, should succede
782  AdvertiseDataTestHelper(service_uuid_match, callback);
783  EXPECT_EQ(9, callback_count);
784  EXPECT_EQ(7, adv_handler->call_count());
785  EXPECT_EQ(service_data, adv_handler->service_data());
786  const std::vector<uint8_t> uuid_32bit_matcher{ 0xDE, 0xAD, 0x01, 0x02 };
787  EXPECT_EQ(uuid_32bit_matcher, adv_handler->uuid_data());
788
789  //Service data and UUID where the UUID for dont match, should fail
790  EXPECT_TRUE(le_client_->StartAdvertising(
791              settings, service_uuid_mismatch, AdvertiseData(), callback));
792  fake_hal_gatt_iface_->NotifyMultiAdvEnableCallback(
793          le_client_->GetClientId(), BT_STATUS_SUCCESS);
794  EXPECT_EQ(10, callback_count);
795  EXPECT_EQ(7, adv_handler->call_count());
796  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);
797}
798
799}  // namespace
800}  // namespace bluetooth
801