1 /*
2  * Copyright 2020 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_address_manager.h"
18 
19 #include <gtest/gtest.h>
20 
21 #include "hci/controller.h"
22 #include "hci/hci_layer_fake.h"
23 #include "hci/octets.h"
24 #include "packet/raw_builder.h"
25 
26 using ::bluetooth::hci::Octet16;
27 using ::bluetooth::os::Handler;
28 using ::bluetooth::os::Thread;
29 
30 namespace bluetooth {
31 namespace hci {
32 namespace {
33 
34 using packet::kLittleEndian;
35 using packet::PacketView;
36 using packet::RawBuilder;
37 
38 class TestController : public Controller {
39 public:
IsSupported(OpCode op_code) const40   bool IsSupported(OpCode op_code) const override { return supported_opcodes_.count(op_code) == 1; }
41 
AddSupported(OpCode op_code)42   void AddSupported(OpCode op_code) { supported_opcodes_.insert(op_code); }
43 
GetLeNumberOfSupportedAdverisingSets() const44   uint8_t GetLeNumberOfSupportedAdverisingSets() const override { return num_advertisers_; }
45 
GetLeMaximumAdvertisingDataLength() const46   uint16_t GetLeMaximumAdvertisingDataLength() const override { return 0x0672; }
47 
SupportsBlePeriodicAdvertising() const48   bool SupportsBlePeriodicAdvertising() const override { return true; }
49 
SupportsBleExtendedAdvertising() const50   bool SupportsBleExtendedAdvertising() const override { return support_ble_extended_advertising_; }
51 
SetBleExtendedAdvertisingSupport(bool support)52   void SetBleExtendedAdvertisingSupport(bool support) {
53     support_ble_extended_advertising_ = support;
54   }
55 
GetVendorCapabilities() const56   VendorCapabilities GetVendorCapabilities() const override { return vendor_capabilities_; }
57 
58   uint8_t num_advertisers_{0};
59   VendorCapabilities vendor_capabilities_;
60 
61 protected:
Start()62   void Start() override {}
Stop()63   void Stop() override {}
ListDependencies(ModuleList *) const64   void ListDependencies(ModuleList* /* list */) const {}
65 
66 private:
67   std::set<OpCode> supported_opcodes_{};
68   bool support_ble_extended_advertising_ = false;
69 };
70 
71 class RotatorClient : public LeAddressManagerCallback {
72 public:
RotatorClient(LeAddressManager * le_address_manager,size_t id)73   RotatorClient(LeAddressManager* le_address_manager, size_t id)
74       : le_address_manager_(le_address_manager), id_(id) {}
75 
OnPause()76   void OnPause() {
77     paused = true;
78     le_address_manager_->AckPause(this);
79   }
80 
OnResume()81   void OnResume() {
82     paused = false;
83     le_address_manager_->AckResume(this);
84     if (resume_promise_ != nullptr) {
85       std::promise<void>* prom = resume_promise_.release();
86       prom->set_value();
87       delete prom;
88     }
89   }
90 
WaitForResume()91   void WaitForResume() {
92     if (paused) {
93       resume_promise_ = std::make_unique<std::promise<void>>();
94       auto resume_future = resume_promise_->get_future();
95       auto result = resume_future.wait_for(std::chrono::milliseconds(1000));
96       EXPECT_NE(std::future_status::timeout, result);
97     }
98   }
99 
100   bool paused{false};
101   LeAddressManager* le_address_manager_;
102   size_t id_;
103   std::unique_ptr<std::promise<void>> resume_promise_;
104 };
105 
106 class LeAddressManagerTest : public ::testing::Test {
107 public:
SetUp()108   void SetUp() override {
109     thread_ = new Thread("thread", Thread::Priority::NORMAL);
110     handler_ = new Handler(thread_);
111     hci_layer_ = new HciLayerFake();
112     Address address({0x01, 0x02, 0x03, 0x04, 0x05, 0x06});
113     controller_ = new TestController;
114     le_address_manager_ = new LeAddressManager(
115             common::Bind(&LeAddressManagerTest::enqueue_command, common::Unretained(this)),
116             handler_, address, 0x3F, 0x3F, controller_);
117     AllocateClients(1);
118   }
119 
sync_handler(os::Handler *)120   void sync_handler(os::Handler* /* handler */) {
121     std::promise<void> promise;
122     auto future = promise.get_future();
123     handler_->Post(common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));
124     auto future_status = future.wait_for(std::chrono::seconds(1));
125     EXPECT_EQ(future_status, std::future_status::ready);
126   }
127 
TearDown()128   void TearDown() override {
129     sync_handler(handler_);
130     delete le_address_manager_;
131     delete hci_layer_;
132     handler_->Clear();
133     delete handler_;
134     delete thread_;
135   }
136 
AllocateClients(size_t num_clients)137   void AllocateClients(size_t num_clients) {
138     size_t first_id = clients.size();
139     for (size_t i = 0; i < num_clients; i++) {
140       clients.emplace_back(std::make_unique<RotatorClient>(le_address_manager_, first_id + i));
141     }
142   }
143 
enqueue_command(std::unique_ptr<CommandBuilder> command_packet)144   void enqueue_command(std::unique_ptr<CommandBuilder> command_packet) {
145     hci_layer_->EnqueueCommand(std::move(command_packet),
146                                handler_->BindOnce(&LeAddressManager::OnCommandComplete,
147                                                   common::Unretained(le_address_manager_)));
148   }
149 
150   Thread* thread_;
151   Handler* handler_;
152   HciLayerFake* hci_layer_ = nullptr;
153   TestController* controller_ = nullptr;
154   LeAddressManager* le_address_manager_;
155   std::vector<std::unique_ptr<RotatorClient>> clients;
156 };
157 
TEST_F(LeAddressManagerTest,startup_teardown)158 TEST_F(LeAddressManagerTest, startup_teardown) {}
159 
TEST_F(LeAddressManagerTest,register_unregister_callback)160 TEST_F(LeAddressManagerTest, register_unregister_callback) {
161   le_address_manager_->Register(clients[0].get());
162   sync_handler(handler_);
163   le_address_manager_->Unregister(clients[0].get());
164   sync_handler(handler_);
165 }
166 
TEST_F(LeAddressManagerTest,rotator_address_for_single_client)167 TEST_F(LeAddressManagerTest, rotator_address_for_single_client) {
168   Octet16 irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05,
169                  0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};
170   auto minimum_rotation_time = std::chrono::milliseconds(1000);
171   auto maximum_rotation_time = std::chrono::milliseconds(3000);
172   AddressWithType remote_address(Address::kEmpty, AddressType::RANDOM_DEVICE_ADDRESS);
173   le_address_manager_->SetPrivacyPolicyForInitiatorAddress(
174           LeAddressManager::AddressPolicy::USE_RESOLVABLE_ADDRESS, remote_address, irk, false,
175           minimum_rotation_time, maximum_rotation_time);
176 
177   le_address_manager_->Register(clients[0].get());
178   sync_handler(handler_);
179   hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);
180   hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
181   clients[0].get()->WaitForResume();
182   le_address_manager_->Unregister(clients[0].get());
183   sync_handler(handler_);
184 }
185 
TEST_F(LeAddressManagerTest,rotator_non_resolvable_address_for_single_client)186 TEST_F(LeAddressManagerTest, rotator_non_resolvable_address_for_single_client) {
187   Octet16 irk = {};
188   auto minimum_rotation_time = std::chrono::milliseconds(1000);
189   auto maximum_rotation_time = std::chrono::milliseconds(3000);
190   AddressWithType remote_address(Address::kEmpty, AddressType::RANDOM_DEVICE_ADDRESS);
191   le_address_manager_->SetPrivacyPolicyForInitiatorAddress(
192           LeAddressManager::AddressPolicy::USE_NON_RESOLVABLE_ADDRESS, remote_address, irk, false,
193           minimum_rotation_time, maximum_rotation_time);
194 
195   le_address_manager_->Register(clients[0].get());
196   sync_handler(handler_);
197   hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);
198   hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
199   clients[0].get()->WaitForResume();
200   le_address_manager_->Unregister(clients[0].get());
201   sync_handler(handler_);
202 }
203 
204 // TODO handle the case "register during rotate_random_address" and enable this
TEST_F(LeAddressManagerTest,DISABLED_rotator_address_for_multiple_clients)205 TEST_F(LeAddressManagerTest, DISABLED_rotator_address_for_multiple_clients) {
206   AllocateClients(2);
207   Octet16 irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05,
208                  0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};
209   auto minimum_rotation_time = std::chrono::milliseconds(1000);
210   auto maximum_rotation_time = std::chrono::milliseconds(3000);
211   AddressWithType remote_address(Address::kEmpty, AddressType::RANDOM_DEVICE_ADDRESS);
212   le_address_manager_->SetPrivacyPolicyForInitiatorAddress(
213           LeAddressManager::AddressPolicy::USE_RESOLVABLE_ADDRESS, remote_address, irk, false,
214           minimum_rotation_time, maximum_rotation_time);
215   le_address_manager_->Register(clients[0].get());
216   le_address_manager_->Register(clients[1].get());
217   le_address_manager_->Register(clients[2].get());
218   sync_handler(handler_);
219 
220   le_address_manager_->Unregister(clients[0].get());
221   le_address_manager_->Unregister(clients[1].get());
222   le_address_manager_->Unregister(clients[2].get());
223   sync_handler(handler_);
224 }
225 
226 class LeAddressManagerWithSingleClientTest : public LeAddressManagerTest {
227 public:
SetUp()228   void SetUp() override {
229     thread_ = new Thread("thread", Thread::Priority::NORMAL);
230     handler_ = new Handler(thread_);
231     hci_layer_ = new HciLayerFake();
232     Address address({0x01, 0x02, 0x03, 0x04, 0x05, 0x06});
233     controller_ = new TestController;
234     le_address_manager_ = new LeAddressManager(
235             common::Bind(&LeAddressManagerWithSingleClientTest::enqueue_command,
236                          common::Unretained(this)),
237             handler_, address, 0x3F, 0x3F, controller_);
238     AllocateClients(1);
239 
240     Octet16 irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05,
241                    0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};
242     auto minimum_rotation_time = std::chrono::milliseconds(1000);
243     auto maximum_rotation_time = std::chrono::milliseconds(3000);
244     AddressWithType remote_address(Address::kEmpty, AddressType::RANDOM_DEVICE_ADDRESS);
245     le_address_manager_->SetPrivacyPolicyForInitiatorAddress(
246             LeAddressManager::AddressPolicy::USE_RESOLVABLE_ADDRESS, remote_address, irk, false,
247             minimum_rotation_time, maximum_rotation_time);
248 
249     le_address_manager_->Register(clients[0].get());
250     sync_handler(handler_);
251     hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);
252     hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
253   }
254 
enqueue_command(std::unique_ptr<CommandBuilder> command_packet)255   void enqueue_command(std::unique_ptr<CommandBuilder> command_packet) {
256     hci_layer_->EnqueueCommand(std::move(command_packet),
257                                handler_->BindOnce(&LeAddressManager::OnCommandComplete,
258                                                   common::Unretained(le_address_manager_)));
259   }
260 
TearDown()261   void TearDown() override {
262     le_address_manager_->Unregister(clients[0].get());
263     sync_handler(handler_);
264     delete le_address_manager_;
265     delete hci_layer_;
266     handler_->Clear();
267     delete handler_;
268     delete thread_;
269   }
270 };
271 
TEST_F(LeAddressManagerWithSingleClientTest,add_device_to_accept_list)272 TEST_F(LeAddressManagerWithSingleClientTest, add_device_to_accept_list) {
273   Address address;
274   Address::FromString("01:02:03:04:05:06", address);
275   le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);
276   auto packet = hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);
277   auto packet_view = LeAddDeviceToFilterAcceptListView::Create(
278           LeConnectionManagementCommandView::Create(AclCommandView::Create(packet)));
279   ASSERT_TRUE(packet_view.IsValid());
280   ASSERT_EQ(FilterAcceptListAddressType::RANDOM, packet_view.GetAddressType());
281   ASSERT_EQ(address, packet_view.GetAddress());
282 
283   hci_layer_->IncomingEvent(
284           LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
285   clients[0].get()->WaitForResume();
286 }
287 
TEST_F(LeAddressManagerWithSingleClientTest,remove_device_from_accept_list)288 TEST_F(LeAddressManagerWithSingleClientTest, remove_device_from_accept_list) {
289   Address address;
290   Address::FromString("01:02:03:04:05:06", address);
291   le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);
292   hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);
293   hci_layer_->IncomingEvent(
294           LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
295 
296   le_address_manager_->RemoveDeviceFromFilterAcceptList(FilterAcceptListAddressType::RANDOM,
297                                                         address);
298   auto packet = hci_layer_->GetCommand(OpCode::LE_REMOVE_DEVICE_FROM_FILTER_ACCEPT_LIST);
299   auto packet_view = LeRemoveDeviceFromFilterAcceptListView::Create(
300           LeConnectionManagementCommandView::Create(AclCommandView::Create(packet)));
301   ASSERT_TRUE(packet_view.IsValid());
302   ASSERT_EQ(FilterAcceptListAddressType::RANDOM, packet_view.GetAddressType());
303   ASSERT_EQ(address, packet_view.GetAddress());
304   hci_layer_->IncomingEvent(
305           LeRemoveDeviceFromFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
306   clients[0].get()->WaitForResume();
307 }
308 
TEST_F(LeAddressManagerWithSingleClientTest,clear_filter_accept_list)309 TEST_F(LeAddressManagerWithSingleClientTest, clear_filter_accept_list) {
310   Address address;
311   Address::FromString("01:02:03:04:05:06", address);
312   le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);
313   hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);
314   hci_layer_->IncomingEvent(
315           LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
316 
317   le_address_manager_->ClearFilterAcceptList();
318   hci_layer_->GetCommand(OpCode::LE_CLEAR_FILTER_ACCEPT_LIST);
319   hci_layer_->IncomingEvent(
320           LeClearFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
321   clients[0].get()->WaitForResume();
322 }
323 
324 // b/260916288
TEST_F(LeAddressManagerWithSingleClientTest,DISABLED_add_device_to_resolving_list)325 TEST_F(LeAddressManagerWithSingleClientTest, DISABLED_add_device_to_resolving_list) {
326   Address address;
327   Address::FromString("01:02:03:04:05:06", address);
328   Octet16 peer_irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05,
329                       0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};
330   Octet16 local_irk = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
331                        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
332 
333   le_address_manager_->AddDeviceToResolvingList(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS,
334                                                 address, peer_irk, local_irk);
335   {
336     auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
337     auto packet_view =
338             LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));
339     ASSERT_TRUE(packet_view.IsValid());
340     ASSERT_EQ(Enable::DISABLED, packet_view.GetAddressResolutionEnable());
341     hci_layer_->IncomingEvent(
342             LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
343   }
344   {
345     auto packet = hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);
346     auto packet_view =
347             LeAddDeviceToResolvingListView::Create(LeSecurityCommandView::Create(packet));
348     ASSERT_TRUE(packet_view.IsValid());
349     ASSERT_EQ(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS,
350               packet_view.GetPeerIdentityAddressType());
351     ASSERT_EQ(address, packet_view.GetPeerIdentityAddress());
352     ASSERT_EQ(peer_irk, packet_view.GetPeerIrk());
353     ASSERT_EQ(local_irk, packet_view.GetLocalIrk());
354     hci_layer_->IncomingEvent(
355             LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
356   }
357   {
358     auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
359     auto packet_view =
360             LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));
361     ASSERT_TRUE(packet_view.IsValid());
362     ASSERT_EQ(Enable::ENABLED, packet_view.GetAddressResolutionEnable());
363     hci_layer_->IncomingEvent(
364             LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
365   }
366   clients[0].get()->WaitForResume();
367 }
368 
369 // b/260916288
TEST_F(LeAddressManagerWithSingleClientTest,DISABLED_remove_device_from_resolving_list)370 TEST_F(LeAddressManagerWithSingleClientTest, DISABLED_remove_device_from_resolving_list) {
371   Address address;
372   Address::FromString("01:02:03:04:05:06", address);
373   Octet16 peer_irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05,
374                       0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};
375   Octet16 local_irk = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
376                        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
377   le_address_manager_->AddDeviceToResolvingList(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS,
378                                                 address, peer_irk, local_irk);
379   hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
380   hci_layer_->IncomingEvent(
381           LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
382   hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);
383   hci_layer_->IncomingEvent(
384           LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
385   hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
386   hci_layer_->IncomingEvent(
387           LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
388 
389   le_address_manager_->RemoveDeviceFromResolvingList(
390           PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS, address);
391   {
392     auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
393     auto packet_view =
394             LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));
395     ASSERT_TRUE(packet_view.IsValid());
396     ASSERT_EQ(Enable::DISABLED, packet_view.GetAddressResolutionEnable());
397     hci_layer_->IncomingEvent(
398             LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
399   }
400   {
401     auto packet = hci_layer_->GetCommand(OpCode::LE_REMOVE_DEVICE_FROM_RESOLVING_LIST);
402     auto packet_view =
403             LeRemoveDeviceFromResolvingListView::Create(LeSecurityCommandView::Create(packet));
404     ASSERT_TRUE(packet_view.IsValid());
405     ASSERT_EQ(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS,
406               packet_view.GetPeerIdentityAddressType());
407     ASSERT_EQ(address, packet_view.GetPeerIdentityAddress());
408     hci_layer_->IncomingEvent(
409             LeRemoveDeviceFromResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
410   }
411   {
412     auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
413     auto packet_view =
414             LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));
415     ASSERT_TRUE(packet_view.IsValid());
416     ASSERT_EQ(Enable::ENABLED, packet_view.GetAddressResolutionEnable());
417     hci_layer_->IncomingEvent(
418             LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
419   }
420   clients[0].get()->WaitForResume();
421 }
422 
423 // b/260916288
TEST_F(LeAddressManagerWithSingleClientTest,DISABLED_clear_resolving_list)424 TEST_F(LeAddressManagerWithSingleClientTest, DISABLED_clear_resolving_list) {
425   Address address;
426   Address::FromString("01:02:03:04:05:06", address);
427   Octet16 peer_irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05,
428                       0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};
429   Octet16 local_irk = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
430                        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
431   le_address_manager_->AddDeviceToResolvingList(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS,
432                                                 address, peer_irk, local_irk);
433   hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
434   hci_layer_->IncomingEvent(
435           LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
436   hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);
437   hci_layer_->IncomingEvent(
438           LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
439   hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
440   hci_layer_->IncomingEvent(
441           LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
442 
443   le_address_manager_->ClearResolvingList();
444   {
445     auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
446     auto packet_view =
447             LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));
448     ASSERT_TRUE(packet_view.IsValid());
449     ASSERT_EQ(Enable::DISABLED, packet_view.GetAddressResolutionEnable());
450     hci_layer_->IncomingEvent(
451             LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
452   }
453   {
454     auto packet = hci_layer_->GetCommand(OpCode::LE_CLEAR_RESOLVING_LIST);
455     auto packet_view = LeClearResolvingListView::Create(LeSecurityCommandView::Create(packet));
456     ASSERT_TRUE(packet_view.IsValid());
457     hci_layer_->IncomingEvent(
458             LeClearResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
459   }
460   {
461     auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);
462     auto packet_view =
463             LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));
464     ASSERT_TRUE(packet_view.IsValid());
465     ASSERT_EQ(Enable::ENABLED, packet_view.GetAddressResolutionEnable());
466     hci_layer_->IncomingEvent(
467             LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
468   }
469 
470   clients[0].get()->WaitForResume();
471 }
472 
TEST_F(LeAddressManagerWithSingleClientTest,register_during_command_complete)473 TEST_F(LeAddressManagerWithSingleClientTest, register_during_command_complete) {
474   Address address;
475   Address::FromString("01:02:03:04:05:06", address);
476   le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);
477   auto packet = hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);
478   auto packet_view = LeAddDeviceToFilterAcceptListView::Create(
479           LeConnectionManagementCommandView::Create(AclCommandView::Create(packet)));
480   ASSERT_TRUE(packet_view.IsValid());
481   ASSERT_EQ(FilterAcceptListAddressType::RANDOM, packet_view.GetAddressType());
482   ASSERT_EQ(address, packet_view.GetAddress());
483   hci_layer_->IncomingEvent(
484           LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
485 
486   AllocateClients(1);
487   le_address_manager_->Register(clients[1].get());
488   clients[0].get()->WaitForResume();
489   clients[1].get()->WaitForResume();
490 }
491 
492 }  // namespace
493 }  // namespace hci
494 }  // namespace bluetooth
495