1 /*
2 * Copyright 2022 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/acl_manager.h"
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21
22 #include <chrono>
23 #include <deque>
24 #include <future>
25
26 #include "common/bind.h"
27 #include "hci/acl_manager/le_connection_management_callbacks_mock.h"
28 #include "hci/address.h"
29 #include "hci/address_with_type.h"
30 #include "hci/class_of_device.h"
31 #include "hci/controller.h"
32 #include "hci/hci_layer.h"
33 #include "hci/hci_layer_fake.h"
34 #include "os/thread.h"
35 #include "packet/raw_builder.h"
36
37 using namespace std::chrono_literals;
38
39 namespace bluetooth {
40 namespace hci {
41 namespace acl_manager {
42 namespace {
43
44 using common::BidiQueue;
45 using common::BidiQueueEnd;
46 using packet::kLittleEndian;
47 using packet::PacketView;
48 using packet::RawBuilder;
49
50 namespace {
51 constexpr char kLocalRandomAddressString[] = "D0:05:04:03:02:01";
52 constexpr char kRemotePublicDeviceStringA[] = "11:A2:A3:A4:A5:A6";
53 constexpr char kRemotePublicDeviceStringB[] = "11:B2:B3:B4:B5:B6";
54 constexpr uint16_t kHciHandleA = 123;
55 constexpr uint16_t kHciHandleB = 456;
56
57 constexpr auto kMinimumRotationTime = std::chrono::milliseconds(7 * 60 * 1000);
58 constexpr auto kMaximumRotationTime = std::chrono::milliseconds(15 * 60 * 1000);
59
60 const AddressWithType empty_address_with_type = hci::AddressWithType();
61
62 struct {
63 Address address;
64 ClassOfDevice class_of_device;
65 const uint16_t handle;
66 } remote_device[2] = {
67 {.address = {}, .class_of_device = {}, .handle = kHciHandleA},
68 {.address = {}, .class_of_device = {}, .handle = kHciHandleB},
69 };
70 } // namespace
71
NextPayload(uint16_t handle)72 std::unique_ptr<BasePacketBuilder> NextPayload(uint16_t handle) {
73 static uint32_t packet_number = 1;
74 auto payload = std::make_unique<RawBuilder>();
75 payload->AddOctets2(6); // L2CAP PDU size
76 payload->AddOctets2(2); // L2CAP CID
77 payload->AddOctets2(handle);
78 payload->AddOctets4(packet_number++);
79 return std::move(payload);
80 }
81
82 class TestController : public Controller {
83 public:
GetAclPacketLength() const84 uint16_t GetAclPacketLength() const override { return acl_buffer_length_; }
85
GetNumAclPacketBuffers() const86 uint16_t GetNumAclPacketBuffers() const override { return total_acl_buffers_; }
87
IsSupported(bluetooth::hci::OpCode) const88 bool IsSupported(bluetooth::hci::OpCode /* op_code */) const override { return false; }
89
GetLeBufferSize() const90 LeBufferSize GetLeBufferSize() const override {
91 LeBufferSize le_buffer_size;
92 le_buffer_size.total_num_le_packets_ = 2;
93 le_buffer_size.le_data_packet_length_ = 32;
94 return le_buffer_size;
95 }
96
97 protected:
Start()98 void Start() override {}
Stop()99 void Stop() override {}
ListDependencies(ModuleList *) const100 void ListDependencies(ModuleList* /* list */) const {}
101
102 private:
103 uint16_t acl_buffer_length_ = 1024;
104 uint16_t total_acl_buffers_ = 2;
105 common::ContextualCallback<void(uint16_t /* handle */, uint16_t /* packets */)> acl_cb_;
106 };
107
108 class MockConnectionCallback : public ConnectionCallbacks {
109 public:
OnConnectSuccess(std::unique_ptr<ClassicAclConnection> connection)110 void OnConnectSuccess(std::unique_ptr<ClassicAclConnection> connection) override {
111 // Convert to std::shared_ptr during push_back()
112 connections_.push_back(std::move(connection));
113 if (is_promise_set_) {
114 is_promise_set_ = false;
115 connection_promise_.set_value(connections_.back());
116 }
117 }
118 MOCK_METHOD(void, OnConnectRequest, (Address, ClassOfDevice), (override));
119 MOCK_METHOD(void, OnConnectFail, (Address, ErrorCode reason, bool locally_initiated), (override));
120
NumberOfConnections() const121 size_t NumberOfConnections() const { return connections_.size(); }
122
123 private:
124 friend class AclManagerWithCallbacksTest;
125 friend class AclManagerNoCallbacksTest;
126
127 std::deque<std::shared_ptr<ClassicAclConnection>> connections_;
128 std::promise<std::shared_ptr<ClassicAclConnection>> connection_promise_;
129 bool is_promise_set_{false};
130 };
131
132 class MockLeConnectionCallbacks : public LeConnectionCallbacks {
133 public:
OnLeConnectSuccess(AddressWithType,std::unique_ptr<LeAclConnection> connection)134 void OnLeConnectSuccess(AddressWithType /* address_with_type */,
135 std::unique_ptr<LeAclConnection> connection) override {
136 le_connections_.push_back(std::move(connection));
137 if (le_connection_promise_ != nullptr) {
138 std::promise<void>* prom = le_connection_promise_.release();
139 prom->set_value();
140 delete prom;
141 }
142 }
143 MOCK_METHOD(void, OnLeConnectFail, (AddressWithType, ErrorCode reason), (override));
144
145 std::deque<std::shared_ptr<LeAclConnection>> le_connections_;
146 std::unique_ptr<std::promise<void>> le_connection_promise_;
147 };
148
149 class AclManagerBaseTest : public ::testing::Test {
150 protected:
SetUp()151 void SetUp() override {
152 test_hci_layer_ = new HciLayerFake; // Ownership is transferred to registry
153 test_controller_ = new TestController;
154 fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);
155 fake_registry_.InjectTestModule(&Controller::Factory, test_controller_);
156 client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
157 ASSERT_NE(client_handler_, nullptr);
158 fake_registry_.Start<AclManager>(&thread_);
159 }
160
TearDown()161 void TearDown() override {
162 fake_registry_.SynchronizeModuleHandler(&AclManager::Factory, std::chrono::milliseconds(20));
163 fake_registry_.StopAll();
164 }
165
sync_client_handler()166 void sync_client_handler() {
167 std::promise<void> promise;
168 auto future = promise.get_future();
169 client_handler_->Post(
170 common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));
171 auto future_status = future.wait_for(std::chrono::seconds(1));
172 ASSERT_EQ(future_status, std::future_status::ready);
173 }
174
175 HciLayerFake* test_hci_layer_ = nullptr;
176 TestController* test_controller_ = nullptr;
177
178 TestModuleRegistry fake_registry_;
179 os::Thread& thread_ = fake_registry_.GetTestThread();
180 AclManager* acl_manager_ = nullptr;
181 os::Handler* client_handler_ = nullptr;
182 };
183
184 class AclManagerNoCallbacksTest : public AclManagerBaseTest {
185 protected:
SetUp()186 void SetUp() override {
187 AclManagerBaseTest::SetUp();
188
189 acl_manager_ =
190 static_cast<AclManager*>(fake_registry_.GetModuleUnderTest(&AclManager::Factory));
191
192 local_address_with_type_ =
193 AddressWithType(Address::FromString(kLocalRandomAddressString).value(),
194 hci::AddressType::RANDOM_DEVICE_ADDRESS);
195
196 acl_manager_->SetPrivacyPolicyForInitiatorAddress(
197 LeAddressManager::AddressPolicy::USE_STATIC_ADDRESS, local_address_with_type_,
198 kMinimumRotationTime, kMaximumRotationTime);
199
200 auto command = test_hci_layer_->GetCommand();
201 ASSERT_TRUE(command.IsValid());
202 ASSERT_EQ(OpCode::LE_SET_RANDOM_ADDRESS, command.GetOpCode());
203 }
204
TearDown()205 void TearDown() override { AclManagerBaseTest::TearDown(); }
206
207 AddressWithType local_address_with_type_;
208 const bool use_accept_list_ = true; // gd currently only supports connect list
209
SendAclData(uint16_t handle,AclConnection::QueueUpEnd * queue_end)210 void SendAclData(uint16_t handle, AclConnection::QueueUpEnd* queue_end) {
211 std::promise<void> promise;
212 auto future = promise.get_future();
213 queue_end->RegisterEnqueue(
214 client_handler_,
215 common::Bind(
216 [](decltype(queue_end) queue_end, uint16_t handle, std::promise<void> promise) {
217 queue_end->UnregisterEnqueue();
218 promise.set_value();
219 return NextPayload(handle);
220 },
221 queue_end, handle, common::Passed(std::move(promise))));
222 auto status = future.wait_for(2s);
223 ASSERT_EQ(status, std::future_status::ready);
224 }
225 };
226
227 class AclManagerWithCallbacksTest : public AclManagerNoCallbacksTest {
228 protected:
SetUp()229 void SetUp() override {
230 AclManagerNoCallbacksTest::SetUp();
231 acl_manager_->RegisterCallbacks(&mock_connection_callbacks_, client_handler_);
232 acl_manager_->RegisterLeCallbacks(&mock_le_connection_callbacks_, client_handler_);
233 }
234
TearDown()235 void TearDown() override {
236 fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));
237 fake_registry_.SynchronizeModuleHandler(&AclManager::Factory, std::chrono::milliseconds(20));
238 fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));
239 {
240 std::promise<void> promise;
241 auto future = promise.get_future();
242 acl_manager_->UnregisterLeCallbacks(&mock_le_connection_callbacks_, std::move(promise));
243 future.wait_for(2s);
244 }
245 {
246 std::promise<void> promise;
247 auto future = promise.get_future();
248 acl_manager_->UnregisterCallbacks(&mock_connection_callbacks_, std::move(promise));
249 future.wait_for(2s);
250 }
251
252 mock_connection_callbacks_.connections_.clear();
253 mock_le_connection_callbacks_.le_connections_.clear();
254
255 AclManagerNoCallbacksTest::TearDown();
256 }
257
GetConnectionFuture()258 std::future<std::shared_ptr<ClassicAclConnection>> GetConnectionFuture() {
259 // Run on main thread
260 mock_connection_callbacks_.connection_promise_ =
261 std::promise<std::shared_ptr<ClassicAclConnection>>();
262 mock_connection_callbacks_.is_promise_set_ = true;
263 return mock_connection_callbacks_.connection_promise_.get_future();
264 }
265
GetLeConnectionFuture()266 std::future<void> GetLeConnectionFuture() {
267 mock_le_connection_callbacks_.le_connection_promise_ = std::make_unique<std::promise<void>>();
268 return mock_le_connection_callbacks_.le_connection_promise_->get_future();
269 }
270
GetLastConnection()271 std::shared_ptr<ClassicAclConnection> GetLastConnection() {
272 return mock_connection_callbacks_.connections_.back();
273 }
274
NumberOfConnections()275 size_t NumberOfConnections() { return mock_connection_callbacks_.connections_.size(); }
276
GetLastLeConnection()277 std::shared_ptr<LeAclConnection> GetLastLeConnection() {
278 return mock_le_connection_callbacks_.le_connections_.back();
279 }
280
NumberOfLeConnections()281 size_t NumberOfLeConnections() { return mock_le_connection_callbacks_.le_connections_.size(); }
282
283 MockConnectionCallback mock_connection_callbacks_;
284 MockLeConnectionCallbacks mock_le_connection_callbacks_;
285 };
286
287 class AclManagerWithConnectionTest : public AclManagerWithCallbacksTest {
288 protected:
SetUp()289 void SetUp() override {
290 AclManagerWithCallbacksTest::SetUp();
291
292 handle_ = 0x123;
293 Address::FromString("A1:A2:A3:A4:A5:A6", remote);
294
295 acl_manager_->CreateConnection(remote);
296
297 // Wait for the connection request
298 auto last_command = test_hci_layer_->GetCommand(OpCode::CREATE_CONNECTION);
299
300 EXPECT_CALL(mock_connection_management_callbacks_,
301 OnRoleChange(hci::ErrorCode::SUCCESS, Role::CENTRAL));
302
303 auto first_connection = GetConnectionFuture();
304 test_hci_layer_->IncomingEvent(ConnectionCompleteBuilder::Create(
305 ErrorCode::SUCCESS, handle_, remote, LinkType::ACL, Enable::DISABLED));
306
307 auto first_connection_status = first_connection.wait_for(2s);
308 ASSERT_EQ(first_connection_status, std::future_status::ready);
309
310 connection_ = GetLastConnection();
311 connection_->RegisterCallbacks(&mock_connection_management_callbacks_, client_handler_);
312 }
313
TearDown()314 void TearDown() override {
315 fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));
316 fake_registry_.SynchronizeModuleHandler(&AclManager::Factory, std::chrono::milliseconds(20));
317 fake_registry_.StopAll();
318 }
319
320 uint16_t handle_;
321 Address remote;
322 std::shared_ptr<ClassicAclConnection> connection_;
323
324 class MockConnectionManagementCallbacks : public ConnectionManagementCallbacks {
325 public:
326 MOCK_METHOD1(OnConnectionPacketTypeChanged, void(uint16_t packet_type));
327 MOCK_METHOD1(OnAuthenticationComplete, void(hci::ErrorCode hci_status));
328 MOCK_METHOD1(OnEncryptionChange, void(EncryptionEnabled enabled));
329 MOCK_METHOD0(OnChangeConnectionLinkKeyComplete, void());
330 MOCK_METHOD1(OnReadClockOffsetComplete, void(uint16_t clock_offse));
331 MOCK_METHOD3(OnModeChange, void(ErrorCode status, Mode current_mode, uint16_t interval));
332 MOCK_METHOD5(OnSniffSubrating,
333 void(ErrorCode status, uint16_t maximum_transmit_latency,
334 uint16_t maximum_receive_latency, uint16_t minimum_remote_timeout,
335 uint16_t minimum_local_timeout));
336 MOCK_METHOD5(OnQosSetupComplete,
337 void(ServiceType service_type, uint32_t token_rate, uint32_t peak_bandwidth,
338 uint32_t latency, uint32_t delay_variation));
339 MOCK_METHOD6(OnFlowSpecificationComplete,
340 void(FlowDirection flow_direction, ServiceType service_type, uint32_t token_rate,
341 uint32_t token_bucket_size, uint32_t peak_bandwidth,
342 uint32_t access_latency));
343 MOCK_METHOD0(OnFlushOccurred, void());
344 MOCK_METHOD1(OnRoleDiscoveryComplete, void(Role current_role));
345 MOCK_METHOD1(OnReadLinkPolicySettingsComplete, void(uint16_t link_policy_settings));
346 MOCK_METHOD1(OnReadAutomaticFlushTimeoutComplete, void(uint16_t flush_timeout));
347 MOCK_METHOD1(OnReadTransmitPowerLevelComplete, void(uint8_t transmit_power_level));
348 MOCK_METHOD1(OnReadLinkSupervisionTimeoutComplete, void(uint16_t link_supervision_timeout));
349 MOCK_METHOD1(OnReadFailedContactCounterComplete, void(uint16_t failed_contact_counter));
350 MOCK_METHOD1(OnReadLinkQualityComplete, void(uint8_t link_quality));
351 MOCK_METHOD2(OnReadAfhChannelMapComplete,
352 void(AfhMode afh_mode, std::array<uint8_t, 10> afh_channel_map));
353 MOCK_METHOD1(OnReadRssiComplete, void(uint8_t rssi));
354 MOCK_METHOD2(OnReadClockComplete, void(uint32_t clock, uint16_t accuracy));
355 MOCK_METHOD1(OnCentralLinkKeyComplete, void(KeyFlag flag));
356 MOCK_METHOD2(OnRoleChange, void(ErrorCode hci_status, Role new_role));
357 MOCK_METHOD1(OnDisconnection, void(ErrorCode reason));
358 MOCK_METHOD4(OnReadRemoteVersionInformationComplete,
359 void(hci::ErrorCode hci_status, uint8_t lmp_version, uint16_t manufacturer_name,
360 uint16_t sub_version));
361 MOCK_METHOD1(OnReadRemoteSupportedFeaturesComplete, void(uint64_t features));
362 MOCK_METHOD3(OnReadRemoteExtendedFeaturesComplete,
363 void(uint8_t page_number, uint8_t max_page_number, uint64_t features));
364 } mock_connection_management_callbacks_;
365 };
366
TEST_F(AclManagerWithCallbacksTest,startup_teardown)367 TEST_F(AclManagerWithCallbacksTest, startup_teardown) {}
368
369 class AclManagerWithLeConnectionTest : public AclManagerWithCallbacksTest {
370 protected:
SetUp()371 void SetUp() override {
372 AclManagerWithCallbacksTest::SetUp();
373
374 Address remote_public_address = Address::FromString(kRemotePublicDeviceStringA).value();
375 remote_with_type_ = AddressWithType(remote_public_address, AddressType::PUBLIC_DEVICE_ADDRESS);
376 acl_manager_->CreateLeConnection(remote_with_type_, true);
377 test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);
378 test_hci_layer_->IncomingEvent(
379 LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
380 auto packet = test_hci_layer_->GetCommand(OpCode::LE_CREATE_CONNECTION);
381 auto le_connection_management_command_view =
382 LeConnectionManagementCommandView::Create(AclCommandView::Create(packet));
383 auto command_view = LeCreateConnectionView::Create(le_connection_management_command_view);
384 ASSERT_TRUE(command_view.IsValid());
385 if (use_accept_list_) {
386 ASSERT_EQ(command_view.GetPeerAddress(), empty_address_with_type.GetAddress());
387 ASSERT_EQ(command_view.GetPeerAddressType(), empty_address_with_type.GetAddressType());
388 } else {
389 ASSERT_EQ(command_view.GetPeerAddress(), remote_public_address);
390 ASSERT_EQ(command_view.GetPeerAddressType(), AddressType::PUBLIC_DEVICE_ADDRESS);
391 }
392
393 test_hci_layer_->IncomingEvent(
394 LeCreateConnectionStatusBuilder::Create(ErrorCode::SUCCESS, 0x01));
395
396 auto first_connection = GetLeConnectionFuture();
397
398 test_hci_layer_->IncomingLeMetaEvent(LeConnectionCompleteBuilder::Create(
399 ErrorCode::SUCCESS, handle_, Role::PERIPHERAL, AddressType::PUBLIC_DEVICE_ADDRESS,
400 remote_public_address, 0x0100, 0x0010, 0x0C80, ClockAccuracy::PPM_30));
401
402 test_hci_layer_->GetCommand(OpCode::LE_REMOVE_DEVICE_FROM_FILTER_ACCEPT_LIST);
403 test_hci_layer_->IncomingEvent(
404 LeRemoveDeviceFromFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
405
406 auto first_connection_status = first_connection.wait_for(2s);
407 ASSERT_EQ(first_connection_status, std::future_status::ready);
408
409 connection_ = GetLastLeConnection();
410 }
411
TearDown()412 void TearDown() override {
413 fake_registry_.SynchronizeModuleHandler(&HciLayer::Factory, std::chrono::milliseconds(20));
414 fake_registry_.SynchronizeModuleHandler(&AclManager::Factory, std::chrono::milliseconds(20));
415 fake_registry_.StopAll();
416 }
417
sync_client_handler()418 void sync_client_handler() {
419 std::promise<void> promise;
420 auto future = promise.get_future();
421 client_handler_->Post(
422 common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));
423 auto future_status = future.wait_for(std::chrono::seconds(1));
424 ASSERT_EQ(future_status, std::future_status::ready);
425 }
426
427 uint16_t handle_ = 0x123;
428 std::shared_ptr<LeAclConnection> connection_;
429 AddressWithType remote_with_type_;
430
431 MockLeConnectionManagementCallbacks mock_le_connection_management_callbacks_;
432 };
433
434 class AclManagerWithResolvableAddressTest : public AclManagerWithCallbacksTest {
435 protected:
SetUp()436 void SetUp() override {
437 test_hci_layer_ = new HciLayerFake; // Ownership is transferred to registry
438 test_controller_ = new TestController;
439 fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);
440 fake_registry_.InjectTestModule(&Controller::Factory, test_controller_);
441 client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
442 ASSERT_NE(client_handler_, nullptr);
443 fake_registry_.Start<AclManager>(&thread_);
444 acl_manager_ =
445 static_cast<AclManager*>(fake_registry_.GetModuleUnderTest(&AclManager::Factory));
446 hci::Address address;
447 Address::FromString("D0:05:04:03:02:01", address);
448 hci::AddressWithType address_with_type(address, hci::AddressType::RANDOM_DEVICE_ADDRESS);
449 acl_manager_->RegisterCallbacks(&mock_connection_callbacks_, client_handler_);
450 acl_manager_->RegisterLeCallbacks(&mock_le_connection_callbacks_, client_handler_);
451 auto minimum_rotation_time = std::chrono::milliseconds(7 * 60 * 1000);
452 auto maximum_rotation_time = std::chrono::milliseconds(15 * 60 * 1000);
453 acl_manager_->SetPrivacyPolicyForInitiatorAddress(
454 LeAddressManager::AddressPolicy::USE_RESOLVABLE_ADDRESS, address_with_type,
455 minimum_rotation_time, maximum_rotation_time);
456
457 test_hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);
458 test_hci_layer_->IncomingEvent(
459 LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));
460 }
461 };
462
TEST_F(AclManagerNoCallbacksTest,unregister_classic_before_connection_request)463 TEST_F(AclManagerNoCallbacksTest, unregister_classic_before_connection_request) {
464 ClassOfDevice class_of_device;
465
466 MockConnectionCallback mock_connection_callbacks_;
467
468 acl_manager_->RegisterCallbacks(&mock_connection_callbacks_, client_handler_);
469
470 // Unregister callbacks before receiving connection request
471 auto promise = std::promise<void>();
472 auto future = promise.get_future();
473 acl_manager_->UnregisterCallbacks(&mock_connection_callbacks_, std::move(promise));
474 future.get();
475
476 // Inject peer sending connection request
477 test_hci_layer_->IncomingEvent(ConnectionRequestBuilder::Create(
478 local_address_with_type_.GetAddress(), class_of_device, ConnectionRequestLinkType::ACL));
479 sync_client_handler();
480
481 // There should be no connections
482 ASSERT_EQ(0UL, mock_connection_callbacks_.NumberOfConnections());
483
484 auto command = test_hci_layer_->GetCommand(OpCode::REJECT_CONNECTION_REQUEST);
485 }
486
TEST_F(AclManagerWithCallbacksTest,two_remote_connection_requests_ABAB)487 TEST_F(AclManagerWithCallbacksTest, two_remote_connection_requests_ABAB) {
488 Address::FromString(kRemotePublicDeviceStringA, remote_device[0].address);
489 Address::FromString(kRemotePublicDeviceStringB, remote_device[1].address);
490
491 {
492 // Device A sends connection request
493 test_hci_layer_->IncomingEvent(ConnectionRequestBuilder::Create(
494 remote_device[0].address, remote_device[0].class_of_device,
495 ConnectionRequestLinkType::ACL));
496 sync_client_handler();
497 // Verify we accept this connection
498 auto command = test_hci_layer_->GetCommand(OpCode::ACCEPT_CONNECTION_REQUEST);
499 }
500
501 {
502 // Device B sends connection request
503 test_hci_layer_->IncomingEvent(ConnectionRequestBuilder::Create(
504 remote_device[1].address, remote_device[1].class_of_device,
505 ConnectionRequestLinkType::ACL));
506 sync_client_handler();
507 // Verify we accept this connection
508 auto command = test_hci_layer_->GetCommand(OpCode::ACCEPT_CONNECTION_REQUEST);
509 }
510
511 ASSERT_EQ(0UL, NumberOfConnections());
512
513 {
514 // Device A completes first connection
515 auto future = GetConnectionFuture();
516 test_hci_layer_->IncomingEvent(ConnectionCompleteBuilder::Create(
517 ErrorCode::SUCCESS, remote_device[0].handle, remote_device[0].address, LinkType::ACL,
518 Enable::DISABLED));
519 ASSERT_EQ(std::future_status::ready, future.wait_for(2s))
520 << "Timeout waiting for first connection complete";
521 ASSERT_EQ(1UL, NumberOfConnections());
522 auto connection = future.get();
523 ASSERT_EQ(connection->GetAddress(), remote_device[0].address)
524 << "First connection remote address mismatch";
525 }
526
527 {
528 // Device B completes second connection
529 auto future = GetConnectionFuture();
530 test_hci_layer_->IncomingEvent(ConnectionCompleteBuilder::Create(
531 ErrorCode::SUCCESS, remote_device[1].handle, remote_device[1].address, LinkType::ACL,
532 Enable::DISABLED));
533 ASSERT_EQ(std::future_status::ready, future.wait_for(2s))
534 << "Timeout waiting for second connection complete";
535 ASSERT_EQ(2UL, NumberOfConnections());
536 auto connection = future.get();
537 ASSERT_EQ(connection->GetAddress(), remote_device[1].address)
538 << "Second connection remote address mismatch";
539 }
540 }
541
TEST_F(AclManagerWithCallbacksTest,two_remote_connection_requests_ABBA)542 TEST_F(AclManagerWithCallbacksTest, two_remote_connection_requests_ABBA) {
543 Address::FromString(kRemotePublicDeviceStringA, remote_device[0].address);
544 Address::FromString(kRemotePublicDeviceStringB, remote_device[1].address);
545
546 {
547 // Device A sends connection request
548 test_hci_layer_->IncomingEvent(ConnectionRequestBuilder::Create(
549 remote_device[0].address, remote_device[0].class_of_device,
550 ConnectionRequestLinkType::ACL));
551 sync_client_handler();
552 // Verify we accept this connection
553 auto command = test_hci_layer_->GetCommand(OpCode::ACCEPT_CONNECTION_REQUEST);
554 }
555
556 {
557 // Device B sends connection request
558 test_hci_layer_->IncomingEvent(ConnectionRequestBuilder::Create(
559 remote_device[1].address, remote_device[1].class_of_device,
560 ConnectionRequestLinkType::ACL));
561 sync_client_handler();
562 // Verify we accept this connection
563 auto command = test_hci_layer_->GetCommand(OpCode::ACCEPT_CONNECTION_REQUEST);
564 }
565
566 ASSERT_EQ(0UL, NumberOfConnections());
567
568 {
569 // Device B completes first connection
570 auto future = GetConnectionFuture();
571 test_hci_layer_->IncomingEvent(ConnectionCompleteBuilder::Create(
572 ErrorCode::SUCCESS, remote_device[1].handle, remote_device[1].address, LinkType::ACL,
573 Enable::DISABLED));
574 ASSERT_EQ(std::future_status::ready, future.wait_for(2s))
575 << "Timeout waiting for first connection complete";
576 ASSERT_EQ(1UL, NumberOfConnections());
577 auto connection = future.get();
578 ASSERT_EQ(connection->GetAddress(), remote_device[1].address)
579 << "First connection remote address mismatch";
580 }
581
582 {
583 // Device A completes second connection
584 auto future = GetConnectionFuture();
585 test_hci_layer_->IncomingEvent(ConnectionCompleteBuilder::Create(
586 ErrorCode::SUCCESS, remote_device[0].handle, remote_device[0].address, LinkType::ACL,
587 Enable::DISABLED));
588 ASSERT_EQ(std::future_status::ready, future.wait_for(2s))
589 << "Timeout waiting for second connection complete";
590 ASSERT_EQ(2UL, NumberOfConnections());
591 auto connection = future.get();
592 ASSERT_EQ(connection->GetAddress(), remote_device[0].address)
593 << "Second connection remote address mismatch";
594 }
595 }
596
TEST_F(AclManagerWithCallbacksTest,test_disconnection_after_request)597 TEST_F(AclManagerWithCallbacksTest, test_disconnection_after_request) {
598 Address remote = *Address::FromString("12:34:56:78:9a:bc");
599 EXPECT_CALL(mock_connection_callbacks_, OnConnectRequest).Times(1);
600 test_hci_layer_->IncomingEvent(ConnectionRequestBuilder::Create(remote, ClassOfDevice({1, 2, 3}),
601 ConnectionRequestLinkType::ACL));
602 test_hci_layer_->IncomingEvent(
603 ConnectionCompleteBuilder::Create(ErrorCode::REMOTE_USER_TERMINATED_CONNECTION, 0, remote,
604 LinkType::ACL, Enable::DISABLED));
605 }
606
TEST_F(AclManagerWithCallbacksTest,test_disconnection_after_request_sync)607 TEST_F(AclManagerWithCallbacksTest, test_disconnection_after_request_sync) {
608 std::promise<void> request_promise;
609 auto request_future = request_promise.get_future();
610
611 Address remote = *Address::FromString("12:34:56:78:9a:bc");
612 EXPECT_CALL(mock_connection_callbacks_, OnConnectRequest).WillOnce([&request_promise]() {
613 request_promise.set_value();
614 });
615 test_hci_layer_->IncomingEvent(ConnectionRequestBuilder::Create(remote, ClassOfDevice({1, 2, 3}),
616 ConnectionRequestLinkType::ACL));
617 ASSERT_EQ(std::future_status::ready, request_future.wait_for(std::chrono::seconds(1)));
618 test_hci_layer_->IncomingEvent(
619 ConnectionCompleteBuilder::Create(ErrorCode::REMOTE_USER_TERMINATED_CONNECTION, 0, remote,
620 LinkType::ACL, Enable::DISABLED));
621 }
622
623 } // namespace
624 } // namespace acl_manager
625 } // namespace hci
626 } // namespace bluetooth
627