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