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_advertising_manager.h"
18 
19 #include <algorithm>
20 #include <chrono>
21 #include <future>
22 #include <map>
23 
24 #include <gmock/gmock.h>
25 #include <gtest/gtest.h>
26 
27 #include "common/bind.h"
28 #include "hci/acl_manager.h"
29 #include "hci/address.h"
30 #include "hci/controller.h"
31 #include "hci/hci_layer.h"
32 #include "os/thread.h"
33 #include "packet/raw_builder.h"
34 
35 namespace bluetooth {
36 namespace hci {
37 namespace {
38 
39 using packet::kLittleEndian;
40 using packet::PacketView;
41 using packet::RawBuilder;
42 
GetPacketView(std::unique_ptr<packet::BasePacketBuilder> packet)43 PacketView<kLittleEndian> GetPacketView(std::unique_ptr<packet::BasePacketBuilder> packet) {
44   auto bytes = std::make_shared<std::vector<uint8_t>>();
45   BitInserter i(*bytes);
46   bytes->reserve(packet->size());
47   packet->Serialize(i);
48   return packet::PacketView<packet::kLittleEndian>(bytes);
49 }
50 
51 class TestController : public Controller {
52  public:
IsSupported(OpCode op_code) const53   bool IsSupported(OpCode op_code) const override {
54     return supported_opcodes_.count(op_code) == 1;
55   }
56 
AddSupported(OpCode op_code)57   void AddSupported(OpCode op_code) {
58     supported_opcodes_.insert(op_code);
59   }
60 
GetLeNumberOfSupportedAdverisingSets() const61   uint8_t GetLeNumberOfSupportedAdverisingSets() const override {
62     return num_advertisers;
63   }
64 
GetLeMaximumAdvertisingDataLength() const65   uint16_t GetLeMaximumAdvertisingDataLength() const override {
66     return 0x0672;
67   }
68 
69   uint8_t num_advertisers{0};
70 
71  protected:
Start()72   void Start() override {}
Stop()73   void Stop() override {}
ListDependencies(ModuleList * list)74   void ListDependencies(ModuleList* list) override {}
75 
76  private:
77   std::set<OpCode> supported_opcodes_{};
78 };
79 
80 class TestHciLayer : public HciLayer {
81  public:
EnqueueCommand(std::unique_ptr<CommandBuilder> command,common::ContextualOnceCallback<void (CommandStatusView)> on_status)82   void EnqueueCommand(
83       std::unique_ptr<CommandBuilder> command,
84       common::ContextualOnceCallback<void(CommandStatusView)> on_status) override {
85     auto packet_view = CommandView::Create(GetPacketView(std::move(command)));
86     ASSERT_TRUE(packet_view.IsValid());
87     std::lock_guard<std::mutex> lock(mutex_);
88     command_queue_.push_back(packet_view);
89     command_status_callbacks.push_back(std::move(on_status));
90     if (command_promise_ != nullptr &&
91         (command_op_code_ == OpCode::NONE || command_op_code_ == packet_view.GetOpCode())) {
92       if (command_op_code_ == OpCode::LE_MULTI_ADVT && command_sub_ocf_ != SubOcf::SET_ENABLE) {
93         return;
94       }
95       command_promise_->set_value(command_queue_.size());
96       command_promise_.reset();
97     }
98   }
99 
EnqueueCommand(std::unique_ptr<CommandBuilder> command,common::ContextualOnceCallback<void (CommandCompleteView)> on_complete)100   void EnqueueCommand(
101       std::unique_ptr<CommandBuilder> command,
102       common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) override {
103     auto packet_view = CommandView::Create(GetPacketView(std::move(command)));
104     ASSERT_TRUE(packet_view.IsValid());
105     std::lock_guard<std::mutex> lock(mutex_);
106     command_queue_.push_back(packet_view);
107     command_complete_callbacks.push_back(std::move(on_complete));
108     if (command_promise_ != nullptr &&
109         (command_op_code_ == OpCode::NONE || command_op_code_ == packet_view.GetOpCode())) {
110       if (command_op_code_ == OpCode::LE_MULTI_ADVT) {
111         auto sub_view = LeMultiAdvtView::Create(LeAdvertisingCommandView::Create(packet_view));
112         ASSERT_TRUE(sub_view.IsValid());
113         if (sub_view.GetSubCmd() != command_sub_ocf_) {
114           return;
115         }
116       }
117       command_promise_->set_value(command_queue_.size());
118       command_promise_.reset();
119     }
120   }
121 
SetCommandFuture(OpCode op_code=OpCode::NONE)122   void SetCommandFuture(OpCode op_code = OpCode::NONE) {
123     ASSERT_LOG(command_promise_ == nullptr, "Promises, Promises, ... Only one at a time.");
124     command_op_code_ = op_code;
125     command_promise_ = std::make_unique<std::promise<size_t>>();
126     command_future_ = std::make_unique<std::future<size_t>>(command_promise_->get_future());
127   }
128 
ResetCommandFuture()129   void ResetCommandFuture() {
130     if (command_future_ != nullptr) {
131       command_future_.reset();
132       command_promise_.reset();
133     }
134   }
135 
SetSubCommandFuture(SubOcf sub_ocf)136   void SetSubCommandFuture(SubOcf sub_ocf) {
137     ASSERT_LOG(command_promise_ == nullptr, "Promises promises ... Only one at a time");
138     command_op_code_ = OpCode::LE_MULTI_ADVT;
139     command_sub_ocf_ = sub_ocf;
140     command_promise_ = std::make_unique<std::promise<size_t>>();
141     command_future_ = std::make_unique<std::future<size_t>>(command_promise_->get_future());
142   }
143 
GetCommand(OpCode op_code)144   ConnectionManagementCommandView GetCommand(OpCode op_code) {
145     if (!command_queue_.empty()) {
146       std::lock_guard<std::mutex> lock(mutex_);
147       if (command_future_ != nullptr) {
148         command_future_.reset();
149         command_promise_.reset();
150       }
151     } else if (command_future_ != nullptr) {
152       auto result = command_future_->wait_for(std::chrono::milliseconds(1000));
153       EXPECT_NE(std::future_status::timeout, result);
154     }
155     ASSERT_LOG(
156         !command_queue_.empty(), "Expecting command %s but command queue was empty", OpCodeText(op_code).c_str());
157     std::lock_guard<std::mutex> lock(mutex_);
158     CommandView command_packet_view = CommandView::Create(command_queue_.front());
159     command_queue_.pop_front();
160     auto command = ConnectionManagementCommandView::Create(AclCommandView::Create(command_packet_view));
161     EXPECT_TRUE(command.IsValid());
162     EXPECT_EQ(command.GetOpCode(), op_code);
163 
164     return command;
165   }
166 
RegisterEventHandler(EventCode event_code,common::ContextualCallback<void (EventView)> event_handler)167   void RegisterEventHandler(EventCode event_code, common::ContextualCallback<void(EventView)> event_handler) override {
168     registered_events_[event_code] = event_handler;
169   }
170 
RegisterLeEventHandler(SubeventCode subevent_code,common::ContextualCallback<void (LeMetaEventView)> event_handler)171   void RegisterLeEventHandler(SubeventCode subevent_code,
172                               common::ContextualCallback<void(LeMetaEventView)> event_handler) override {
173     registered_le_events_[subevent_code] = event_handler;
174   }
175 
IncomingEvent(std::unique_ptr<EventBuilder> event_builder)176   void IncomingEvent(std::unique_ptr<EventBuilder> event_builder) {
177     auto packet = GetPacketView(std::move(event_builder));
178     EventView event = EventView::Create(packet);
179     ASSERT_TRUE(event.IsValid());
180     EventCode event_code = event.GetEventCode();
181     ASSERT_NE(registered_events_.find(event_code), registered_events_.end()) << EventCodeText(event_code);
182     registered_events_[event_code].Invoke(event);
183   }
184 
IncomingLeMetaEvent(std::unique_ptr<LeMetaEventBuilder> event_builder)185   void IncomingLeMetaEvent(std::unique_ptr<LeMetaEventBuilder> event_builder) {
186     auto packet = GetPacketView(std::move(event_builder));
187     EventView event = EventView::Create(packet);
188     LeMetaEventView meta_event_view = LeMetaEventView::Create(event);
189     ASSERT_TRUE(meta_event_view.IsValid());
190     SubeventCode subevent_code = meta_event_view.GetSubeventCode();
191     ASSERT_NE(registered_le_events_.find(subevent_code), registered_le_events_.end())
192         << SubeventCodeText(subevent_code);
193     registered_le_events_[subevent_code].Invoke(meta_event_view);
194   }
195 
CommandCompleteCallback(EventView event)196   void CommandCompleteCallback(EventView event) {
197     CommandCompleteView complete_view = CommandCompleteView::Create(event);
198     ASSERT_TRUE(complete_view.IsValid());
199     std::move(command_complete_callbacks.front()).Invoke(complete_view);
200     command_complete_callbacks.pop_front();
201   }
202 
CommandStatusCallback(EventView event)203   void CommandStatusCallback(EventView event) {
204     CommandStatusView status_view = CommandStatusView::Create(event);
205     ASSERT_TRUE(status_view.IsValid());
206     std::move(command_status_callbacks.front()).Invoke(status_view);
207     command_status_callbacks.pop_front();
208   }
209 
ListDependencies(ModuleList * list)210   void ListDependencies(ModuleList* list) override {}
Start()211   void Start() override {
212     RegisterEventHandler(EventCode::COMMAND_COMPLETE,
213                          GetHandler()->BindOn(this, &TestHciLayer::CommandCompleteCallback));
214     RegisterEventHandler(EventCode::COMMAND_STATUS, GetHandler()->BindOn(this, &TestHciLayer::CommandStatusCallback));
215   }
Stop()216   void Stop() override {}
217 
218  private:
219   std::map<EventCode, common::ContextualCallback<void(EventView)>> registered_events_;
220   std::map<SubeventCode, common::ContextualCallback<void(LeMetaEventView)>> registered_le_events_;
221   std::list<common::ContextualOnceCallback<void(CommandCompleteView)>> command_complete_callbacks;
222   std::list<common::ContextualOnceCallback<void(CommandStatusView)>> command_status_callbacks;
223 
224   std::list<CommandView> command_queue_;
225   mutable std::mutex mutex_;
226   std::unique_ptr<std::promise<size_t>> command_promise_{};
227   std::unique_ptr<std::future<size_t>> command_future_{};
228   OpCode command_op_code_;
229   SubOcf command_sub_ocf_;
230 };
231 
232 class TestLeAddressManager : public LeAddressManager {
233  public:
TestLeAddressManager(common::Callback<void (std::unique_ptr<CommandBuilder>)> enqueue_command,os::Handler * handler,Address public_address,uint8_t connect_list_size,uint8_t resolving_list_size)234   TestLeAddressManager(
235       common::Callback<void(std::unique_ptr<CommandBuilder>)> enqueue_command,
236       os::Handler* handler,
237       Address public_address,
238       uint8_t connect_list_size,
239       uint8_t resolving_list_size)
240       : LeAddressManager(enqueue_command, handler, public_address, connect_list_size, resolving_list_size) {}
241 
Register(LeAddressManagerCallback * callback)242   AddressPolicy Register(LeAddressManagerCallback* callback) override {
243     return AddressPolicy::USE_STATIC_ADDRESS;
244   }
245 
Unregister(LeAddressManagerCallback * callback)246   void Unregister(LeAddressManagerCallback* callback) override {}
247 
GetAnotherAddress()248   AddressWithType GetAnotherAddress() override {
249     hci::Address address;
250     Address::FromString("05:04:03:02:01:00", address);
251     auto random_address = AddressWithType(address, AddressType::RANDOM_DEVICE_ADDRESS);
252     return random_address;
253   }
254 };
255 
256 class TestAclManager : public AclManager {
257  public:
GetLeAddressManager()258   LeAddressManager* GetLeAddressManager() override {
259     return test_le_address_manager_;
260   }
261 
262  protected:
Start()263   void Start() override {
264     thread_ = new os::Thread("thread", os::Thread::Priority::NORMAL);
265     handler_ = new os::Handler(thread_);
266     Address address({0x01, 0x02, 0x03, 0x04, 0x05, 0x06});
267     test_le_address_manager_ = new TestLeAddressManager(
268         common::Bind(&TestAclManager::enqueue_command, common::Unretained(this)), handler_, address, 0x3F, 0x3F);
269   }
270 
Stop()271   void Stop() override {
272     delete test_le_address_manager_;
273     handler_->Clear();
274     delete handler_;
275     delete thread_;
276   }
277 
ListDependencies(ModuleList * list)278   void ListDependencies(ModuleList* list) override {}
279 
SetRandomAddress(Address address)280   void SetRandomAddress(Address address) {}
281 
enqueue_command(std::unique_ptr<CommandBuilder> command_packet)282   void enqueue_command(std::unique_ptr<CommandBuilder> command_packet){};
283 
284   os::Thread* thread_;
285   os::Handler* handler_;
286   TestLeAddressManager* test_le_address_manager_;
287 };
288 
289 class LeAdvertisingManagerTest : public ::testing::Test {
290  protected:
SetUp()291   void SetUp() override {
292     test_hci_layer_ = new TestHciLayer;  // Ownership is transferred to registry
293     test_controller_ = new TestController;
294     test_acl_manager_ = new TestAclManager;
295     test_controller_->AddSupported(param_opcode_);
296     fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);
297     fake_registry_.InjectTestModule(&Controller::Factory, test_controller_);
298     fake_registry_.InjectTestModule(&AclManager::Factory, test_acl_manager_);
299     client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
300     ASSERT_NE(client_handler_, nullptr);
301     test_controller_->num_advertisers = 1;
302     le_advertising_manager_ = fake_registry_.Start<LeAdvertisingManager>(&thread_);
303     le_advertising_manager_->RegisterAdvertisingCallback(&mock_advertising_callback_);
304   }
305 
TearDown()306   void TearDown() override {
307     fake_registry_.SynchronizeModuleHandler(&LeAdvertisingManager::Factory, std::chrono::milliseconds(20));
308     fake_registry_.StopAll();
309   }
310 
311   TestModuleRegistry fake_registry_;
312   TestHciLayer* test_hci_layer_ = nullptr;
313   TestController* test_controller_ = nullptr;
314   TestAclManager* test_acl_manager_ = nullptr;
315   os::Thread& thread_ = fake_registry_.GetTestThread();
316   LeAdvertisingManager* le_advertising_manager_ = nullptr;
317   os::Handler* client_handler_ = nullptr;
318 
319   const common::Callback<void(Address, AddressType)> scan_callback =
320       common::Bind(&LeAdvertisingManagerTest::on_scan, common::Unretained(this));
321   const common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback =
322       common::Bind(&LeAdvertisingManagerTest::on_set_terminated, common::Unretained(this));
323 
GetOnScanPromise()324   std::future<Address> GetOnScanPromise() {
325     ASSERT_LOG(address_promise_ == nullptr, "Promises promises ... Only one at a time");
326     address_promise_ = std::make_unique<std::promise<Address>>();
327     return address_promise_->get_future();
328   }
on_scan(Address address,AddressType address_type)329   void on_scan(Address address, AddressType address_type) {
330     if (address_promise_ == nullptr) {
331       return;
332     }
333     address_promise_->set_value(address);
334     address_promise_.reset();
335   }
336 
GetSetTerminatedPromise()337   std::future<ErrorCode> GetSetTerminatedPromise() {
338     ASSERT_LOG(set_terminated_promise_ == nullptr, "Promises promises ... Only one at a time");
339     set_terminated_promise_ = std::make_unique<std::promise<ErrorCode>>();
340     return set_terminated_promise_->get_future();
341   }
on_set_terminated(ErrorCode error_code,uint8_t,uint8_t)342   void on_set_terminated(ErrorCode error_code, uint8_t, uint8_t) {
343     if (set_terminated_promise_ != nullptr) {
344       return;
345     }
346     set_terminated_promise_->set_value(error_code);
347     set_terminated_promise_.reset();
348   }
349 
sync_client_handler()350   void sync_client_handler() {
351     std::promise<void> promise;
352     auto future = promise.get_future();
353     client_handler_->Call(common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));
354     auto future_status = future.wait_for(std::chrono::seconds(1));
355     ASSERT_EQ(future_status, std::future_status::ready);
356   }
357 
358   std::unique_ptr<std::promise<Address>> address_promise_{};
359   std::unique_ptr<std::promise<ErrorCode>> set_terminated_promise_{};
360 
361   OpCode param_opcode_{OpCode::LE_SET_ADVERTISING_PARAMETERS};
362 
363   class MockAdvertisingCallback : public AdvertisingCallback {
364    public:
365     MOCK_METHOD4(
366         OnAdvertisingSetStarted, void(int reg_id, uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status));
367     MOCK_METHOD3(OnAdvertisingEnabled, void(uint8_t advertiser_id, bool enable, uint8_t status));
368     MOCK_METHOD2(OnAdvertisingDataSet, void(uint8_t advertiser_id, uint8_t status));
369     MOCK_METHOD2(OnScanResponseDataSet, void(uint8_t advertiser_id, uint8_t status));
370     MOCK_METHOD3(OnAdvertisingParametersUpdated, void(uint8_t advertiser_id, int8_t tx_power, uint8_t status));
371     MOCK_METHOD2(OnPeriodicAdvertisingParametersUpdated, void(uint8_t advertiser_id, uint8_t status));
372     MOCK_METHOD2(OnPeriodicAdvertisingDataSet, void(uint8_t advertiser_id, uint8_t status));
373     MOCK_METHOD3(OnPeriodicAdvertisingEnabled, void(uint8_t advertiser_id, bool enable, uint8_t status));
374   } mock_advertising_callback_;
375 };
376 
377 class LeAdvertisingAPITest : public LeAdvertisingManagerTest {
378  protected:
SetUp()379   void SetUp() override {
380     LeAdvertisingManagerTest::SetUp();
381 
382     // start advertising set
383     ExtendedAdvertisingConfig advertising_config{};
384     advertising_config.advertising_type = AdvertisingType::ADV_IND;
385     advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
386     std::vector<GapData> gap_data{};
387     GapData data_item{};
388     data_item.data_type_ = GapDataType::FLAGS;
389     data_item.data_ = {0x34};
390     gap_data.push_back(data_item);
391     data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
392     data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
393     gap_data.push_back(data_item);
394     advertising_config.advertisement = gap_data;
395     advertising_config.scan_response = gap_data;
396 
397     test_hci_layer_->SetCommandFuture();
398     advertiser_id_ = le_advertising_manager_->ExtendedCreateAdvertiser(
399         0x00, advertising_config, scan_callback, set_terminated_callback, 0, 0, client_handler_);
400     ASSERT_NE(LeAdvertisingManager::kInvalidId, advertiser_id_);
401     EXPECT_CALL(
402         mock_advertising_callback_,
403         OnAdvertisingSetStarted(0x00, advertiser_id_, 0x00, AdvertisingCallback::AdvertisingStatus::SUCCESS));
404     std::vector<OpCode> adv_opcodes = {
405         OpCode::LE_READ_ADVERTISING_PHYSICAL_CHANNEL_TX_POWER,
406         OpCode::LE_SET_ADVERTISING_PARAMETERS,
407         OpCode::LE_SET_SCAN_RESPONSE_DATA,
408         OpCode::LE_SET_ADVERTISING_DATA,
409         OpCode::LE_SET_ADVERTISING_ENABLE,
410     };
411     std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};
412     for (size_t i = 0; i < adv_opcodes.size(); i++) {
413       auto packet_view = test_hci_layer_->GetCommand(adv_opcodes[i]);
414       CommandView command_packet_view = CommandView::Create(packet_view);
415       if (adv_opcodes[i] == OpCode::LE_READ_ADVERTISING_PHYSICAL_CHANNEL_TX_POWER) {
416         test_hci_layer_->IncomingEvent(
417             LeReadAdvertisingPhysicalChannelTxPowerCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, 0x00));
418       } else {
419         test_hci_layer_->IncomingEvent(
420             CommandCompleteBuilder::Create(uint8_t{1}, adv_opcodes[i], std::make_unique<RawBuilder>(success_vector)));
421       }
422       test_hci_layer_->SetCommandFuture();
423     }
424     sync_client_handler();
425     test_hci_layer_->ResetCommandFuture();
426   }
427 
428   AdvertiserId advertiser_id_;
429 };
430 
431 class LeAndroidHciAdvertisingManagerTest : public LeAdvertisingManagerTest {
432  protected:
SetUp()433   void SetUp() override {
434     param_opcode_ = OpCode::LE_MULTI_ADVT;
435     LeAdvertisingManagerTest::SetUp();
436     test_controller_->num_advertisers = 3;
437   }
438 };
439 
440 class LeAndroidHciAdvertisingAPITest : public LeAndroidHciAdvertisingManagerTest {
441  protected:
SetUp()442   void SetUp() override {
443     LeAndroidHciAdvertisingManagerTest::SetUp();
444 
445     ExtendedAdvertisingConfig advertising_config{};
446     advertising_config.advertising_type = AdvertisingType::ADV_IND;
447     advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
448     std::vector<GapData> gap_data{};
449     GapData data_item{};
450     data_item.data_type_ = GapDataType::FLAGS;
451     data_item.data_ = {0x34};
452     gap_data.push_back(data_item);
453     data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
454     data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
455     gap_data.push_back(data_item);
456     advertising_config.advertisement = gap_data;
457     advertising_config.scan_response = gap_data;
458 
459     test_hci_layer_->SetSubCommandFuture(SubOcf::SET_PARAM);
460     advertiser_id_ = le_advertising_manager_->ExtendedCreateAdvertiser(
461         0x00, advertising_config, scan_callback, set_terminated_callback, 0, 0, client_handler_);
462     ASSERT_NE(LeAdvertisingManager::kInvalidId, advertiser_id_);
463     std::vector<SubOcf> sub_ocf = {
464         SubOcf::SET_PARAM,
465         SubOcf::SET_DATA,
466         SubOcf::SET_SCAN_RESP,
467         SubOcf::SET_RANDOM_ADDR,
468         SubOcf::SET_ENABLE,
469     };
470     EXPECT_CALL(
471         mock_advertising_callback_,
472         OnAdvertisingSetStarted(0, advertiser_id_, 0, AdvertisingCallback::AdvertisingStatus::SUCCESS));
473     for (size_t i = 0; i < sub_ocf.size(); i++) {
474       auto packet = test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
475       auto sub_packet = LeMultiAdvtView::Create(LeAdvertisingCommandView::Create(packet));
476       ASSERT_TRUE(sub_packet.IsValid());
477       test_hci_layer_->IncomingEvent(LeMultiAdvtCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, sub_ocf[i]));
478       if ((i + 1) < sub_ocf.size()) {
479         test_hci_layer_->SetSubCommandFuture(sub_ocf[i + 1]);
480       }
481     }
482     sync_client_handler();
483   }
484 
485   AdvertiserId advertiser_id_;
486 };
487 
488 class LeExtendedAdvertisingManagerTest : public LeAdvertisingManagerTest {
489  protected:
SetUp()490   void SetUp() override {
491     param_opcode_ = OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS;
492     LeAdvertisingManagerTest::SetUp();
493     test_controller_->num_advertisers = 5;
494   }
495 };
496 
497 class LeExtendedAdvertisingAPITest : public LeExtendedAdvertisingManagerTest {
498  protected:
SetUp()499   void SetUp() override {
500     LeExtendedAdvertisingManagerTest::SetUp();
501 
502     // start advertising set
503     ExtendedAdvertisingConfig advertising_config{};
504     advertising_config.advertising_type = AdvertisingType::ADV_IND;
505     advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
506     std::vector<GapData> gap_data{};
507     GapData data_item{};
508     data_item.data_type_ = GapDataType::FLAGS;
509     data_item.data_ = {0x34};
510     gap_data.push_back(data_item);
511     data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
512     data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
513     gap_data.push_back(data_item);
514     advertising_config.advertisement = gap_data;
515     advertising_config.scan_response = gap_data;
516     advertising_config.channel_map = 1;
517     advertising_config.sid = 0x01;
518 
519     test_hci_layer_->SetCommandFuture();
520     advertiser_id_ = le_advertising_manager_->ExtendedCreateAdvertiser(
521         0x00, advertising_config, scan_callback, set_terminated_callback, 0, 0, client_handler_);
522     ASSERT_NE(LeAdvertisingManager::kInvalidId, advertiser_id_);
523     EXPECT_CALL(
524         mock_advertising_callback_,
525         OnAdvertisingSetStarted(0x00, advertiser_id_, -23, AdvertisingCallback::AdvertisingStatus::SUCCESS));
526     std::vector<OpCode> adv_opcodes = {
527         OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS,
528         OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE,
529         OpCode::LE_SET_EXTENDED_ADVERTISING_DATA,
530         OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE,
531     };
532     std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};
533     for (size_t i = 0; i < adv_opcodes.size(); i++) {
534       auto packet_view = test_hci_layer_->GetCommand(adv_opcodes[i]);
535       CommandView command_packet_view = CommandView::Create(packet_view);
536       auto command = ConnectionManagementCommandView::Create(AclCommandView::Create(command_packet_view));
537       if (adv_opcodes[i] == OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS) {
538         test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingParametersCompleteBuilder::Create(
539             uint8_t{1}, ErrorCode::SUCCESS, static_cast<uint8_t>(-23)));
540       } else {
541         test_hci_layer_->IncomingEvent(
542             CommandCompleteBuilder::Create(uint8_t{1}, adv_opcodes[i], std::make_unique<RawBuilder>(success_vector)));
543       }
544       test_hci_layer_->SetCommandFuture();
545     }
546     sync_client_handler();
547     test_hci_layer_->ResetCommandFuture();
548   }
549 
550   AdvertiserId advertiser_id_;
551 };
552 
TEST_F(LeAdvertisingManagerTest,startup_teardown)553 TEST_F(LeAdvertisingManagerTest, startup_teardown) {}
554 
TEST_F(LeAndroidHciAdvertisingManagerTest,startup_teardown)555 TEST_F(LeAndroidHciAdvertisingManagerTest, startup_teardown) {}
556 
TEST_F(LeExtendedAdvertisingManagerTest,startup_teardown)557 TEST_F(LeExtendedAdvertisingManagerTest, startup_teardown) {}
558 
TEST_F(LeAdvertisingManagerTest,create_advertiser_test)559 TEST_F(LeAdvertisingManagerTest, create_advertiser_test) {
560   ExtendedAdvertisingConfig advertising_config{};
561   advertising_config.advertising_type = AdvertisingType::ADV_IND;
562   advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
563   std::vector<GapData> gap_data{};
564   GapData data_item{};
565   data_item.data_type_ = GapDataType::FLAGS;
566   data_item.data_ = {0x34};
567   gap_data.push_back(data_item);
568   data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
569   data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
570   gap_data.push_back(data_item);
571   advertising_config.advertisement = gap_data;
572   advertising_config.scan_response = gap_data;
573 
574   test_hci_layer_->SetCommandFuture();
575   auto id = le_advertising_manager_->ExtendedCreateAdvertiser(
576       0x00, advertising_config, scan_callback, set_terminated_callback, 0, 0, client_handler_);
577   ASSERT_NE(LeAdvertisingManager::kInvalidId, id);
578   std::vector<OpCode> adv_opcodes = {
579       OpCode::LE_READ_ADVERTISING_PHYSICAL_CHANNEL_TX_POWER,
580       OpCode::LE_SET_ADVERTISING_PARAMETERS,
581       OpCode::LE_SET_SCAN_RESPONSE_DATA,
582       OpCode::LE_SET_ADVERTISING_DATA,
583       OpCode::LE_SET_ADVERTISING_ENABLE,
584   };
585   EXPECT_CALL(
586       mock_advertising_callback_,
587       OnAdvertisingSetStarted(0x00, id, 0x00, AdvertisingCallback::AdvertisingStatus::SUCCESS));
588   std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};
589   for (size_t i = 0; i < adv_opcodes.size(); i++) {
590     auto packet_view = test_hci_layer_->GetCommand(adv_opcodes[i]);
591     CommandView command_packet_view = CommandView::Create(packet_view);
592     auto command = ConnectionManagementCommandView::Create(AclCommandView::Create(command_packet_view));
593     if (adv_opcodes[i] == OpCode::LE_READ_ADVERTISING_PHYSICAL_CHANNEL_TX_POWER) {
594       test_hci_layer_->IncomingEvent(
595           LeReadAdvertisingPhysicalChannelTxPowerCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, 0x00));
596     } else {
597       test_hci_layer_->IncomingEvent(
598           CommandCompleteBuilder::Create(uint8_t{1}, adv_opcodes[i], std::make_unique<RawBuilder>(success_vector)));
599     }
600     test_hci_layer_->SetCommandFuture();
601   }
602   sync_client_handler();
603 
604   // Disable the advertiser
605   le_advertising_manager_->RemoveAdvertiser(id);
606   test_hci_layer_->GetCommand(OpCode::LE_SET_ADVERTISING_ENABLE);
607   sync_client_handler();
608 }
609 
TEST_F(LeAndroidHciAdvertisingManagerTest,create_advertiser_test)610 TEST_F(LeAndroidHciAdvertisingManagerTest, create_advertiser_test) {
611   ExtendedAdvertisingConfig advertising_config{};
612   advertising_config.advertising_type = AdvertisingType::ADV_IND;
613   advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
614   std::vector<GapData> gap_data{};
615   GapData data_item{};
616   data_item.data_type_ = GapDataType::FLAGS;
617   data_item.data_ = {0x34};
618   gap_data.push_back(data_item);
619   data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
620   data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
621   gap_data.push_back(data_item);
622   advertising_config.advertisement = gap_data;
623   advertising_config.scan_response = gap_data;
624 
625   test_hci_layer_->SetSubCommandFuture(SubOcf::SET_PARAM);
626   auto id = le_advertising_manager_->ExtendedCreateAdvertiser(
627       0x00, advertising_config, scan_callback, set_terminated_callback, 0, 0, client_handler_);
628   ASSERT_NE(LeAdvertisingManager::kInvalidId, id);
629   std::vector<SubOcf> sub_ocf = {
630       SubOcf::SET_PARAM, SubOcf::SET_DATA, SubOcf::SET_SCAN_RESP, SubOcf::SET_RANDOM_ADDR, SubOcf::SET_ENABLE,
631   };
632   EXPECT_CALL(
633       mock_advertising_callback_, OnAdvertisingSetStarted(0, id, 0, AdvertisingCallback::AdvertisingStatus::SUCCESS));
634   for (size_t i = 0; i < sub_ocf.size(); i++) {
635     auto packet = test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
636     auto sub_packet = LeMultiAdvtView::Create(LeAdvertisingCommandView::Create(packet));
637     ASSERT_TRUE(sub_packet.IsValid());
638     test_hci_layer_->IncomingEvent(LeMultiAdvtCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, sub_ocf[i]));
639     if ((i + 1) < sub_ocf.size()) {
640       test_hci_layer_->SetSubCommandFuture(sub_ocf[i + 1]);
641     }
642   }
643   sync_client_handler();
644 
645   // Disable the advertiser
646   test_hci_layer_->SetSubCommandFuture(SubOcf::SET_ENABLE);
647   le_advertising_manager_->RemoveAdvertiser(id);
648   test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
649   test_hci_layer_->IncomingEvent(LeMultiAdvtSetEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
650   sync_client_handler();
651 }
652 
TEST_F(LeExtendedAdvertisingManagerTest,create_advertiser_test)653 TEST_F(LeExtendedAdvertisingManagerTest, create_advertiser_test) {
654   ExtendedAdvertisingConfig advertising_config{};
655   advertising_config.advertising_type = AdvertisingType::ADV_IND;
656   advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
657   std::vector<GapData> gap_data{};
658   GapData data_item{};
659   data_item.data_type_ = GapDataType::FLAGS;
660   data_item.data_ = {0x34};
661   gap_data.push_back(data_item);
662   data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
663   data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
664   gap_data.push_back(data_item);
665   advertising_config.advertisement = gap_data;
666   advertising_config.scan_response = gap_data;
667   advertising_config.channel_map = 1;
668   advertising_config.sid = 0x01;
669 
670   test_hci_layer_->SetCommandFuture();
671   auto id = le_advertising_manager_->ExtendedCreateAdvertiser(
672       0x00, advertising_config, scan_callback, set_terminated_callback, 0, 0, client_handler_);
673   ASSERT_NE(LeAdvertisingManager::kInvalidId, id);
674   EXPECT_CALL(
675       mock_advertising_callback_,
676       OnAdvertisingSetStarted(0x00, id, -23, AdvertisingCallback::AdvertisingStatus::SUCCESS));
677   std::vector<OpCode> adv_opcodes = {
678       OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS,
679       OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE,
680       OpCode::LE_SET_EXTENDED_ADVERTISING_DATA,
681       OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE,
682   };
683   std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};
684   for (size_t i = 0; i < adv_opcodes.size(); i++) {
685     auto packet_view = test_hci_layer_->GetCommand(adv_opcodes[i]);
686     CommandView command_packet_view = CommandView::Create(packet_view);
687     auto command = ConnectionManagementCommandView::Create(AclCommandView::Create(command_packet_view));
688     if (adv_opcodes[i] == OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS) {
689       test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingParametersCompleteBuilder::Create(
690           uint8_t{1}, ErrorCode::SUCCESS, static_cast<uint8_t>(-23)));
691     } else {
692       test_hci_layer_->IncomingEvent(
693           CommandCompleteBuilder::Create(uint8_t{1}, adv_opcodes[i], std::make_unique<RawBuilder>(success_vector)));
694     }
695     test_hci_layer_->SetCommandFuture();
696   }
697   sync_client_handler();
698 
699   // Remove the advertiser
700   le_advertising_manager_->RemoveAdvertiser(id);
701   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE);
702   test_hci_layer_->SetCommandFuture();
703   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_ENABLE);
704   test_hci_layer_->SetCommandFuture();
705   test_hci_layer_->GetCommand(OpCode::LE_REMOVE_ADVERTISING_SET);
706   sync_client_handler();
707 }
708 
TEST_F(LeAdvertisingAPITest,startup_teardown)709 TEST_F(LeAdvertisingAPITest, startup_teardown) {}
710 
TEST_F(LeAndroidHciAdvertisingAPITest,startup_teardown)711 TEST_F(LeAndroidHciAdvertisingAPITest, startup_teardown) {}
712 
TEST_F(LeExtendedAdvertisingAPITest,startup_teardown)713 TEST_F(LeExtendedAdvertisingAPITest, startup_teardown) {}
714 
TEST_F(LeAdvertisingAPITest,set_parameter)715 TEST_F(LeAdvertisingAPITest, set_parameter) {
716   ExtendedAdvertisingConfig advertising_config{};
717   advertising_config.advertising_type = AdvertisingType::ADV_IND;
718   advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
719   std::vector<GapData> gap_data{};
720   GapData data_item{};
721   data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
722   data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
723   gap_data.push_back(data_item);
724   advertising_config.advertisement = gap_data;
725   advertising_config.channel_map = 1;
726   test_hci_layer_->SetCommandFuture();
727   le_advertising_manager_->SetParameters(advertiser_id_, advertising_config);
728   test_hci_layer_->GetCommand(OpCode::LE_SET_ADVERTISING_PARAMETERS);
729   EXPECT_CALL(
730       mock_advertising_callback_,
731       OnAdvertisingParametersUpdated(advertiser_id_, 0x00, AdvertisingCallback::AdvertisingStatus::SUCCESS));
732   test_hci_layer_->IncomingEvent(LeSetAdvertisingParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
733   sync_client_handler();
734 }
735 
TEST_F(LeAndroidHciAdvertisingAPITest,set_parameter)736 TEST_F(LeAndroidHciAdvertisingAPITest, set_parameter) {
737   ExtendedAdvertisingConfig advertising_config{};
738   advertising_config.advertising_type = AdvertisingType::ADV_IND;
739   advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
740   std::vector<GapData> gap_data{};
741   GapData data_item{};
742   data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
743   data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
744   gap_data.push_back(data_item);
745   advertising_config.advertisement = gap_data;
746   advertising_config.channel_map = 1;
747   test_hci_layer_->SetSubCommandFuture(SubOcf::SET_PARAM);
748   le_advertising_manager_->SetParameters(advertiser_id_, advertising_config);
749   test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
750   EXPECT_CALL(
751       mock_advertising_callback_,
752       OnAdvertisingParametersUpdated(advertiser_id_, 0x00, AdvertisingCallback::AdvertisingStatus::SUCCESS));
753   test_hci_layer_->IncomingEvent(LeMultiAdvtCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, SubOcf::SET_PARAM));
754   sync_client_handler();
755 }
756 
TEST_F(LeExtendedAdvertisingAPITest,set_parameter)757 TEST_F(LeExtendedAdvertisingAPITest, set_parameter) {
758   ExtendedAdvertisingConfig advertising_config{};
759   advertising_config.advertising_type = AdvertisingType::ADV_IND;
760   advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
761   std::vector<GapData> gap_data{};
762   GapData data_item{};
763   data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
764   data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
765   gap_data.push_back(data_item);
766   advertising_config.advertisement = gap_data;
767   advertising_config.channel_map = 1;
768   advertising_config.sid = 0x01;
769   advertising_config.tx_power = 0x08;
770   test_hci_layer_->SetCommandFuture();
771   le_advertising_manager_->SetParameters(advertiser_id_, advertising_config);
772   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_PARAMETERS);
773   EXPECT_CALL(
774       mock_advertising_callback_,
775       OnAdvertisingParametersUpdated(advertiser_id_, 0x08, AdvertisingCallback::AdvertisingStatus::SUCCESS));
776   test_hci_layer_->IncomingEvent(
777       LeSetExtendedAdvertisingParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, 0x08));
778   sync_client_handler();
779 }
780 
TEST_F(LeAdvertisingAPITest,set_data_test)781 TEST_F(LeAdvertisingAPITest, set_data_test) {
782   // Set advertising data
783   std::vector<GapData> advertising_data{};
784   GapData data_item{};
785   data_item.data_type_ = GapDataType::TX_POWER_LEVEL;
786   data_item.data_ = {0x00};
787   advertising_data.push_back(data_item);
788   test_hci_layer_->SetCommandFuture();
789   le_advertising_manager_->SetData(advertiser_id_, false, advertising_data);
790   test_hci_layer_->GetCommand(OpCode::LE_SET_ADVERTISING_DATA);
791   EXPECT_CALL(
792       mock_advertising_callback_,
793       OnAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
794   test_hci_layer_->IncomingEvent(LeSetAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
795   sync_client_handler();
796 
797   // Set scan response data
798   std::vector<GapData> response_data{};
799   GapData data_item2{};
800   data_item2.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
801   data_item2.data_ = {'t', 'e', 's', 't', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
802   response_data.push_back(data_item2);
803   test_hci_layer_->SetCommandFuture();
804   le_advertising_manager_->SetData(advertiser_id_, true, response_data);
805   test_hci_layer_->GetCommand(OpCode::LE_SET_SCAN_RESPONSE_DATA);
806   EXPECT_CALL(
807       mock_advertising_callback_,
808       OnScanResponseDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
809   test_hci_layer_->IncomingEvent(LeSetScanResponseDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
810   sync_client_handler();
811 }
812 
TEST_F(LeExtendedAdvertisingAPITest,set_data_test)813 TEST_F(LeExtendedAdvertisingAPITest, set_data_test) {
814   // Set advertising data
815   std::vector<GapData> advertising_data{};
816   GapData data_item{};
817   data_item.data_type_ = GapDataType::TX_POWER_LEVEL;
818   data_item.data_ = {0x00};
819   advertising_data.push_back(data_item);
820   test_hci_layer_->SetCommandFuture();
821   le_advertising_manager_->SetData(advertiser_id_, false, advertising_data);
822   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_DATA);
823   EXPECT_CALL(
824       mock_advertising_callback_,
825       OnAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
826   test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
827   sync_client_handler();
828 
829   // Set scan response data
830   std::vector<GapData> response_data{};
831   GapData data_item2{};
832   data_item2.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
833   data_item2.data_ = {'t', 'e', 's', 't', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
834   response_data.push_back(data_item2);
835   test_hci_layer_->SetCommandFuture();
836   le_advertising_manager_->SetData(advertiser_id_, true, response_data);
837   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE);
838   EXPECT_CALL(
839       mock_advertising_callback_,
840       OnScanResponseDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
841   test_hci_layer_->IncomingEvent(
842       LeSetExtendedAdvertisingScanResponseCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
843   sync_client_handler();
844 }
845 
TEST_F(LeAndroidHciAdvertisingAPITest,set_data_test)846 TEST_F(LeAndroidHciAdvertisingAPITest, set_data_test) {
847   // Set advertising data
848   std::vector<GapData> advertising_data{};
849   GapData data_item{};
850   data_item.data_type_ = GapDataType::TX_POWER_LEVEL;
851   data_item.data_ = {0x00};
852   advertising_data.push_back(data_item);
853   test_hci_layer_->SetSubCommandFuture(SubOcf::SET_DATA);
854   le_advertising_manager_->SetData(advertiser_id_, false, advertising_data);
855   test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
856   EXPECT_CALL(
857       mock_advertising_callback_,
858       OnAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
859   test_hci_layer_->IncomingEvent(LeMultiAdvtCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, SubOcf::SET_DATA));
860   sync_client_handler();
861 
862   // Set scan response data
863   std::vector<GapData> response_data{};
864   GapData data_item2{};
865   data_item2.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
866   data_item2.data_ = {'t', 'e', 's', 't', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
867   response_data.push_back(data_item2);
868   test_hci_layer_->SetSubCommandFuture(SubOcf::SET_SCAN_RESP);
869   le_advertising_manager_->SetData(advertiser_id_, true, response_data);
870   test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
871   EXPECT_CALL(
872       mock_advertising_callback_,
873       OnScanResponseDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
874   test_hci_layer_->IncomingEvent(
875       LeMultiAdvtCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, SubOcf::SET_SCAN_RESP));
876   sync_client_handler();
877 }
878 
TEST_F(LeExtendedAdvertisingAPITest,set_data_fragments_test)879 TEST_F(LeExtendedAdvertisingAPITest, set_data_fragments_test) {
880   // Set advertising data
881   std::vector<GapData> advertising_data{};
882   for (uint8_t i = 0; i < 3; i++) {
883     GapData data_item{};
884     data_item.data_.push_back(0xda);
885     data_item.data_type_ = GapDataType::SERVICE_DATA_128_BIT_UUIDS;
886     uint8_t uuid[16] = {0xf0, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, i};
887     std::copy_n(uuid, 16, std::back_inserter(data_item.data_));
888     uint8_t service_data[200];
889     std::copy_n(service_data, 200, std::back_inserter(data_item.data_));
890     advertising_data.push_back(data_item);
891   }
892   le_advertising_manager_->SetData(advertiser_id_, false, advertising_data);
893 
894   // First fragment
895   test_hci_layer_->SetCommandFuture();
896   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_DATA);
897 
898   // Intermediate fragment
899   test_hci_layer_->SetCommandFuture();
900   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_DATA);
901 
902   // Last fragment
903   test_hci_layer_->SetCommandFuture();
904   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_DATA);
905 
906   EXPECT_CALL(
907       mock_advertising_callback_,
908       OnAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
909   test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
910   test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
911   test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
912 
913   sync_client_handler();
914 }
915 
TEST_F(LeExtendedAdvertisingAPITest,set_scan_response_fragments_test)916 TEST_F(LeExtendedAdvertisingAPITest, set_scan_response_fragments_test) {
917   // Set advertising data
918   std::vector<GapData> advertising_data{};
919   for (uint8_t i = 0; i < 3; i++) {
920     GapData data_item{};
921     data_item.data_.push_back(0xfa);
922     data_item.data_type_ = GapDataType::SERVICE_DATA_128_BIT_UUIDS;
923     uint8_t uuid[16] = {0xf0, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, i};
924     std::copy_n(uuid, 16, std::back_inserter(data_item.data_));
925     uint8_t service_data[232];
926     std::copy_n(service_data, 232, std::back_inserter(data_item.data_));
927     advertising_data.push_back(data_item);
928   }
929   le_advertising_manager_->SetData(advertiser_id_, true, advertising_data);
930 
931   // First fragment
932   test_hci_layer_->SetCommandFuture();
933   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE);
934 
935   // Intermediate fragment
936   test_hci_layer_->SetCommandFuture();
937   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE);
938 
939   // Last fragment
940   test_hci_layer_->SetCommandFuture();
941   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE);
942 
943   EXPECT_CALL(
944       mock_advertising_callback_,
945       OnScanResponseDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
946   test_hci_layer_->IncomingEvent(
947       LeSetExtendedAdvertisingScanResponseCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
948   test_hci_layer_->IncomingEvent(
949       LeSetExtendedAdvertisingScanResponseCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
950   test_hci_layer_->IncomingEvent(
951       LeSetExtendedAdvertisingScanResponseCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
952 
953   sync_client_handler();
954 }
955 
TEST_F(LeExtendedAdvertisingAPITest,set_data_with_invalid_ad_structure)956 TEST_F(LeExtendedAdvertisingAPITest, set_data_with_invalid_ad_structure) {
957   // Set advertising data with AD structure that length greater than 251
958   std::vector<GapData> advertising_data{};
959   GapData data_item{};
960   data_item.data_.push_back(0xfb);
961   data_item.data_type_ = GapDataType::SERVICE_DATA_128_BIT_UUIDS;
962   uint8_t uuid[16] = {0xf0, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00};
963   std::copy_n(uuid, 16, std::back_inserter(data_item.data_));
964   uint8_t service_data[233];
965   std::copy_n(service_data, 233, std::back_inserter(data_item.data_));
966   advertising_data.push_back(data_item);
967 
968   EXPECT_CALL(
969       mock_advertising_callback_,
970       OnAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR));
971 
972   le_advertising_manager_->SetData(advertiser_id_, false, advertising_data);
973 
974   EXPECT_CALL(
975       mock_advertising_callback_,
976       OnScanResponseDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR));
977   le_advertising_manager_->SetData(advertiser_id_, true, advertising_data);
978 
979   sync_client_handler();
980 }
981 
TEST_F(LeExtendedAdvertisingAPITest,set_data_with_invalid_length)982 TEST_F(LeExtendedAdvertisingAPITest, set_data_with_invalid_length) {
983   // Set advertising data with data that greater than le_maximum_advertising_data_length_
984   std::vector<GapData> advertising_data{};
985   for (uint8_t i = 0; i < 10; i++) {
986     GapData data_item{};
987     data_item.data_.push_back(0xfb);
988     data_item.data_type_ = GapDataType::SERVICE_DATA_128_BIT_UUIDS;
989     uint8_t uuid[16] = {0xf0, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, i};
990     std::copy_n(uuid, 16, std::back_inserter(data_item.data_));
991     uint8_t service_data[200];
992     std::copy_n(service_data, 200, std::back_inserter(data_item.data_));
993     advertising_data.push_back(data_item);
994   }
995 
996   EXPECT_CALL(
997       mock_advertising_callback_,
998       OnAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::DATA_TOO_LARGE));
999   le_advertising_manager_->SetData(advertiser_id_, false, advertising_data);
1000 
1001   EXPECT_CALL(
1002       mock_advertising_callback_,
1003       OnScanResponseDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::DATA_TOO_LARGE));
1004   le_advertising_manager_->SetData(advertiser_id_, true, advertising_data);
1005 
1006   sync_client_handler();
1007 }
1008 
TEST_F(LeAdvertisingAPITest,disable_enable_advertiser_test)1009 TEST_F(LeAdvertisingAPITest, disable_enable_advertiser_test) {
1010   // disable advertiser
1011   test_hci_layer_->SetCommandFuture();
1012   le_advertising_manager_->EnableAdvertiser(advertiser_id_, false, 0x00, 0x00);
1013   test_hci_layer_->GetCommand(OpCode::LE_SET_ADVERTISING_ENABLE);
1014   EXPECT_CALL(
1015       mock_advertising_callback_,
1016       OnAdvertisingEnabled(advertiser_id_, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1017   test_hci_layer_->IncomingEvent(LeSetAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1018   sync_client_handler();
1019 
1020   // enable advertiser
1021   test_hci_layer_->SetCommandFuture();
1022   le_advertising_manager_->EnableAdvertiser(advertiser_id_, true, 0x00, 0x00);
1023   test_hci_layer_->GetCommand(OpCode::LE_SET_ADVERTISING_ENABLE);
1024   EXPECT_CALL(
1025       mock_advertising_callback_,
1026       OnAdvertisingEnabled(advertiser_id_, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1027   test_hci_layer_->IncomingEvent(LeSetAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1028   sync_client_handler();
1029 }
1030 
TEST_F(LeAndroidHciAdvertisingAPITest,disable_enable_advertiser_test)1031 TEST_F(LeAndroidHciAdvertisingAPITest, disable_enable_advertiser_test) {
1032   // disable advertiser
1033   test_hci_layer_->SetSubCommandFuture(SubOcf::SET_ENABLE);
1034   le_advertising_manager_->EnableAdvertiser(advertiser_id_, false, 0x00, 0x00);
1035   test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
1036   EXPECT_CALL(
1037       mock_advertising_callback_,
1038       OnAdvertisingEnabled(advertiser_id_, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1039   test_hci_layer_->IncomingEvent(
1040       LeMultiAdvtCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, SubOcf::SET_ENABLE));
1041   sync_client_handler();
1042 
1043   // enable advertiser
1044   test_hci_layer_->SetSubCommandFuture(SubOcf::SET_ENABLE);
1045   le_advertising_manager_->EnableAdvertiser(advertiser_id_, true, 0x00, 0x00);
1046   test_hci_layer_->GetCommand(OpCode::LE_MULTI_ADVT);
1047   EXPECT_CALL(
1048       mock_advertising_callback_,
1049       OnAdvertisingEnabled(advertiser_id_, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1050   test_hci_layer_->IncomingEvent(
1051       LeMultiAdvtCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS, SubOcf::SET_ENABLE));
1052   sync_client_handler();
1053 }
1054 
TEST_F(LeExtendedAdvertisingAPITest,disable_enable_advertiser_test)1055 TEST_F(LeExtendedAdvertisingAPITest, disable_enable_advertiser_test) {
1056   // disable advertiser
1057   test_hci_layer_->SetCommandFuture();
1058   le_advertising_manager_->EnableAdvertiser(advertiser_id_, false, 0x00, 0x00);
1059   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE);
1060   EXPECT_CALL(
1061       mock_advertising_callback_,
1062       OnAdvertisingEnabled(advertiser_id_, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1063   test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1064   sync_client_handler();
1065 
1066   // enable advertiser
1067   test_hci_layer_->SetCommandFuture();
1068   le_advertising_manager_->EnableAdvertiser(advertiser_id_, true, 0x00, 0x00);
1069   test_hci_layer_->GetCommand(OpCode::LE_SET_EXTENDED_ADVERTISING_ENABLE);
1070   EXPECT_CALL(
1071       mock_advertising_callback_,
1072       OnAdvertisingEnabled(advertiser_id_, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1073   test_hci_layer_->IncomingEvent(LeSetExtendedAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1074   sync_client_handler();
1075 }
1076 
TEST_F(LeExtendedAdvertisingAPITest,set_periodic_parameter)1077 TEST_F(LeExtendedAdvertisingAPITest, set_periodic_parameter) {
1078   PeriodicAdvertisingParameters advertising_config{};
1079   advertising_config.max_interval = 0x1000;
1080   advertising_config.min_interval = 0x0006;
1081   test_hci_layer_->SetCommandFuture();
1082   le_advertising_manager_->SetPeriodicParameters(advertiser_id_, advertising_config);
1083   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_PARAM);
1084   EXPECT_CALL(
1085       mock_advertising_callback_,
1086       OnPeriodicAdvertisingParametersUpdated(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1087   test_hci_layer_->IncomingEvent(LeSetPeriodicAdvertisingParamCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1088   sync_client_handler();
1089 }
1090 
TEST_F(LeExtendedAdvertisingAPITest,set_periodic_data_test)1091 TEST_F(LeExtendedAdvertisingAPITest, set_periodic_data_test) {
1092   // Set advertising data
1093   std::vector<GapData> advertising_data{};
1094   GapData data_item{};
1095   data_item.data_type_ = GapDataType::TX_POWER_LEVEL;
1096   data_item.data_ = {0x00};
1097   advertising_data.push_back(data_item);
1098   test_hci_layer_->SetCommandFuture();
1099   le_advertising_manager_->SetPeriodicData(advertiser_id_, advertising_data);
1100   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_DATA);
1101   EXPECT_CALL(
1102       mock_advertising_callback_,
1103       OnPeriodicAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1104   test_hci_layer_->IncomingEvent(LeSetPeriodicAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1105   sync_client_handler();
1106 }
1107 
TEST_F(LeExtendedAdvertisingAPITest,set_periodic_data_fragments_test)1108 TEST_F(LeExtendedAdvertisingAPITest, set_periodic_data_fragments_test) {
1109   // Set advertising data
1110   std::vector<GapData> advertising_data{};
1111   for (uint8_t i = 0; i < 3; i++) {
1112     GapData data_item{};
1113     data_item.data_.push_back(0xfa);
1114     data_item.data_type_ = GapDataType::SERVICE_DATA_128_BIT_UUIDS;
1115     uint8_t uuid[16] = {0xf0, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, i};
1116     std::copy_n(uuid, 16, std::back_inserter(data_item.data_));
1117     uint8_t service_data[232];
1118     std::copy_n(service_data, 232, std::back_inserter(data_item.data_));
1119     advertising_data.push_back(data_item);
1120   }
1121   le_advertising_manager_->SetPeriodicData(advertiser_id_, advertising_data);
1122 
1123   // First fragment
1124   test_hci_layer_->SetCommandFuture();
1125   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_DATA);
1126 
1127   // Intermediate fragment
1128   test_hci_layer_->SetCommandFuture();
1129   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_DATA);
1130 
1131   // Last fragment
1132   test_hci_layer_->SetCommandFuture();
1133   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_DATA);
1134 
1135   EXPECT_CALL(
1136       mock_advertising_callback_,
1137       OnPeriodicAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1138   test_hci_layer_->IncomingEvent(LeSetPeriodicAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1139   test_hci_layer_->IncomingEvent(LeSetPeriodicAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1140   test_hci_layer_->IncomingEvent(LeSetPeriodicAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1141 
1142   sync_client_handler();
1143 }
1144 
TEST_F(LeExtendedAdvertisingAPITest,set_perodic_data_with_invalid_ad_structure)1145 TEST_F(LeExtendedAdvertisingAPITest, set_perodic_data_with_invalid_ad_structure) {
1146   // Set advertising data with AD structure that length greater than 251
1147   std::vector<GapData> advertising_data{};
1148   GapData data_item{};
1149   data_item.data_.push_back(0xfb);
1150   data_item.data_type_ = GapDataType::SERVICE_DATA_128_BIT_UUIDS;
1151   uint8_t uuid[16] = {0xf0, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00};
1152   std::copy_n(uuid, 16, std::back_inserter(data_item.data_));
1153   uint8_t service_data[233];
1154   std::copy_n(service_data, 233, std::back_inserter(data_item.data_));
1155   advertising_data.push_back(data_item);
1156 
1157   EXPECT_CALL(
1158       mock_advertising_callback_,
1159       OnPeriodicAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR));
1160 
1161   le_advertising_manager_->SetPeriodicData(advertiser_id_, advertising_data);
1162 
1163   sync_client_handler();
1164 }
1165 
TEST_F(LeExtendedAdvertisingAPITest,set_perodic_data_with_invalid_length)1166 TEST_F(LeExtendedAdvertisingAPITest, set_perodic_data_with_invalid_length) {
1167   // Set advertising data with data that greater than le_maximum_advertising_data_length_
1168   std::vector<GapData> advertising_data{};
1169   for (uint8_t i = 0; i < 10; i++) {
1170     GapData data_item{};
1171     data_item.data_.push_back(0xfb);
1172     data_item.data_type_ = GapDataType::SERVICE_DATA_128_BIT_UUIDS;
1173     uint8_t uuid[16] = {0xf0, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, i};
1174     std::copy_n(uuid, 16, std::back_inserter(data_item.data_));
1175     uint8_t service_data[200];
1176     std::copy_n(service_data, 200, std::back_inserter(data_item.data_));
1177     advertising_data.push_back(data_item);
1178   }
1179 
1180   EXPECT_CALL(
1181       mock_advertising_callback_,
1182       OnPeriodicAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::DATA_TOO_LARGE));
1183   le_advertising_manager_->SetPeriodicData(advertiser_id_, advertising_data);
1184 
1185   sync_client_handler();
1186 }
1187 
TEST_F(LeExtendedAdvertisingAPITest,disable_enable_periodic_advertiser_test)1188 TEST_F(LeExtendedAdvertisingAPITest, disable_enable_periodic_advertiser_test) {
1189   // disable advertiser
1190   test_hci_layer_->SetCommandFuture();
1191   le_advertising_manager_->EnablePeriodicAdvertising(advertiser_id_, false);
1192   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_ENABLE);
1193   EXPECT_CALL(
1194       mock_advertising_callback_,
1195       OnPeriodicAdvertisingEnabled(advertiser_id_, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1196   test_hci_layer_->IncomingEvent(LeSetPeriodicAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1197   sync_client_handler();
1198 
1199   // enable advertiser
1200   test_hci_layer_->SetCommandFuture();
1201   le_advertising_manager_->EnablePeriodicAdvertising(advertiser_id_, true);
1202   test_hci_layer_->GetCommand(OpCode::LE_SET_PERIODIC_ADVERTISING_ENABLE);
1203   EXPECT_CALL(
1204       mock_advertising_callback_,
1205       OnPeriodicAdvertisingEnabled(advertiser_id_, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));
1206   test_hci_layer_->IncomingEvent(LeSetPeriodicAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
1207   sync_client_handler();
1208 }
1209 
1210 }  // namespace
1211 }  // namespace hci
1212 }  // namespace bluetooth
1213