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