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