1 /*
2 * Copyright (C) 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_, fake_registry_.GetTestHandler());
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 EXPECT_CALL(mock_callbacks_, OnScanResult(extended_event_type, _, _, _, _, _, _, _, _, _));
387
388 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({scan_response}));
389 }
390
TEST_F(LeScanningManagerTest,legacy_adv_ind_report_with_scan_response)391 TEST_F(LeScanningManagerTest, legacy_adv_ind_report_with_scan_response) {
392 start_le_scanning_manager();
393
394 le_scanning_manager->Scan(true);
395 ASSERT_EQ(OpCode::LE_SET_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
396 test_hci_layer_->IncomingEvent(
397 LeSetScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
398 ASSERT_EQ(OpCode::LE_SET_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
399 test_hci_layer_->IncomingEvent(
400 LeSetScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
401
402 LeAdvertisingResponse report = make_advertising_report();
403 // Scannable & connectable!
404 report.event_type_ = AdvertisingEventType::ADV_IND;
405
406 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
407
408 LeAdvertisingResponse scan_response = make_advertising_report();
409 scan_response.event_type_ = AdvertisingEventType::SCAN_RESPONSE;
410
411 uint16_t extended_event_type = kLegacy | kScannable | kConnectable | kScanResponse;
412 EXPECT_CALL(mock_callbacks_, OnScanResult(extended_event_type, _, _, _, _, _, _, _, _, _));
413
414 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({scan_response}));
415 }
416
TEST_F(LeScanningManagerTest,is_ad_type_filter_supported_false_test)417 TEST_F(LeScanningManagerTest, is_ad_type_filter_supported_false_test) {
418 start_le_scanning_manager();
419 ASSERT_TRUE(fake_registry_.IsStarted(&HciLayer::Factory));
420 ASSERT_FALSE(le_scanning_manager->IsAdTypeFilterSupported());
421 }
422
TEST_F(LeScanningManagerTest,scan_filter_add_ad_type_not_supported_test)423 TEST_F(LeScanningManagerTest, scan_filter_add_ad_type_not_supported_test) {
424 start_le_scanning_manager();
425 ASSERT_TRUE(fake_registry_.IsStarted(&HciLayer::Factory));
426
427 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
428 filters.push_back(make_filter(hci::ApcfFilterType::AD_TYPE));
429 le_scanning_manager->ScanFilterAdd(0x01, filters);
430 }
431
TEST_F(LeScanningManagerExtendedTest,is_coded_phy_supported_test)432 TEST_F(LeScanningManagerExtendedTest, is_coded_phy_supported_test) {
433 int scan_phy = 4; // BluetoothDevice.PHY_LE_CODED_MASK
434
435 start_le_scanning_manager();
436 le_scanning_manager->SetScanParameters(LeScanType::ACTIVE, 1, 0x0004, 4800, 1, 0x0004, 4800,
437 scan_phy);
438 le_scanning_manager->Scan(true);
439
440 auto command_view = LeSetExtendedScanParametersView::Create(
441 LeScanningCommandView::Create(test_hci_layer_->GetCommand()));
442 ASSERT_TRUE(command_view.IsValid());
443 if (com::android::bluetooth::flags::phy_to_native()) {
444 ASSERT_EQ(command_view.GetScanningPhys(), scan_phy);
445 ASSERT_EQ(command_view.GetParameters().size(), static_cast<size_t>(1));
446 }
447 }
448
TEST_F(LeScanningManagerExtendedTest,is_multiple_phy_supported_test)449 TEST_F(LeScanningManagerExtendedTest, is_multiple_phy_supported_test) {
450 int scan_phy = 5; // BluetoothDevice.PHY_LE_1M_MASK | BluetoothDevice.PHY_LE_CODED_MASK
451
452 start_le_scanning_manager();
453 le_scanning_manager->SetScanParameters(LeScanType::ACTIVE, 1, 0x0004, 4800, 1, 0x0004, 4800,
454 scan_phy);
455 le_scanning_manager->Scan(true);
456
457 auto command_view = LeSetExtendedScanParametersView::Create(
458 LeScanningCommandView::Create(test_hci_layer_->GetCommand()));
459 ASSERT_TRUE(command_view.IsValid());
460 if (com::android::bluetooth::flags::phy_to_native()) {
461 ASSERT_EQ(command_view.GetScanningPhys(), scan_phy);
462 ASSERT_EQ(command_view.GetParameters().size(), static_cast<size_t>(2));
463 }
464 }
465
TEST_F(LeScanningManagerAndroidHciTest,startup_teardown)466 TEST_F(LeScanningManagerAndroidHciTest, startup_teardown) {}
467
TEST_F(LeScanningManagerAndroidHciTest,start_scan_test)468 TEST_F(LeScanningManagerAndroidHciTest, start_scan_test) {
469 // Enable scan
470 le_scanning_manager->Scan(true);
471 ASSERT_EQ(OpCode::LE_EXTENDED_SCAN_PARAMS, test_hci_layer_->GetCommand().GetOpCode());
472
473 LeAdvertisingResponse report = make_advertising_report();
474
475 EXPECT_CALL(mock_callbacks_, OnScanResult);
476
477 test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
478 }
479
TEST_F(LeScanningManagerAndroidHciTest,is_ad_type_filter_supported_true_test)480 TEST_F(LeScanningManagerAndroidHciTest, is_ad_type_filter_supported_true_test) {
481 sync_client_handler();
482 client_handler_->Post(common::BindOnce(
483 [](LeScanningManager* le_scanning_manager) {
484 ASSERT_TRUE(le_scanning_manager->IsAdTypeFilterSupported());
485 },
486 le_scanning_manager));
487 }
488
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_enable_test)489 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_enable_test) {
490 le_scanning_manager->ScanFilterEnable(true);
491 sync_client_handler();
492
493 EXPECT_CALL(mock_callbacks_, OnFilterEnable);
494 test_hci_layer_->IncomingEvent(LeAdvFilterEnableCompleteBuilder::Create(
495 uint8_t{1}, ErrorCode::SUCCESS, Enable::ENABLED));
496 sync_client_handler();
497 }
498
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_parameter_test)499 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_parameter_test) {
500 AdvertisingFilterParameter advertising_filter_parameter{};
501 advertising_filter_parameter.delivery_mode = DeliveryMode::IMMEDIATE;
502 le_scanning_manager->ScanFilterParameterSetup(ApcfAction::ADD, 0x01,
503 advertising_filter_parameter);
504 auto commandView = test_hci_layer_->GetCommand();
505 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
506 auto filter_command_view = LeAdvFilterSetFilteringParametersView::Create(
507 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
508 ASSERT_TRUE(filter_command_view.IsValid());
509 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::SET_FILTERING_PARAMETERS);
510
511 EXPECT_CALL(mock_callbacks_, OnFilterParamSetup);
512 test_hci_layer_->IncomingEvent(LeAdvFilterSetFilteringParametersCompleteBuilder::Create(
513 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
514 sync_client_handler();
515 }
516
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_broadcaster_address_test)517 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_broadcaster_address_test) {
518 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
519 filters.push_back(make_filter(ApcfFilterType::BROADCASTER_ADDRESS));
520 le_scanning_manager->ScanFilterAdd(0x01, filters);
521 auto commandView = test_hci_layer_->GetCommand();
522 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
523 auto filter_command_view = LeAdvFilterBroadcasterAddressView::Create(
524 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
525 ASSERT_TRUE(filter_command_view.IsValid());
526 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::BROADCASTER_ADDRESS);
527
528 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
529 test_hci_layer_->IncomingEvent(LeAdvFilterBroadcasterAddressCompleteBuilder::Create(
530 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
531 }
532
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_service_uuid_test)533 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_service_uuid_test) {
534 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
535 filters.push_back(make_filter(ApcfFilterType::SERVICE_UUID));
536 le_scanning_manager->ScanFilterAdd(0x01, filters);
537 auto commandView = test_hci_layer_->GetCommand();
538 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
539 auto filter_command_view = LeAdvFilterServiceUuidView::Create(
540 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
541 ASSERT_TRUE(filter_command_view.IsValid());
542 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::SERVICE_UUID);
543
544 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
545 test_hci_layer_->IncomingEvent(LeAdvFilterServiceUuidCompleteBuilder::Create(
546 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
547 }
548
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_local_name_test)549 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_local_name_test) {
550 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
551 filters.push_back(make_filter(ApcfFilterType::LOCAL_NAME));
552 le_scanning_manager->ScanFilterAdd(0x01, filters);
553 auto commandView = test_hci_layer_->GetCommand();
554 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
555 auto filter_command_view = LeAdvFilterLocalNameView::Create(
556 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
557 ASSERT_TRUE(filter_command_view.IsValid());
558 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::LOCAL_NAME);
559
560 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
561 test_hci_layer_->IncomingEvent(LeAdvFilterLocalNameCompleteBuilder::Create(
562 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
563 }
564
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_manufacturer_data_test)565 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_manufacturer_data_test) {
566 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
567 filters.push_back(make_filter(ApcfFilterType::MANUFACTURER_DATA));
568 le_scanning_manager->ScanFilterAdd(0x01, filters);
569 auto commandView = test_hci_layer_->GetCommand();
570 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
571 auto filter_command_view = LeAdvFilterManufacturerDataView::Create(
572 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
573 ASSERT_TRUE(filter_command_view.IsValid());
574 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::MANUFACTURER_DATA);
575
576 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
577 test_hci_layer_->IncomingEvent(LeAdvFilterManufacturerDataCompleteBuilder::Create(
578 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
579 }
580
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_service_data_test)581 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_service_data_test) {
582 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
583 filters.push_back(make_filter(hci::ApcfFilterType::SERVICE_DATA));
584 le_scanning_manager->ScanFilterAdd(0x01, filters);
585 auto commandView = test_hci_layer_->GetCommand();
586 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
587 auto filter_command_view = LeAdvFilterServiceDataView::Create(
588 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
589 ASSERT_TRUE(filter_command_view.IsValid());
590 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::SERVICE_DATA);
591
592 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
593 test_hci_layer_->IncomingEvent(LeAdvFilterServiceDataCompleteBuilder::Create(
594 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
595 }
596
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_transport_discovery_data_test)597 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_transport_discovery_data_test) {
598 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
599 filters.push_back(make_filter(hci::ApcfFilterType::TRANSPORT_DISCOVERY_DATA));
600 le_scanning_manager->ScanFilterAdd(0x01, filters);
601 auto commandView = test_hci_layer_->GetCommand();
602 ASSERT_EQ(OpCode::LE_ADV_FILTER, commandView.GetOpCode());
603 auto filter_command_view = LeAdvFilterTransportDiscoveryDataView::Create(
604 LeAdvFilterView::Create(LeScanningCommandView::Create(commandView)));
605
606 ASSERT_TRUE(filter_command_view.IsValid());
607 ASSERT_EQ(filter_command_view.GetApcfOpcode(), ApcfOpcode::TRANSPORT_DISCOVERY_DATA);
608
609 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
610 test_hci_layer_->IncomingEvent(LeAdvFilterTransportDiscoveryDataCompleteBuilder::Create(
611 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
612 }
613
TEST_F(LeScanningManagerAndroidHciTest,scan_filter_add_ad_type_test)614 TEST_F(LeScanningManagerAndroidHciTest, scan_filter_add_ad_type_test) {
615 sync_client_handler();
616 client_handler_->Post(common::BindOnce(
617 [](LeScanningManager* le_scanning_manager) {
618 ASSERT_TRUE(le_scanning_manager->IsAdTypeFilterSupported());
619 },
620 le_scanning_manager));
621
622 std::vector<AdvertisingPacketContentFilterCommand> filters = {};
623 hci::AdvertisingPacketContentFilterCommand filter = make_filter(hci::ApcfFilterType::AD_TYPE);
624 filters.push_back(filter);
625 le_scanning_manager->ScanFilterAdd(0x01, filters);
626 sync_client_handler();
627
628 EXPECT_CALL(mock_callbacks_, OnFilterConfigCallback);
629 test_hci_layer_->IncomingEvent(LeAdvFilterADTypeCompleteBuilder::Create(
630 uint8_t{1}, ErrorCode::SUCCESS, ApcfAction::ADD, 0x0a));
631 }
632
TEST_F(LeScanningManagerAndroidHciTest,read_batch_scan_result)633 TEST_F(LeScanningManagerAndroidHciTest, read_batch_scan_result) {
634 le_scanning_manager->BatchScanConifgStorage(100, 0, 95, 0x00);
635 sync_client_handler();
636 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
637 test_hci_layer_->IncomingEvent(
638 LeBatchScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
639 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
640 test_hci_layer_->IncomingEvent(
641 LeBatchScanSetStorageParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
642
643 // Enable batch scan
644
645 le_scanning_manager->BatchScanEnable(BatchScanMode::FULL, 2400, 2400,
646 BatchScanDiscardRule::OLDEST);
647 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
648 test_hci_layer_->IncomingEvent(
649 LeBatchScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
650
651 // Read batch scan data
652
653 le_scanning_manager->BatchScanReadReport(0x01, BatchScanMode::FULL);
654 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
655
656 // We will send read command while num_of_record != 0
657 std::vector<uint8_t> raw_data = {0x5c, 0x1f, 0xa2, 0xc3, 0x63, 0x5d, 0x01, 0xf5, 0xb3,
658 0x5e, 0x00, 0x0c, 0x02, 0x01, 0x02, 0x05, 0x09, 0x6d,
659 0x76, 0x38, 0x76, 0x02, 0x0a, 0xf5, 0x00};
660
661 test_hci_layer_->IncomingEvent(LeBatchScanReadResultParametersCompleteRawBuilder::Create(
662 uint8_t{1}, ErrorCode::SUCCESS, BatchScanDataRead::FULL_MODE_DATA, 1, raw_data));
663 ASSERT_EQ(OpCode::LE_BATCH_SCAN, test_hci_layer_->GetCommand().GetOpCode());
664
665 // OnBatchScanReports will be trigger when num_of_record == 0
666 EXPECT_CALL(mock_callbacks_, OnBatchScanReports);
667 test_hci_layer_->IncomingEvent(LeBatchScanReadResultParametersCompleteRawBuilder::Create(
668 uint8_t{1}, ErrorCode::SUCCESS, BatchScanDataRead::FULL_MODE_DATA, 0, {}));
669 }
670
TEST_F(LeScanningManagerAndroidHciTest,start_sync_test)671 TEST_F(LeScanningManagerAndroidHciTest, start_sync_test) {
672 Address address;
673 const uint16_t handle = 0x0001;
674 const uint16_t service_data = 0x0000;
675 const uint16_t sync_handle = 0x0002;
676 const int pa_source = 3;
677
678 Address::FromString("12:34:56:78:9a:bc", address);
679
680 le_scanning_manager->TransferSync(address, handle, service_data, sync_handle, pa_source);
681 sync_client_handler();
682
683 ASSERT_EQ(OpCode::LE_PERIODIC_ADVERTISING_SYNC_TRANSFER,
684 test_hci_layer_->GetCommand().GetOpCode());
685 }
686
TEST_F(LeScanningManagerAndroidHciTest,start_sync_invalid_handle_test)687 TEST_F(LeScanningManagerAndroidHciTest, start_sync_invalid_handle_test) {
688 Address address;
689 const uint16_t handle = 0xFFFF;
690 const uint16_t service_data = 0x0000;
691 const uint16_t sync_handle = 0x0002;
692 const int pa_source = 3;
693
694 Address::FromString("12:34:56:78:9a:bc", address);
695
696 EXPECT_CALL(mock_callbacks_,
697 OnPeriodicSyncTransferred(pa_source, static_cast<int>(ErrorCode::UNKNOWN_CONNECTION),
698 address));
699 le_scanning_manager->TransferSync(address, handle, service_data, sync_handle, pa_source);
700 sync_client_handler();
701 }
702
TEST_F(LeScanningManagerAndroidHciTest,set_info_test)703 TEST_F(LeScanningManagerAndroidHciTest, set_info_test) {
704 Address address;
705 const uint16_t handle = 0x0001;
706 const uint16_t service_data = 0x0000;
707 const uint16_t sync_handle = 0x0002;
708 const int pa_source = 3;
709
710 Address::FromString("12:34:56:78:9a:bc", address);
711
712 le_scanning_manager->TransferSetInfo(address, handle, service_data, sync_handle, pa_source);
713 sync_client_handler();
714
715 ASSERT_EQ(OpCode::LE_PERIODIC_ADVERTISING_SET_INFO_TRANSFER,
716 test_hci_layer_->GetCommand().GetOpCode());
717 }
718
TEST_F(LeScanningManagerAndroidHciTest,set_info_invalid_handle_test)719 TEST_F(LeScanningManagerAndroidHciTest, set_info_invalid_handle_test) {
720 Address address;
721 const uint16_t handle = 0xFFFF;
722 const uint16_t service_data = 0x0000;
723 const uint16_t sync_handle = 0x0002;
724 const int pa_source = 3;
725
726 Address::FromString("12:34:56:78:9a:bc", address);
727
728 EXPECT_CALL(mock_callbacks_,
729 OnPeriodicSyncTransferred(pa_source, static_cast<int>(ErrorCode::UNKNOWN_CONNECTION),
730 address));
731 le_scanning_manager->TransferSetInfo(address, handle, service_data, sync_handle, pa_source);
732 sync_client_handler();
733 }
734
TEST_F(LeScanningManagerExtendedTest,startup_teardown)735 TEST_F(LeScanningManagerExtendedTest, startup_teardown) {}
736
TEST_F(LeScanningManagerExtendedTest,start_scan_test)737 TEST_F(LeScanningManagerExtendedTest, start_scan_test) {
738 // Enable scan
739 le_scanning_manager->Scan(true);
740 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
741 test_hci_layer_->IncomingEvent(
742 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
743 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
744 test_hci_layer_->IncomingEvent(
745 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
746 LeExtendedAdvertisingResponse report{};
747 report.connectable_ = 1;
748 report.scannable_ = 0;
749 report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;
750 Address::FromString("12:34:56:78:9a:bc", report.address_);
751 std::vector<LengthAndData> adv_data{};
752 LengthAndData data_item{};
753 data_item.data_.push_back(static_cast<uint8_t>(GapDataType::FLAGS));
754 data_item.data_.push_back(0x34);
755 adv_data.push_back(data_item);
756 data_item.data_.push_back(static_cast<uint8_t>(GapDataType::COMPLETE_LOCAL_NAME));
757 for (auto octet : {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'}) {
758 data_item.data_.push_back(octet);
759 }
760 adv_data.push_back(data_item);
761
762 report.advertising_data_ = adv_data;
763
764 EXPECT_CALL(mock_callbacks_, OnScanResult);
765
766 test_hci_layer_->IncomingLeMetaEvent(LeExtendedAdvertisingReportBuilder::Create({report}));
767 }
768
TEST_F(LeScanningManagerExtendedTest,start_scan_on_resume_conflict_test)769 TEST_F(LeScanningManagerExtendedTest, start_scan_on_resume_conflict_test) {
770 TestLeAddressManager* test_le_address_manager =
771 (TestLeAddressManager*)test_acl_manager_->GetLeAddressManager();
772
773 // Enable scan
774 le_scanning_manager->Scan(true);
775 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
776 test_hci_layer_->IncomingEvent(
777 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
778 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
779 test_hci_layer_->IncomingEvent(
780 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
781 sync_client_handler();
782
783 // Pause scan
784 test_le_address_manager->client_->OnPause();
785 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
786 test_hci_layer_->IncomingEvent(
787 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
788
789 // Disable scan
790 le_scanning_manager->Scan(false);
791 test_hci_layer_->AssertNoQueuedCommand();
792
793 // Enable Scan
794 le_scanning_manager->Scan(true);
795 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
796 test_hci_layer_->IncomingEvent(
797 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
798 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
799 test_hci_layer_->IncomingEvent(
800 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
801
802 // Ensure there is no double enable commands on resume
803 test_le_address_manager->client_->OnResume();
804 sync_client_handler();
805 test_hci_layer_->AssertNoQueuedCommand();
806 }
807
TEST_F(LeScanningManagerExtendedTest,on_pause_on_resume_test)808 TEST_F(LeScanningManagerExtendedTest, on_pause_on_resume_test) {
809 TestLeAddressManager* test_le_address_manager =
810 (TestLeAddressManager*)test_acl_manager_->GetLeAddressManager();
811
812 // Enable scan
813 le_scanning_manager->Scan(true);
814 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
815 test_hci_layer_->IncomingEvent(
816 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
817 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
818 test_hci_layer_->IncomingEvent(
819 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
820 sync_client_handler();
821
822 // Pause scan
823 test_le_address_manager->client_->OnPause();
824 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
825 test_hci_layer_->IncomingEvent(
826 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
827
828 // Ensure scan is resumed (enabled)
829 test_le_address_manager->client_->OnResume();
830 if (com::android::bluetooth::flags::configure_scan_on_resume()) {
831 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
832 test_hci_layer_->IncomingEvent(
833 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
834 }
835 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
836 test_hci_layer_->IncomingEvent(
837 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
838 }
839
TEST_F(LeScanningManagerExtendedTest,ignore_on_pause_on_resume_after_unregistered)840 TEST_F(LeScanningManagerExtendedTest, ignore_on_pause_on_resume_after_unregistered) {
841 TestLeAddressManager* test_le_address_manager =
842 (TestLeAddressManager*)test_acl_manager_->GetLeAddressManager();
843 test_le_address_manager->ignore_unregister_for_testing = true;
844
845 // Register LeAddressManager
846 le_scanning_manager->Scan(true);
847 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
848 test_hci_layer_->IncomingEvent(
849 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
850 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
851 test_hci_layer_->IncomingEvent(
852 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
853 sync_client_handler();
854
855 // Unregister LeAddressManager
856 le_scanning_manager->Scan(false);
857 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
858 test_hci_layer_->IncomingEvent(
859 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
860 sync_client_handler();
861
862 // Unregistered client should ignore OnPause/OnResume
863 ASSERT_NE(test_le_address_manager->client_, nullptr);
864 ASSERT_EQ(test_le_address_manager->test_client_state_,
865 TestLeAddressManager::TestClientState::UNREGISTERED);
866 test_le_address_manager->client_->OnPause();
867 ASSERT_EQ(test_le_address_manager->test_client_state_,
868 TestLeAddressManager::TestClientState::UNREGISTERED);
869 test_le_address_manager->client_->OnResume();
870 ASSERT_EQ(test_le_address_manager->test_client_state_,
871 TestLeAddressManager::TestClientState::UNREGISTERED);
872 }
873
TEST_F(LeScanningManagerExtendedTest,drop_insignificant_bytes_test)874 TEST_F(LeScanningManagerExtendedTest, drop_insignificant_bytes_test) {
875 // Enable scan
876 le_scanning_manager->Scan(true);
877 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_PARAMETERS, test_hci_layer_->GetCommand().GetOpCode());
878 test_hci_layer_->IncomingEvent(
879 LeSetExtendedScanParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
880 ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
881 test_hci_layer_->IncomingEvent(
882 LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
883
884 // Prepare advertisement report
885 LeExtendedAdvertisingResponse advertisement_report{};
886 advertisement_report.connectable_ = 1;
887 advertisement_report.scannable_ = 1;
888 advertisement_report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;
889 Address::FromString("12:34:56:78:9a:bc", advertisement_report.address_);
890 std::vector<LengthAndData> adv_data{};
891 LengthAndData flags_data{};
892 flags_data.data_.push_back(static_cast<uint8_t>(GapDataType::FLAGS));
893 flags_data.data_.push_back(0x34);
894 adv_data.push_back(flags_data);
895 LengthAndData name_data{};
896 name_data.data_.push_back(static_cast<uint8_t>(GapDataType::COMPLETE_LOCAL_NAME));
897 for (auto octet : "random device") {
898 name_data.data_.push_back(octet);
899 }
900 adv_data.push_back(name_data);
901 for (int i = 0; i != 5; ++i) {
902 adv_data.push_back({}); // pad with a few insigificant zeros
903 }
904 advertisement_report.advertising_data_ = adv_data;
905
906 // Prepare scan response report
907 auto scan_response_report = advertisement_report;
908 scan_response_report.scan_response_ = true;
909 LengthAndData extra_data{};
910 extra_data.data_.push_back(static_cast<uint8_t>(GapDataType::MANUFACTURER_SPECIFIC_DATA));
911 for (auto octet : "manufacturer specific") {
912 extra_data.data_.push_back(octet);
913 }
914 adv_data = {extra_data};
915 for (int i = 0; i != 5; ++i) {
916 adv_data.push_back({}); // pad with a few insigificant zeros
917 }
918 scan_response_report.advertising_data_ = adv_data;
919
920 // We expect the two reports to be concatenated, excluding the zero-padding
921 auto result = std::vector<uint8_t>();
922 packet::BitInserter it(result);
923 flags_data.Serialize(it);
924 name_data.Serialize(it);
925 extra_data.Serialize(it);
926 EXPECT_CALL(mock_callbacks_, OnScanResult(_, _, _, _, _, _, _, _, _, result));
927
928 // Send both reports
929 test_hci_layer_->IncomingLeMetaEvent(
930 LeExtendedAdvertisingReportBuilder::Create({advertisement_report}));
931 test_hci_layer_->IncomingLeMetaEvent(
932 LeExtendedAdvertisingReportBuilder::Create({scan_response_report}));
933 }
934
935 } // namespace
936 } // namespace hci
937 } // namespace bluetooth
938