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