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