1 /*
2 * Copyright 2019 The Android Open Source Project
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 "hci/le_scanning_manager.h"
18
19 #include <com_android_bluetooth_flags.h>
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22
23 #include <algorithm>
24 #include <chrono>
25 #include <future>
26 #include <list>
27 #include <map>
28 #include <memory>
29 #include <mutex>
30 #include <queue>
31 #include <vector>
32
33 #include "common/bind.h"
34 #include "hci/acl_manager.h"
35 #include "hci/address.h"
36 #include "hci/controller.h"
37 #include "hci/hci_layer.h"
38 #include "hci/hci_layer_fake.h"
39 #include "hci/uuid.h"
40 #include "os/thread.h"
41 #include "packet/raw_builder.h"
42
43 using ::testing::_;
44 using ::testing::Eq;
45
46 using namespace bluetooth;
47 using namespace std::chrono_literals;
48
49 using packet::kLittleEndian;
50 using packet::PacketView;
51 using packet::RawBuilder;
52
53 namespace {
54
55 // Event type fields.
56 // TODO(b/315496838): Use a common enum for event type bits.
57 static constexpr uint16_t kConnectable = 0x1;
58 static constexpr uint16_t kScannable = 0x2;
59 static constexpr uint16_t kScanResponse = 0x8;
60 static constexpr uint16_t kLegacy = 0x10;
61
make_filter(const hci::ApcfFilterType & filter_type)62 hci::AdvertisingPacketContentFilterCommand make_filter(const hci::ApcfFilterType& filter_type) {
63 hci::AdvertisingPacketContentFilterCommand filter{};
64 filter.filter_type = filter_type;
65
66 switch (filter_type) {
67 case hci::ApcfFilterType::AD_TYPE:
68 case hci::ApcfFilterType::SERVICE_DATA:
69 filter.ad_type = 0x09;
70 filter.data = {0x12, 0x34, 0x56, 0x78};
71 filter.data_mask = {0xff, 0xff, 0xff, 0xff};
72 break;
73 case hci::ApcfFilterType::BROADCASTER_ADDRESS:
74 filter.address = hci::Address::kEmpty;
75 filter.application_address_type = hci::ApcfApplicationAddressType::RANDOM;
76 break;
77 case hci::ApcfFilterType::SERVICE_UUID:
78 filter.uuid = hci::Uuid::From32Bit(0x12345678);
79 filter.uuid_mask = hci::Uuid::From32Bit(0xffffffff);
80 break;
81 case hci::ApcfFilterType::LOCAL_NAME:
82 filter.name = {0x01, 0x02, 0x03};
83 break;
84 case hci::ApcfFilterType::MANUFACTURER_DATA:
85 filter.company = 0x12;
86 filter.company_mask = 0xff;
87 filter.data = {0x12, 0x34, 0x56, 0x78};
88 filter.data_mask = {0xff, 0xff, 0xff, 0xff};
89 break;
90 case hci::ApcfFilterType::TRANSPORT_DISCOVERY_DATA:
91 filter.org_id = 0x02;
92 filter.tds_flags = 0x01;
93 filter.tds_flags_mask = 0xFF;
94 filter.meta_data_type = hci::ApcfMetaDataType::WIFI_NAN_HASH;
95 filter.meta_data = {0x4B, 0x14, 0x96, 0x96, 0x96, 0x5E, 0xA6, 0x33};
96 break;
97 default:
98 break;
99 }
100 return filter;
101 }
102
make_advertising_report()103 hci::LeAdvertisingResponse make_advertising_report() {
104 hci::LeAdvertisingResponse report{};
105 report.event_type_ = hci::AdvertisingEventType::ADV_DIRECT_IND;
106 report.address_type_ = hci::AddressType::PUBLIC_DEVICE_ADDRESS;
107 hci::Address::FromString("12:34:56:78:9a:bc", report.address_);
108 std::vector<hci::LengthAndData> adv_data{};
109 hci::LengthAndData data_item{};
110 data_item.data_.push_back(static_cast<uint8_t>(hci::GapDataType::FLAGS));
111 data_item.data_.push_back(0x34);
112 adv_data.push_back(data_item);
113 data_item.data_.push_back(static_cast<uint8_t>(hci::GapDataType::COMPLETE_LOCAL_NAME));
114 for (auto octet : {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'}) {
115 data_item.data_.push_back(octet);
116 }
117 adv_data.push_back(data_item);
118 report.advertising_data_ = adv_data;
119 return report;
120 }
121
122 } // namespace
123
124 namespace bluetooth {
125 namespace hci {
126 namespace {
127
128 class TestController : public Controller {
129 public:
IsSupported(OpCode op_code) const130 bool IsSupported(OpCode op_code) const override {
131 return supported_opcodes_.count(op_code) == 1;
132 }
133
AddSupported(OpCode op_code)134 void AddSupported(OpCode op_code) {
135 supported_opcodes_.insert(op_code);
136 }
137
SupportsBleExtendedAdvertising() const138 bool SupportsBleExtendedAdvertising() const override {
139 return support_ble_extended_advertising_;
140 }
141
SetBleExtendedAdvertisingSupport(bool support)142 void SetBleExtendedAdvertisingSupport(bool support) {
143 support_ble_extended_advertising_ = support;
144 }
145
SupportsBlePeriodicAdvertisingSyncTransferSender() const146 bool SupportsBlePeriodicAdvertisingSyncTransferSender() const override {
147 return support_ble_periodic_advertising_sync_transfer_;
148 }
149
SetBlePeriodicAdvertisingSyncTransferSenderSupport(bool support)150 void SetBlePeriodicAdvertisingSyncTransferSenderSupport(bool support) {
151 support_ble_periodic_advertising_sync_transfer_ = support;
152 }
153
154 protected:
Start()155 void Start() override {}
Stop()156 void Stop() override {}
ListDependencies(ModuleList *) const157 void ListDependencies(ModuleList* /* list */) const {}
158
159 private:
160 std::set<OpCode> supported_opcodes_{};
161 bool support_ble_extended_advertising_ = false;
162 bool support_ble_periodic_advertising_sync_transfer_ = false;
163 };
164
165 class TestLeAddressManager : public LeAddressManager {
166 public:
TestLeAddressManager(common::Callback<void (std::unique_ptr<CommandBuilder>)> enqueue_command,os::Handler * handler,Address public_address,uint8_t accept_list_size,uint8_t resolving_list_size)167 TestLeAddressManager(
168 common::Callback<void(std::unique_ptr<CommandBuilder>)> enqueue_command,
169 os::Handler* handler,
170 Address public_address,
171 uint8_t accept_list_size,
172 uint8_t resolving_list_size)
173 : LeAddressManager(enqueue_command, handler, public_address, accept_list_size, resolving_list_size) {}
174
Register(LeAddressManagerCallback * callback)175 AddressPolicy Register(LeAddressManagerCallback* callback) override {
176 client_ = callback;
177 test_client_state_ = RESUMED;
178 return AddressPolicy::USE_STATIC_ADDRESS;
179 }
180
Unregister(LeAddressManagerCallback *)181 void Unregister(LeAddressManagerCallback* /* callback */) override {
182 if (!ignore_unregister_for_testing) {
183 client_ = nullptr;
184 }
185 test_client_state_ = UNREGISTERED;
186 }
187
AckPause(LeAddressManagerCallback *)188 void AckPause(LeAddressManagerCallback* /* callback */) override {
189 test_client_state_ = PAUSED;
190 }
191
AckResume(LeAddressManagerCallback *)192 void AckResume(LeAddressManagerCallback* /* callback */) override {
193 test_client_state_ = RESUMED;
194 }
195
196 LeAddressManagerCallback* client_;
197 bool ignore_unregister_for_testing = false;
198 enum TestClientState {
199 UNREGISTERED,
200 PAUSED,
201 RESUMED,
202 };
203 TestClientState test_client_state_ = UNREGISTERED;
204 };
205
206 class TestAclManager : public AclManager {
207 public:
GetLeAddressManager()208 LeAddressManager* GetLeAddressManager() override {
209 return test_le_address_manager_;
210 }
211
212 protected:
Start()213 void Start() override {
214 thread_ = new os::Thread("thread", os::Thread::Priority::NORMAL);
215 handler_ = new os::Handler(thread_);
216 Address address({0x01, 0x02, 0x03, 0x04, 0x05, 0x06});
217 test_le_address_manager_ = new TestLeAddressManager(
218 common::Bind(&TestAclManager::enqueue_command, common::Unretained(this)), handler_, address, 0x3F, 0x3F);
219 }
220
Stop()221 void Stop() override {
222 delete test_le_address_manager_;
223 handler_->Clear();
224 delete handler_;
225 delete thread_;
226 }
227
ListDependencies(ModuleList *) const228 void ListDependencies(ModuleList* /* list */) const {}
229
SetRandomAddress(Address)230 void SetRandomAddress(Address /* address */) {}
231
enqueue_command(std::unique_ptr<CommandBuilder>)232 void enqueue_command(std::unique_ptr<CommandBuilder> /* command_packet */){};
233
234 private:
235 os::Thread* thread_;
236 os::Handler* handler_;
237 TestLeAddressManager* test_le_address_manager_;
238 };
239
240 class MockCallbacks : public bluetooth::hci::ScanningCallback {
241 public:
242 MOCK_METHOD(
243 void,
244 OnScannerRegistered,
245 (const bluetooth::hci::Uuid app_uuid, ScannerId scanner_id, ScanningStatus status),
246 (override));
247 MOCK_METHOD(void, OnSetScannerParameterComplete, (ScannerId scanner_id, ScanningStatus status), (override));
248 MOCK_METHOD(
249 void,
250 OnScanResult,
251 (uint16_t event_type,
252 uint8_t address_type,
253 Address address,
254 uint8_t primary_phy,
255 uint8_t secondary_phy,
256 uint8_t advertising_sid,
257 int8_t tx_power,
258 int8_t rssi,
259 uint16_t periodic_advertising_interval,
260 std::vector<uint8_t> advertising_data),
261 (override));
262 MOCK_METHOD(
263 void,
264 OnTrackAdvFoundLost,
265 (bluetooth::hci::AdvertisingFilterOnFoundOnLostInfo on_found_on_lost_info),
266 (override));
267 MOCK_METHOD(
268 void,
269 OnBatchScanReports,
270 (int client_if, int status, int report_format, int num_records, std::vector<uint8_t> data),
271 (override));
272 MOCK_METHOD(void, OnBatchScanThresholdCrossed, (int client_if), (override));
273 MOCK_METHOD(void, OnTimeout, (), (override));
274 MOCK_METHOD(void, OnFilterEnable, (Enable enable, uint8_t status), (override));
275 MOCK_METHOD(void, OnFilterParamSetup, (uint8_t available_spaces, ApcfAction action, uint8_t status), (override));
276 MOCK_METHOD(
277 void,
278 OnFilterConfigCallback,
279 (ApcfFilterType filter_type, uint8_t available_spaces, ApcfAction action, uint8_t status),
280 (override));
281 MOCK_METHOD(void, OnPeriodicSyncStarted, (int, uint8_t, uint16_t, uint8_t, AddressWithType, uint8_t, uint16_t));
282 MOCK_METHOD(void, OnPeriodicSyncReport, (uint16_t, int8_t, int8_t, uint8_t, std::vector<uint8_t>));
283 MOCK_METHOD(void, OnPeriodicSyncLost, (uint16_t));
284 MOCK_METHOD(void, OnPeriodicSyncTransferred, (int, uint8_t, Address));
285 MOCK_METHOD(void, OnBigInfoReport, (uint16_t, bool));
286 } mock_callbacks_;
287
288 class LeScanningManagerTest : public ::testing::Test {
289 protected:
SetUp()290 void SetUp() override {
291 test_hci_layer_ = new HciLayerFake; // Ownership is transferred to registry
292 test_controller_ = new TestController;
293 test_acl_manager_ = new TestAclManager;
294 fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);
295 fake_registry_.InjectTestModule(&Controller::Factory, test_controller_);
296 fake_registry_.InjectTestModule(&AclManager::Factory, test_acl_manager_);
297 client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
298 ASSERT_TRUE(client_handler_ != nullptr);
299 }
300
TearDown()301 void TearDown() override {
302 sync_client_handler();
303 if (fake_registry_.IsStarted<LeScanningManager>()) {
304 fake_registry_.SynchronizeModuleHandler(&LeScanningManager::Factory, std::chrono::milliseconds(20));
305 }
306 fake_registry_.StopAll();
307 }
308
start_le_scanning_manager()309 void start_le_scanning_manager() {
310 fake_registry_.Start<LeScanningManager>(&thread_);
311 le_scanning_manager =
312 static_cast<LeScanningManager*>(fake_registry_.GetModuleUnderTest(&LeScanningManager::Factory));
313 le_scanning_manager->RegisterScanningCallback(&mock_callbacks_);
314 sync_client_handler();
315 }
316
sync_client_handler()317 void sync_client_handler() {
318 log::assert_that(
319 thread_.GetReactor()->WaitForIdle(std::chrono::seconds(2)),
320 "assert failed: thread_.GetReactor()->WaitForIdle(std::chrono::seconds(2))");
321 }
322
323 TestModuleRegistry fake_registry_;
324 HciLayerFake* test_hci_layer_ = nullptr;
325 TestController* test_controller_ = nullptr;
326 TestAclManager* test_acl_manager_ = nullptr;
327 os::Thread& thread_ = fake_registry_.GetTestThread();
328 LeScanningManager* le_scanning_manager = nullptr;
329 os::Handler* client_handler_ = nullptr;
330
331 MockCallbacks mock_callbacks_;
332 };
333
334 class LeScanningManagerAndroidHciTest : public LeScanningManagerTest {
335 protected:
SetUp()336 void SetUp() override {
337 LeScanningManagerTest::SetUp();
338 test_controller_->AddSupported(OpCode::LE_EXTENDED_SCAN_PARAMS);
339 test_controller_->AddSupported(OpCode::LE_ADV_FILTER);
340 test_controller_->AddSupported(OpCode::LE_BATCH_SCAN);
341 test_controller_->SetBlePeriodicAdvertisingSyncTransferSenderSupport(true);
342 start_le_scanning_manager();
343 ASSERT_TRUE(fake_registry_.IsStarted(&HciLayer::Factory));
344
345
346 ASSERT_EQ(OpCode::LE_ADV_FILTER, test_hci_layer_->GetCommand().GetOpCode());
347 test_hci_layer_->IncomingEvent(
348 LeAdvFilterReadExtendedFeaturesCompleteBuilder::Create(1, ErrorCode::SUCCESS, 0x01, 0x01));
349 }
350
TearDown()351 void TearDown() override {
352 LeScanningManagerTest::TearDown();
353 }
354 };
355
356 class LeScanningManagerExtendedTest : public LeScanningManagerTest {
357 protected:
SetUp()358 void SetUp() override {
359 LeScanningManagerTest::SetUp();
360 test_controller_->AddSupported(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS);
361 test_controller_->AddSupported(OpCode::LE_SET_EXTENDED_SCAN_ENABLE);
362 test_controller_->SetBleExtendedAdvertisingSupport(true);
363 start_le_scanning_manager();
364 }
365 };
366
TEST_F(LeScanningManagerTest,startup_teardown)367 TEST_F(LeScanningManagerTest, startup_teardown) {}
368
TEST_F(LeScanningManagerTest,start_scan_test)369 TEST_F(LeScanningManagerTest, start_scan_test) {
370 start_le_scanning_manager();
371
372 // Enable scan
373 le_scanning_manager->Scan(true);
374 ASSERT_EQ(OpCode::LE_SET_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
375 test_hci_layer_->IncomingEvent(
376 LeSetScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
377 ASSERT_EQ(OpCode::LE_SET_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
378 test_hci_layer_->IncomingEvent(
379 LeSetScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
380
381 LeAdvertisingResponse report = make_advertising_report();
382 EXPECT_CALL(mock_callbacks_, OnScanResult);
383
384 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
385 }
386
TEST_F(LeScanningManagerTest,legacy_adv_scan_ind_report_with_scan_response)387 TEST_F(LeScanningManagerTest, legacy_adv_scan_ind_report_with_scan_response) {
388 start_le_scanning_manager();
389
390 le_scanning_manager->Scan(true);
391 ASSERT_EQ(OpCode::LE_SET_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
392 test_hci_layer_->IncomingEvent(
393 LeSetScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
394 ASSERT_EQ(OpCode::LE_SET_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
395 test_hci_layer_->IncomingEvent(
396 LeSetScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
397
398 LeAdvertisingResponse report = make_advertising_report();
399 // Scannable & not connectable!
400 report.event_type_ = AdvertisingEventType::ADV_SCAN_IND;
401
402 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
403
404 LeAdvertisingResponse scan_response = make_advertising_report();
405 scan_response.event_type_ = AdvertisingEventType::SCAN_RESPONSE;
406
407 // The 'connectable' bit should NOT be set.
408 uint16_t extended_event_type = kLegacy | kScannable | kScanResponse;
409 if (!com::android::bluetooth::flags::fix_nonconnectable_scannable_advertisement()) {
410 extended_event_type |= kConnectable;
411 }
412 EXPECT_CALL(mock_callbacks_, OnScanResult(extended_event_type, _, _, _, _, _, _, _, _, _));
413
414 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({scan_response}));
415 }
416
TEST_F(LeScanningManagerTest,legacy_adv_ind_report_with_scan_response)417 TEST_F(LeScanningManagerTest, legacy_adv_ind_report_with_scan_response) {
418 start_le_scanning_manager();
419
420 le_scanning_manager->Scan(true);
421 ASSERT_EQ(OpCode::LE_SET_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
422 test_hci_layer_->IncomingEvent(
423 LeSetScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
424 ASSERT_EQ(OpCode::LE_SET_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
425 test_hci_layer_->IncomingEvent(
426 LeSetScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
427
428 LeAdvertisingResponse report = make_advertising_report();
429 // Scannable & connectable!
430 report.event_type_ = AdvertisingEventType::ADV_IND;
431
432 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
433
434 LeAdvertisingResponse scan_response = make_advertising_report();
435 scan_response.event_type_ = AdvertisingEventType::SCAN_RESPONSE;
436
437 uint16_t extended_event_type = kLegacy | kScannable | kConnectable | kScanResponse;
438 EXPECT_CALL(mock_callbacks_, OnScanResult(extended_event_type, _, _, _, _, _, _, _, _, _));
439
440 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({scan_response}));
441 }
442
TEST_F(LeScanningManagerTest,is_ad_type_filter_supported_false_test)443 TEST_F(LeScanningManagerTest, is_ad_type_filter_supported_false_test) {
444 start_le_scanning_manager();
445 ASSERT_TRUE(fake_registry_.IsStarted(&HciLayer::Factory));
446 ASSERT_FALSE(le_scanning_manager->IsAdTypeFilterSupported());
447 }
448
TEST_F(LeScanningManagerTest,scan_filter_add_ad_type_not_supported_test)449 TEST_F(LeScanningManagerTest, scan_filter_add_ad_type_not_supported_test) {
450 start_le_scanning_manager();
451 ASSERT_TRUE(fake_registry_.IsStarted(&HciLayer::Factory));
452
453 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
454 filters.push_back(make_filter(hci::ApcfFilterType::AD_TYPE));
455 le_scanning_manager->ScanFilterAdd(0x01, filters);
456 }
457
TEST_F(LeScanningManagerExtendedTest,is_nonstandard_phy_supported_test)458 TEST_F(LeScanningManagerExtendedTest, is_nonstandard_phy_supported_test) {
459 int scan_phy = 2;
460
461 start_le_scanning_manager();
462 le_scanning_manager->SetScanParameters(1, LeScanType::ACTIVE, 0x0004, 4800, scan_phy);
463 le_scanning_manager->Scan(true);
464
465 auto command_view = LeSetExtendedScanParametersView::Create(
466 LeScanningCommandView::Create(test_hci_layer_->GetCommand()));
467 ASSERT_TRUE(command_view.IsValid());
468 if (com::android::bluetooth::flags::phy_to_native()) {
469 ASSERT_EQ(command_view.GetScanningPhys(), scan_phy);
470 ASSERT_EQ(command_view.GetParameters().size(), static_cast<size_t>(1));
471 }
472 }
473
TEST_F(LeScanningManagerExtendedTest,is_multiple_phy_supported_test)474 TEST_F(LeScanningManagerExtendedTest, is_multiple_phy_supported_test) {
475 int scan_phy = 3;
476
477 start_le_scanning_manager();
478 le_scanning_manager->SetScanParameters(1, LeScanType::ACTIVE, 0x0004, 4800, scan_phy);
479 le_scanning_manager->Scan(true);
480
481 auto command_view = LeSetExtendedScanParametersView::Create(
482 LeScanningCommandView::Create(test_hci_layer_->GetCommand()));
483 ASSERT_TRUE(command_view.IsValid());
484 if (com::android::bluetooth::flags::phy_to_native()) {
485 ASSERT_EQ(command_view.GetScanningPhys(), scan_phy);
486 ASSERT_EQ(command_view.GetParameters().size(), static_cast<size_t>(2));
487 }
488 }
489
TEST_F(LeScanningManagerAndroidHciTest,startup_teardown)490 TEST_F(LeScanningManagerAndroidHciTest, startup_teardown) {}
491
TEST_F(LeScanningManagerAndroidHciTest,start_scan_test)492 TEST_F(LeScanningManagerAndroidHciTest, start_scan_test) {
493 // Enable scan
494 le_scanning_manager->Scan(true);
495 ASSERT_EQ(OpCode::LE_EXTENDED_SCAN_PARAMS, test_hci_layer_->GetCommand().GetOpCode());
496
497 LeAdvertisingResponse report = make_advertising_report();
498
499 EXPECT_CALL(mock_callbacks_, OnScanResult);
500
501 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
502 }
503
TEST_F(LeScanningManagerAndroidHciTest,is_ad_type_filter_supported_true_test)504 TEST_F(LeScanningManagerAndroidHciTest, is_ad_type_filter_supported_true_test) {
505 sync_client_handler();
506 client_handler_->Post(common::BindOnce(
507 [](LeScanningManager* le_scanning_manager) { ASSERT_TRUE(le_scanning_manager->IsAdTypeFilterSupported()); },
508 le_scanning_manager));
509 }
510
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_enable_test)511 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_enable_test) {
512 le_scanning_manager->ScanFilterEnable(true);
513 sync_client_handler();
514
515 EXPECT_CALL(mock_callbacks_, OnFilterEnable);
516 test_hci_layer_->IncomingEvent(
517 LeAdvFilterEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, Enable::ENABLED));
518 sync_client_handler();
519 }
520
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_parameter_test)521 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_parameter_test) {
522
523 AdvertisingFilterParameter advertising_filter_parameter{};
524 advertising_filter_parameter.delivery_mode = DeliveryMode::IMMEDIATE;
525 le_scanning_manager->ScanFilterParameterSetup(ApcfAction::ADD, 0x01, advertising_filter_parameter);
526 auto commandView = test_hci_layer_->GetCommand();
527 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
528 auto filter_command_view = LeAdvFilterSetFilteringParametersView::Create(
529 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
530 ASSERT_TRUE(filter_command_view.IsValid());
531 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::SET_FILTERING_PARAMETERS);
532
533 EXPECT_CALL(mock_callbacks_, OnFilterParamSetup);
534 test_hci_layer_->IncomingEvent(
535 LeAdvFilterSetFilteringParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
536 sync_client_handler();
537 }
538
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_broadcaster_address_test)539 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_broadcaster_address_test) {
540
541 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
542 filters.push_back(make_filter(ApcfFilterType::BROADCASTER_ADDRESS));
543 le_scanning_manager->ScanFilterAdd(0x01, filters);
544 auto commandView = test_hci_layer_->GetCommand();
545 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
546 auto filter_command_view =
547 LeAdvFilterBroadcasterAddressView::Create(LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
548 ASSERT_TRUE(filter_command_view.IsValid());
549 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::BROADCASTER_ADDRESS);
550
551 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
552 test_hci_layer_->IncomingEvent(
553 LeAdvFilterBroadcasterAddressCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
554 }
555
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_service_uuid_test)556 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_service_uuid_test) {
557
558 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
559 filters.push_back(make_filter(ApcfFilterType::SERVICE_UUID));
560 le_scanning_manager->ScanFilterAdd(0x01, filters);
561 auto commandView = test_hci_layer_->GetCommand();
562 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
563 auto filter_command_view =
564 LeAdvFilterServiceUuidView::Create(LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
565 ASSERT_TRUE(filter_command_view.IsValid());
566 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::SERVICE_UUID);
567
568 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
569 test_hci_layer_->IncomingEvent(
570 LeAdvFilterServiceUuidCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
571 }
572
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_local_name_test)573 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_local_name_test) {
574
575 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
576 filters.push_back(make_filter(ApcfFilterType::LOCAL_NAME));
577 le_scanning_manager->ScanFilterAdd(0x01, filters);
578 auto commandView = test_hci_layer_->GetCommand();
579 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
580 auto filter_command_view =
581 LeAdvFilterLocalNameView::Create(LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
582 ASSERT_TRUE(filter_command_view.IsValid());
583 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::LOCAL_NAME);
584
585 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
586 test_hci_layer_->IncomingEvent(
587 LeAdvFilterLocalNameCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
588 }
589
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_manufacturer_data_test)590 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_manufacturer_data_test) {
591
592 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
593 filters.push_back(make_filter(ApcfFilterType::MANUFACTURER_DATA));
594 le_scanning_manager->ScanFilterAdd(0x01, filters);
595 auto commandView = test_hci_layer_->GetCommand();
596 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
597 auto filter_command_view =
598 LeAdvFilterManufacturerDataView::Create(LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
599 ASSERT_TRUE(filter_command_view.IsValid());
600 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::MANUFACTURER_DATA);
601
602 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
603 test_hci_layer_->IncomingEvent(
604 LeAdvFilterManufacturerDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
605 }
606
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_service_data_test)607 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_service_data_test) {
608
609 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
610 filters.push_back(make_filter(hci::ApcfFilterType::SERVICE_DATA));
611 le_scanning_manager->ScanFilterAdd(0x01, filters);
612 auto commandView = test_hci_layer_->GetCommand();
613 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
614 auto filter_command_view =
615 LeAdvFilterServiceDataView::Create(LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
616 ASSERT_TRUE(filter_command_view.IsValid());
617 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::SERVICE_DATA);
618
619 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
620 test_hci_layer_->IncomingEvent(
621 LeAdvFilterServiceDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
622 }
623
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_transport_discovery_data_test)624 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_transport_discovery_data_test) {
625 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
626 filters.push_back(make_filter(hci::ApcfFilterType::TRANSPORT_DISCOVERY_DATA));
627 le_scanning_manager->ScanFilterAdd(0x01, filters);
628 auto commandView = test_hci_layer_->GetCommand();
629 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
630 auto filter_command_view = LeAdvFilterTransportDiscoveryDataView::Create(
631 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
632
633 ASSERT_TRUE(filter_command_view.IsValid());
634 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::TRANSPORT_DISCOVERY_DATA);
635
636 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
637 test_hci_layer_->IncomingEvent(LeAdvFilterTransportDiscoveryDataCompleteBuilder::Create(
638 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
639 }
640
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_ad_type_test)641 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_ad_type_test) {
642 sync_client_handler();
643 client_handler_->Post(common::BindOnce(
644 [](LeScanningManager* le_scanning_manager) { ASSERT_TRUE(le_scanning_manager->IsAdTypeFilterSupported()); },
645 le_scanning_manager));
646
647 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
648 hci::AdvertisingPacketContentFilterCommand filter = make_filter(hci::ApcfFilterType::AD_TYPE);
649 filters.push_back(filter);
650 le_scanning_manager->ScanFilterAdd(0x01, filters);
651 sync_client_handler();
652
653 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
654 test_hci_layer_->IncomingEvent(
655 LeAdvFilterADTypeCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
656 }
657
TEST_F(LeScanningManagerAndroidHciTest,read_batch_scan_result)658 TEST_F(LeScanningManagerAndroidHciTest, read_batch_scan_result) {
659 le_scanning_manager->BatchScanConifgStorage(100, 0, 95, 0x00);
660 sync_client_handler();
661 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
662 test_hci_layer_->IncomingEvent(LeBatchScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
663 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
664 test_hci_layer_->IncomingEvent(
665 LeBatchScanSetStorageParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
666
667 // Enable batch scan
668
669 le_scanning_manager->BatchScanEnable(BatchScanMode::FULL, 2400, 2400, BatchScanDiscardRule::OLDEST);
670 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
671 test_hci_layer_->IncomingEvent(LeBatchScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
672
673 // Read batch scan data
674
675 le_scanning_manager->BatchScanReadReport(0x01, BatchScanMode::FULL);
676 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
677
678 // We will send read command while num_of_record != 0
679 std::vector<uint8_t> raw_data = {0x5c, 0x1f, 0xa2, 0xc3, 0x63, 0x5d, 0x01, 0xf5, 0xb3, 0x5e, 0x00, 0x0c, 0x02,
680 0x01, 0x02, 0x05, 0x09, 0x6d, 0x76, 0x38, 0x76, 0x02, 0x0a, 0xf5, 0x00};
681
682 test_hci_layer_->IncomingEvent(LeBatchScanReadResultParametersCompleteRawBuilder::Create(
683 uint8_t{1}, ErrorCode::SUCCESS, BatchScanDataRead::FULL_MODE_DATA, 1, raw_data));
684 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
685
686 // OnBatchScanReports will be trigger when num_of_record == 0
687 EXPECT_CALL(mock_callbacks_, OnBatchScanReports);
688 test_hci_layer_->IncomingEvent(LeBatchScanReadResultParametersCompleteRawBuilder::Create(
689 uint8_t{1}, ErrorCode::SUCCESS, BatchScanDataRead::FULL_MODE_DATA, 0, {}));
690 }
691
TEST_F(LeScanningManagerAndroidHciTest,start_sync_test)692 TEST_F(LeScanningManagerAndroidHciTest, start_sync_test) {
693 Address address;
694 const uint16_t handle = 0x0001;
695 const uint16_t service_data = 0x0000;
696 const uint16_t sync_handle = 0x0002;
697 const int pa_source = 3;
698
699 Address::FromString("12:34:56:78:9a:bc", address);
700
701 le_scanning_manager->TransferSync(address, handle, service_data, sync_handle, pa_source);
702 sync_client_handler();
703
704 ASSERT_EQ(
705 OpCode::LE_PERIODIC_ADVERTISING_SYNC_TRANSFER, test_hci_layer_->GetCommand().GetOpCode());
706 }
707
TEST_F(LeScanningManagerAndroidHciTest,start_sync_invalid_handle_test)708 TEST_F(LeScanningManagerAndroidHciTest, start_sync_invalid_handle_test) {
709 Address address;
710 const uint16_t handle = 0xFFFF;
711 const uint16_t service_data = 0x0000;
712 const uint16_t sync_handle = 0x0002;
713 const int pa_source = 3;
714
715 Address::FromString("12:34:56:78:9a:bc", address);
716
717 EXPECT_CALL(
718 mock_callbacks_,
719 OnPeriodicSyncTransferred(
720 pa_source, static_cast<int>(ErrorCode::UNKNOWN_CONNECTION), address));
721 le_scanning_manager->TransferSync(address, handle, service_data, sync_handle, pa_source);
722 sync_client_handler();
723 }
724
TEST_F(LeScanningManagerAndroidHciTest,set_info_test)725 TEST_F(LeScanningManagerAndroidHciTest, set_info_test) {
726 Address address;
727 const uint16_t handle = 0x0001;
728 const uint16_t service_data = 0x0000;
729 const uint16_t sync_handle = 0x0002;
730 const int pa_source = 3;
731
732 Address::FromString("12:34:56:78:9a:bc", address);
733
734 le_scanning_manager->TransferSetInfo(address, handle, service_data, sync_handle, pa_source);
735 sync_client_handler();
736
737 ASSERT_EQ(
738 OpCode::LE_PERIODIC_ADVERTISING_SET_INFO_TRANSFER, test_hci_layer_->GetCommand().GetOpCode());
739 }
740
TEST_F(LeScanningManagerAndroidHciTest,set_info_invalid_handle_test)741 TEST_F(LeScanningManagerAndroidHciTest, set_info_invalid_handle_test) {
742 Address address;
743 const uint16_t handle = 0xFFFF;
744 const uint16_t service_data = 0x0000;
745 const uint16_t sync_handle = 0x0002;
746 const int pa_source = 3;
747
748 Address::FromString("12:34:56:78:9a:bc", address);
749
750 EXPECT_CALL(
751 mock_callbacks_,
752 OnPeriodicSyncTransferred(
753 pa_source, static_cast<int>(ErrorCode::UNKNOWN_CONNECTION), address));
754 le_scanning_manager->TransferSetInfo(address, handle, service_data, sync_handle, pa_source);
755 sync_client_handler();
756 }
757
TEST_F(LeScanningManagerExtendedTest,startup_teardown)758 TEST_F(LeScanningManagerExtendedTest, startup_teardown) {}
759
TEST_F(LeScanningManagerExtendedTest,start_scan_test)760 TEST_F(LeScanningManagerExtendedTest, start_scan_test) {
761 // Enable scan
762 le_scanning_manager->Scan(true);
763 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
764 test_hci_layer_->IncomingEvent(LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
765 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
766 test_hci_layer_->IncomingEvent(LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
767 LeExtendedAdvertisingResponse report{};
768 report.connectable_ = 1;
769 report.scannable_ = 0;
770 report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;
771 Address::FromString("12:34:56:78:9a:bc", report.address_);
772 std::vector<LengthAndData> adv_data{};
773 LengthAndData data_item{};
774 data_item.data_.push_back(static_cast<uint8_t>(GapDataType::FLAGS));
775 data_item.data_.push_back(0x34);
776 adv_data.push_back(data_item);
777 data_item.data_.push_back(static_cast<uint8_t>(GapDataType::COMPLETE_LOCAL_NAME));
778 for (auto octet : {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'}) {
779 data_item.data_.push_back(octet);
780 }
781 adv_data.push_back(data_item);
782
783 report.advertising_data_ = adv_data;
784
785 EXPECT_CALL(mock_callbacks_, OnScanResult);
786
787 test_hci_layer_->IncomingLeMetaEvent(LeExtendedAdvertisingReportBuilder::Create({report}));
788 }
789
TEST_F(LeScanningManagerExtendedTest,start_scan_on_resume_conflict_test)790 TEST_F(LeScanningManagerExtendedTest, start_scan_on_resume_conflict_test) {
791 TestLeAddressManager* test_le_address_manager =
792 (TestLeAddressManager*)test_acl_manager_->GetLeAddressManager();
793
794 // Enable scan
795 le_scanning_manager->Scan(true);
796 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
797 test_hci_layer_->IncomingEvent(
798 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
799 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
800 test_hci_layer_->IncomingEvent(
801 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
802 sync_client_handler();
803
804 // Pause scan
805 test_le_address_manager->client_->OnPause();
806 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
807 test_hci_layer_->IncomingEvent(
808 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
809
810 // Disable scan
811 le_scanning_manager->Scan(false);
812 test_hci_layer_->AssertNoQueuedCommand();
813
814 // Enable Scan
815 le_scanning_manager->Scan(true);
816 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
817 test_hci_layer_->IncomingEvent(
818 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
819 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
820 test_hci_layer_->IncomingEvent(
821 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
822
823 // Ensure there is no double enable commands on resume
824 test_le_address_manager->client_->OnResume();
825 sync_client_handler();
826 test_hci_layer_->AssertNoQueuedCommand();
827 }
828
TEST_F(LeScanningManagerExtendedTest,on_pause_on_resume_test)829 TEST_F(LeScanningManagerExtendedTest, on_pause_on_resume_test) {
830 TestLeAddressManager* test_le_address_manager =
831 (TestLeAddressManager*)test_acl_manager_->GetLeAddressManager();
832
833 // Enable scan
834 le_scanning_manager->Scan(true);
835 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
836 test_hci_layer_->IncomingEvent(
837 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
838 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
839 test_hci_layer_->IncomingEvent(
840 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
841 sync_client_handler();
842
843 // Pause scan
844 test_le_address_manager->client_->OnPause();
845 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
846 test_hci_layer_->IncomingEvent(
847 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
848
849 // Ensure scan is resumed (enabled)
850 test_le_address_manager->client_->OnResume();
851 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
852 test_hci_layer_->IncomingEvent(
853 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
854 }
855
TEST_F(LeScanningManagerExtendedTest,ignore_on_pause_on_resume_after_unregistered)856 TEST_F(LeScanningManagerExtendedTest, ignore_on_pause_on_resume_after_unregistered) {
857 TestLeAddressManager* test_le_address_manager = (TestLeAddressManager*)test_acl_manager_->GetLeAddressManager();
858 test_le_address_manager->ignore_unregister_for_testing = true;
859
860 // Register LeAddressManager
861 le_scanning_manager->Scan(true);
862 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
863 test_hci_layer_->IncomingEvent(LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
864 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
865 test_hci_layer_->IncomingEvent(LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
866 sync_client_handler();
867
868 // Unregister LeAddressManager
869 le_scanning_manager->Scan(false);
870 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
871 test_hci_layer_->IncomingEvent(LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
872 sync_client_handler();
873
874 // Unregistered client should ignore OnPause/OnResume
875 ASSERT_NE(test_le_address_manager->client_, nullptr);
876 ASSERT_EQ(test_le_address_manager->test_client_state_, TestLeAddressManager::TestClientState::UNREGISTERED);
877 test_le_address_manager->client_->OnPause();
878 ASSERT_EQ(test_le_address_manager->test_client_state_, TestLeAddressManager::TestClientState::UNREGISTERED);
879 test_le_address_manager->client_->OnResume();
880 ASSERT_EQ(test_le_address_manager->test_client_state_, TestLeAddressManager::TestClientState::UNREGISTERED);
881 }
882
TEST_F(LeScanningManagerExtendedTest,drop_insignificant_bytes_test)883 TEST_F(LeScanningManagerExtendedTest, drop_insignificant_bytes_test) {
884 // Enable scan
885 le_scanning_manager->Scan(true);
886 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
887 test_hci_layer_->IncomingEvent(LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
888 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
889 test_hci_layer_->IncomingEvent(LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
890
891 // Prepare advertisement report
892 LeExtendedAdvertisingResponse advertisement_report{};
893 advertisement_report.connectable_ = 1;
894 advertisement_report.scannable_ = 1;
895 advertisement_report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;
896 Address::FromString("12:34:56:78:9a:bc", advertisement_report.address_);
897 std::vector<LengthAndData> adv_data{};
898 LengthAndData flags_data{};
899 flags_data.data_.push_back(static_cast<uint8_t>(GapDataType::FLAGS));
900 flags_data.data_.push_back(0x34);
901 adv_data.push_back(flags_data);
902 LengthAndData name_data{};
903 name_data.data_.push_back(static_cast<uint8_t>(GapDataType::COMPLETE_LOCAL_NAME));
904 for (auto octet : "random device") {
905 name_data.data_.push_back(octet);
906 }
907 adv_data.push_back(name_data);
908 for (int i = 0; i != 5; ++i) {
909 adv_data.push_back({}); // pad with a few insigificant zeros
910 }
911 advertisement_report.advertising_data_ = adv_data;
912
913 // Prepare scan response report
914 auto scan_response_report = advertisement_report;
915 scan_response_report.scan_response_ = true;
916 LengthAndData extra_data{};
917 extra_data.data_.push_back(static_cast<uint8_t>(GapDataType::MANUFACTURER_SPECIFIC_DATA));
918 for (auto octet : "manufacturer specific") {
919 extra_data.data_.push_back(octet);
920 }
921 adv_data = {extra_data};
922 for (int i = 0; i != 5; ++i) {
923 adv_data.push_back({}); // pad with a few insigificant zeros
924 }
925 scan_response_report.advertising_data_ = adv_data;
926
927 // We expect the two reports to be concatenated, excluding the zero-padding
928 auto result = std::vector<uint8_t>();
929 packet::BitInserter it(result);
930 flags_data.Serialize(it);
931 name_data.Serialize(it);
932 extra_data.Serialize(it);
933 EXPECT_CALL(mock_callbacks_, OnScanResult(_, _, _, _, _, _, _, _, _, result));
934
935 // Send both reports
936 test_hci_layer_->IncomingLeMetaEvent(LeExtendedAdvertisingReportBuilder::Create({advertisement_report}));
937 test_hci_layer_->IncomingLeMetaEvent(LeExtendedAdvertisingReportBuilder::Create({scan_response_report}));
938 }
939
940 } // namespace
941 } // namespace hci
942 } // namespace bluetooth
943