gd/shim/l2cap_test.cc - platform/system/bt - Git at Google

 /*
  * Copyright 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "shim/l2cap.h"

 #include <gtest/gtest.h>
 #include <future>
 #include <memory>

 #include "common/bind.h"
 #include "hci/address.h"
 #include "hci/address_with_type.h"
 #include "l2cap/classic/dynamic_channel_configuration_option.h"
 #include "l2cap/classic/dynamic_channel_manager.h"
 #include "l2cap/classic/internal/dynamic_channel_service_manager_impl_mock.h"
 #include "l2cap/classic/l2cap_classic_module.h"
 #include "l2cap/internal/ilink.h"
 #include "l2cap/psm.h"
 #include "l2cap/security_policy.h"
 #include "os/handler.h"

 namespace bluetooth {
 namespace shim {
 namespace {

 constexpr uint16_t kPsm = 123;
 constexpr uint16_t kPsm2 = kPsm + 2;
 constexpr uint16_t kCid = 456;
 constexpr uint16_t kCid2 = kCid + 1;
 constexpr char device_address[] = "11:22:33:44:55:66";
 constexpr char device_address2[] = "aa:bb:cc:dd:ee:ff";
 constexpr bool kNoUseErtm = false;
 constexpr uint16_t kMtu = 1000;

 class TestDynamicChannelService : public l2cap::classic::DynamicChannelService {
  public:
   TestDynamicChannelService(l2cap::Psm psm, l2cap::classic::internal::DynamicChannelServiceManagerImpl* manager,
                             os::Handler* handler)
       : DynamicChannelService(psm, manager, handler) {}
 };

 class TestLink : public l2cap::internal::ILink {
  public:
   hci::AddressWithType GetDevice() {
     return device_with_type_;
   }
   hci::AddressWithType device_with_type_;

   void SendLeCredit(l2cap::Cid local_cid, uint16_t credit) {}

   void SendDisconnectionRequest(l2cap::Cid cid, l2cap::Cid remote_cid) {
     connection_closed_promise_.set_value();
   }
   std::promise<void> connection_closed_promise_;
 };

 class TestDynamicChannelManagerImpl {
  public:
   bool ConnectChannel(hci::Address device, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
                       l2cap::Psm psm, l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
                       l2cap::classic::DynamicChannelManager::OnConnectionFailureCallback on_fail_callback,
                       os::Handler* handler) {
     connections_++;
     on_open_callback_ = std::move(on_open_callback);
     on_fail_callback_ = std::move(on_fail_callback);

     connected_promise_.set_value();
     return true;
   }
   int connections_{0};

   bool RegisterService(l2cap::Psm psm, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
                        const l2cap::SecurityPolicy& security_policy,
                        l2cap::classic::DynamicChannelManager::OnRegistrationCompleteCallback on_registration_complete,
                        l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
                        os::Handler* handler) {
     services_++;
     on_registration_complete_ = std::move(on_registration_complete);
     on_open_callback_ = std::move(on_open_callback);

     register_promise_.set_value();
     return true;
   }
   int services_{0};

   void SetConnectionFuture() {
     connected_promise_ = std::promise<void>();
   }

   void WaitConnectionFuture() {
     connected_future_ = connected_promise_.get_future();
     connected_future_.wait();
   }

   void SetRegistrationFuture() {
     register_promise_ = std::promise<void>();
   }

   void WaitRegistrationFuture() {
     register_future_ = register_promise_.get_future();
     register_future_.wait();
   }

   void SetConnectionOnFail(l2cap::classic::DynamicChannelManager::ConnectionResult result, std::promise<void> promise) {
     std::move(on_fail_callback_).Run(result);
     promise.set_value();
   }

   void SetConnectionOnOpen(std::unique_ptr<l2cap::DynamicChannel> channel, std::promise<void> promise) {
     std::move(on_open_callback_).Run(std::move(channel));
     promise.set_value();
   }

   l2cap::classic::DynamicChannelManager::OnRegistrationCompleteCallback on_registration_complete_{};
   l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback_{};
   l2cap::classic::DynamicChannelManager::OnConnectionFailureCallback on_fail_callback_{};

   TestDynamicChannelManagerImpl() = default;
   ~TestDynamicChannelManagerImpl() = default;

  private:
   std::promise<void> connected_promise_;
   std::future<void> connected_future_;

   std::promise<void> register_promise_;
   std::future<void> register_future_;
 };

 class TestDynamicChannelManager : public l2cap::classic::DynamicChannelManager {
  public:
   bool ConnectChannel(hci::Address device, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
                       l2cap::Psm psm, l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
                       l2cap::classic::DynamicChannelManager::OnConnectionFailureCallback on_fail_callback,
                       os::Handler* handler) override {
     return impl_.ConnectChannel(device, configuration_option, psm, std::move(on_open_callback),
                                 std::move(on_fail_callback), handler);
   }

   bool RegisterService(l2cap::Psm psm, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
                        const l2cap::SecurityPolicy& security_policy,
                        l2cap::classic::DynamicChannelManager::OnRegistrationCompleteCallback on_registration_complete,
                        l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
                        os::Handler* handler) override {
     return impl_.RegisterService(psm, configuration_option, security_policy, std::move(on_registration_complete),
                                  std::move(on_open_callback), handler);
   }
   TestDynamicChannelManager(TestDynamicChannelManagerImpl& impl) : impl_(impl) {}
   TestDynamicChannelManagerImpl& impl_;
 };

 class TestL2capClassicModule : public l2cap::classic::L2capClassicModule {
  public:
   std::unique_ptr<l2cap::classic::DynamicChannelManager> GetDynamicChannelManager() override {
     ASSERT(impl_ != nullptr);
     return std::make_unique<TestDynamicChannelManager>(*impl_);
   }

   void ListDependencies(ModuleList* list) override {}
   void Start() override;
   void Stop() override;

   std::unique_ptr<TestDynamicChannelManagerImpl> impl_;
 };

 void TestL2capClassicModule::Start() {
   impl_ = std::make_unique<TestDynamicChannelManagerImpl>();
 }

 void TestL2capClassicModule::Stop() {
   impl_.reset();
 }

 class ShimL2capTest : public ::testing::Test {
  public:
   void OnConnectionComplete(std::string string_address, uint16_t psm, uint16_t cid, bool connected) {
     connection_string_address_ = string_address;
     connection_psm_ = psm;
     connection_cid_ = cid;
     connection_connected_ = connected;
     connection_complete_promise_.set_value();
   }

   uint16_t CreateConnection(uint16_t psm, std::string device_address) {
     std::promise<uint16_t> promise;
     auto future = promise.get_future();

     shim_l2cap_->CreateConnection(
         psm, device_address,
         std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
         std::move(promise));
     return future.get();
   }

   void SetConnectionFuture() {
     test_l2cap_classic_module_->impl_->SetConnectionFuture();
   }

   void WaitConnectionFuture() {
     test_l2cap_classic_module_->impl_->WaitConnectionFuture();
   }

   void SetRegistrationFuture() {
     test_l2cap_classic_module_->impl_->SetRegistrationFuture();
   }

   void WaitRegistrationFuture() {
     test_l2cap_classic_module_->impl_->WaitRegistrationFuture();
   }

   int NumberOfConnections() const {
     return test_l2cap_classic_module_->impl_->connections_;
   }

   int NumberOfServices() const {
     return test_l2cap_classic_module_->impl_->services_;
   }

   std::string connection_string_address_;
   uint16_t connection_psm_{0};
   uint16_t connection_cid_{0};
   bool connection_connected_{false};

   shim::L2cap* shim_l2cap_ = nullptr;
   TestL2capClassicModule* test_l2cap_classic_module_{nullptr};

   TestLink test_link_;
   std::promise<void> connection_complete_promise_;

  protected:
   void SetUp() override {
     handler_ = new os::Handler(&thread_);

     test_l2cap_classic_module_ = new TestL2capClassicModule();
     test_l2cap_classic_module_->Start();
     fake_registry_.InjectTestModule(&l2cap::classic::L2capClassicModule::Factory, test_l2cap_classic_module_);

     fake_registry_.Start<shim::L2cap>(&thread_);
     shim_l2cap_ = static_cast<shim::L2cap*>(fake_registry_.GetModuleUnderTest(&shim::L2cap::Factory));
   }

   void TearDown() override {
     fake_registry_.StopAll();
     handler_->Clear();
     delete handler_;
   }
   os::Handler* handler_ = nullptr;
   l2cap::classic::internal::testing::MockDynamicChannelServiceManagerImpl mock_;

  private:
   TestModuleRegistry fake_registry_;
   os::Thread& thread_ = fake_registry_.GetTestThread();
 };

 TEST_F(ShimL2capTest, CreateThenDisconnectBeforeCompletion) {
   SetConnectionFuture();

   ASSERT(NumberOfConnections() == 0);
   uint16_t cid = CreateConnection(kPsm, device_address);
   ASSERT(cid != 0);

   WaitConnectionFuture();
   ASSERT(NumberOfConnections() == 1);

   shim_l2cap_->CloseConnection(cid);
 }

 TEST_F(ShimL2capTest, MaxCreatedConnections) {
   for (int i = 0; i < 65536 - 64; i++) {
     SetConnectionFuture();
     uint16_t cid = CreateConnection(kPsm, device_address);
     ASSERT(cid != 0);
     WaitConnectionFuture();

     ASSERT(NumberOfConnections() == i + 1);
   }
   uint16_t cid = CreateConnection(kPsm, device_address);
   ASSERT(cid == 0);

   ASSERT(NumberOfConnections() == 65536 - 64);
 }

 TEST_F(ShimL2capTest, TwoDifferentCreatedConnections) {
   {
     SetConnectionFuture();
     uint16_t cid = CreateConnection(kPsm, device_address);
     ASSERT(cid != 0);
     WaitConnectionFuture();

     ASSERT(NumberOfConnections() == 1);
   }

   {
     SetConnectionFuture();
     uint16_t cid = CreateConnection(kPsm2, device_address2);
     ASSERT(cid != 0);
     WaitConnectionFuture();

     ASSERT(NumberOfConnections() == 2);
   }
 }

 TEST_F(ShimL2capTest, ConnectFail) {
   SetConnectionFuture();
   uint16_t cid = CreateConnection(kPsm, device_address);
   ASSERT(cid != 0);
   WaitConnectionFuture();

   ASSERT(NumberOfConnections() == 1);

   l2cap::classic::DynamicChannelManager::ConnectionResult result{
       .connection_result_code = TestDynamicChannelManager::ConnectionResultCode::FAIL_NO_SERVICE_REGISTERED,
       .hci_error = hci::ErrorCode::SUCCESS,
       .l2cap_connection_response_result = l2cap::ConnectionResponseResult::SUCCESS,
   };

   std::promise<void> on_fail_promise;
   auto on_fail_future = on_fail_promise.get_future();
   handler_->Post(common::BindOnce(&TestDynamicChannelManagerImpl::SetConnectionOnFail,
                                   common::Unretained(test_l2cap_classic_module_->impl_.get()), result,
                                   std::move(on_fail_promise)));
   on_fail_future.wait();

   ASSERT(connection_connected_ == false);

   shim_l2cap_->CloseConnection(cid);
 }

 TEST_F(ShimL2capTest, ConnectOpen) {
   SetConnectionFuture();
   uint16_t cid = CreateConnection(kPsm, device_address);
   ASSERT(cid != 0);
   WaitConnectionFuture();

   ASSERT(NumberOfConnections() == 1);

   hci::Address address;
   hci::Address::FromString(device_address, address);
   test_link_.device_with_type_ = hci::AddressWithType(address, hci::AddressType::PUBLIC_DEVICE_ADDRESS);

   l2cap::Psm psm = kPsm;
   l2cap::Cid local_cid = kCid;
   l2cap::Cid remote_cid = kCid2;

   std::shared_ptr<l2cap::internal::DynamicChannelImpl> impl =
       std::make_shared<l2cap::internal::DynamicChannelImpl>(psm, local_cid, remote_cid, &test_link_, handler_);

   auto channel = std::make_unique<l2cap::DynamicChannel>(impl, handler_);

   std::promise<void> on_fail_promise;
   auto on_fail_future = on_fail_promise.get_future();

   auto connection_complete_future = connection_complete_promise_.get_future();
   handler_->Post(common::BindOnce(&TestDynamicChannelManagerImpl::SetConnectionOnOpen,
                                   common::Unretained(test_l2cap_classic_module_->impl_.get()), std::move(channel),
                                   std::move(on_fail_promise)));
   connection_complete_future.wait();

   on_fail_future.wait();

   ASSERT(connection_connected_ == true);

   auto future = test_link_.connection_closed_promise_.get_future();
   shim_l2cap_->CloseConnection(cid);
   future.wait();
 }

 TEST_F(ShimL2capTest, RegisterService_Success) {
   std::promise<uint16_t> registration_promise;
   auto registration_pending = registration_promise.get_future();

   SetRegistrationFuture();
   shim_l2cap_->RegisterService(
       kPsm, kNoUseErtm, kMtu,
       std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
                 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
       std::move(registration_promise));
   WaitRegistrationFuture();
   ASSERT_LOG(test_l2cap_classic_module_->impl_->on_registration_complete_, "Synchronization failure");
   ASSERT(test_l2cap_classic_module_->impl_->services_ == 1);

   l2cap::classic::DynamicChannelManager::RegistrationResult result{
       l2cap::classic::DynamicChannelManager::RegistrationResult::SUCCESS,
   };
   auto service = std::make_unique<TestDynamicChannelService>(kPsm, &mock_, handler_);

   handler_->Post(common::BindOnce(std::move(test_l2cap_classic_module_->impl_->on_registration_complete_), result,
                                   std::move(service)));
   uint16_t psm = registration_pending.get();
   ASSERT(psm == kPsm);
 }

 TEST_F(ShimL2capTest, RegisterService_Duplicate) {
   std::promise<uint16_t> promise;
   auto future = promise.get_future();

   SetRegistrationFuture();
   shim_l2cap_->RegisterService(
       kPsm, kNoUseErtm, kMtu,
       std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
                 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
       std::move(promise));
   WaitRegistrationFuture();
   ASSERT_LOG(test_l2cap_classic_module_->impl_->on_registration_complete_, "Synchronization failure");
   ASSERT(test_l2cap_classic_module_->impl_->services_ == 1);

   l2cap::classic::DynamicChannelManager::RegistrationResult result{
       l2cap::classic::DynamicChannelManager::RegistrationResult::FAIL_DUPLICATE_SERVICE,
   };
   auto service = std::make_unique<TestDynamicChannelService>(kPsm, &mock_, handler_);

   handler_->Post(common::BindOnce(std::move(test_l2cap_classic_module_->impl_->on_registration_complete_), result,
                                   std::move(service)));
   uint16_t psm = future.get();
   ASSERT(psm == l2cap::kDefaultPsm);
 }

 TEST_F(ShimL2capTest, RegisterService_Invalid) {
   std::promise<uint16_t> promise;
   auto future = promise.get_future();

   SetRegistrationFuture();

   shim_l2cap_->RegisterService(
       kPsm, kNoUseErtm, kMtu,
       std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
                 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
       std::move(promise));

   l2cap::classic::DynamicChannelManager::RegistrationResult result{
       l2cap::classic::DynamicChannelManager::RegistrationResult::FAIL_INVALID_SERVICE,
   };
   auto service = std::make_unique<TestDynamicChannelService>(kPsm, &mock_, handler_);
   WaitRegistrationFuture();

   ASSERT_LOG(test_l2cap_classic_module_->impl_->on_registration_complete_, "Synchronization failure");
   handler_->Post(common::BindOnce(std::move(test_l2cap_classic_module_->impl_->on_registration_complete_), result,
                                   std::move(service)));
   uint16_t psm = future.get();
   ASSERT(psm == l2cap::kDefaultPsm);
   ASSERT(test_l2cap_classic_module_->impl_->services_ == 1);
 }

 }  // namespace
 }  // namespace shim
 }  // namespace bluetooth
	/*
	* Copyright 2020 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "shim/l2cap.h"

	#include <gtest/gtest.h>
	#include <future>
	#include <memory>

	#include "common/bind.h"
	#include "hci/address.h"
	#include "hci/address_with_type.h"
	#include "l2cap/classic/dynamic_channel_configuration_option.h"
	#include "l2cap/classic/dynamic_channel_manager.h"
	#include "l2cap/classic/internal/dynamic_channel_service_manager_impl_mock.h"
	#include "l2cap/classic/l2cap_classic_module.h"
	#include "l2cap/internal/ilink.h"
	#include "l2cap/psm.h"
	#include "l2cap/security_policy.h"
	#include "os/handler.h"

	namespace bluetooth {
	namespace shim {
	namespace {

	constexpr uint16_t kPsm = 123;
	constexpr uint16_t kPsm2 = kPsm + 2;
	constexpr uint16_t kCid = 456;
	constexpr uint16_t kCid2 = kCid + 1;
	constexpr char device_address[] = "11:22:33:44:55:66";
	constexpr char device_address2[] = "aa:bb:cc:dd:ee:ff";
	constexpr bool kNoUseErtm = false;
	constexpr uint16_t kMtu = 1000;

	class TestDynamicChannelService : public l2cap::classic::DynamicChannelService {
	public:
	TestDynamicChannelService(l2cap::Psm psm, l2cap::classic::internal::DynamicChannelServiceManagerImpl* manager,
	os::Handler* handler)
	: DynamicChannelService(psm, manager, handler) {}
	};

	class TestLink : public l2cap::internal::ILink {
	public:
	hci::AddressWithType GetDevice() {
	return device_with_type_;
	}
	hci::AddressWithType device_with_type_;

	void SendLeCredit(l2cap::Cid local_cid, uint16_t credit) {}

	void SendDisconnectionRequest(l2cap::Cid cid, l2cap::Cid remote_cid) {
	connection_closed_promise_.set_value();
	}
	std::promise<void> connection_closed_promise_;
	};

	class TestDynamicChannelManagerImpl {
	public:
	bool ConnectChannel(hci::Address device, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
	l2cap::Psm psm, l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
	l2cap::classic::DynamicChannelManager::OnConnectionFailureCallback on_fail_callback,
	os::Handler* handler) {
	connections_++;
	on_open_callback_ = std::move(on_open_callback);
	on_fail_callback_ = std::move(on_fail_callback);

	connected_promise_.set_value();
	return true;
	}
	int connections_{0};

	bool RegisterService(l2cap::Psm psm, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
	const l2cap::SecurityPolicy& security_policy,
	l2cap::classic::DynamicChannelManager::OnRegistrationCompleteCallback on_registration_complete,
	l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
	os::Handler* handler) {
	services_++;
	on_registration_complete_ = std::move(on_registration_complete);
	on_open_callback_ = std::move(on_open_callback);

	register_promise_.set_value();
	return true;
	}
	int services_{0};

	void SetConnectionFuture() {
	connected_promise_ = std::promise<void>();
	}

	void WaitConnectionFuture() {
	connected_future_ = connected_promise_.get_future();
	connected_future_.wait();
	}

	void SetRegistrationFuture() {
	register_promise_ = std::promise<void>();
	}

	void WaitRegistrationFuture() {
	register_future_ = register_promise_.get_future();
	register_future_.wait();
	}

	void SetConnectionOnFail(l2cap::classic::DynamicChannelManager::ConnectionResult result, std::promise<void> promise) {
	std::move(on_fail_callback_).Run(result);
	promise.set_value();
	}

	void SetConnectionOnOpen(std::unique_ptr<l2cap::DynamicChannel> channel, std::promise<void> promise) {
	std::move(on_open_callback_).Run(std::move(channel));
	promise.set_value();
	}

	l2cap::classic::DynamicChannelManager::OnRegistrationCompleteCallback on_registration_complete_{};
	l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback_{};
	l2cap::classic::DynamicChannelManager::OnConnectionFailureCallback on_fail_callback_{};

	TestDynamicChannelManagerImpl() = default;
	~TestDynamicChannelManagerImpl() = default;

	private:
	std::promise<void> connected_promise_;
	std::future<void> connected_future_;

	std::promise<void> register_promise_;
	std::future<void> register_future_;
	};

	class TestDynamicChannelManager : public l2cap::classic::DynamicChannelManager {
	public:
	bool ConnectChannel(hci::Address device, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
	l2cap::Psm psm, l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
	l2cap::classic::DynamicChannelManager::OnConnectionFailureCallback on_fail_callback,
	os::Handler* handler) override {
	return impl_.ConnectChannel(device, configuration_option, psm, std::move(on_open_callback),
	std::move(on_fail_callback), handler);
	}

	bool RegisterService(l2cap::Psm psm, l2cap::classic::DynamicChannelConfigurationOption configuration_option,
	const l2cap::SecurityPolicy& security_policy,
	l2cap::classic::DynamicChannelManager::OnRegistrationCompleteCallback on_registration_complete,
	l2cap::classic::DynamicChannelManager::OnConnectionOpenCallback on_open_callback,
	os::Handler* handler) override {
	return impl_.RegisterService(psm, configuration_option, security_policy, std::move(on_registration_complete),
	std::move(on_open_callback), handler);
	}
	TestDynamicChannelManager(TestDynamicChannelManagerImpl& impl) : impl_(impl) {}
	TestDynamicChannelManagerImpl& impl_;
	};

	class TestL2capClassicModule : public l2cap::classic::L2capClassicModule {
	public:
	std::unique_ptr<l2cap::classic::DynamicChannelManager> GetDynamicChannelManager() override {
	ASSERT(impl_ != nullptr);
	return std::make_unique<TestDynamicChannelManager>(*impl_);
	}

	void ListDependencies(ModuleList* list) override {}
	void Start() override;
	void Stop() override;

	std::unique_ptr<TestDynamicChannelManagerImpl> impl_;
	};

	void TestL2capClassicModule::Start() {
	impl_ = std::make_unique<TestDynamicChannelManagerImpl>();
	}

	void TestL2capClassicModule::Stop() {
	impl_.reset();
	}

	class ShimL2capTest : public ::testing::Test {
	public:
	void OnConnectionComplete(std::string string_address, uint16_t psm, uint16_t cid, bool connected) {
	connection_string_address_ = string_address;
	connection_psm_ = psm;
	connection_cid_ = cid;
	connection_connected_ = connected;
	connection_complete_promise_.set_value();
	}

	uint16_t CreateConnection(uint16_t psm, std::string device_address) {
	std::promise<uint16_t> promise;
	auto future = promise.get_future();

	shim_l2cap_->CreateConnection(
	psm, device_address,
	std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
	std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
	std::move(promise));
	return future.get();
	}

	void SetConnectionFuture() {
	test_l2cap_classic_module_->impl_->SetConnectionFuture();
	}

	void WaitConnectionFuture() {
	test_l2cap_classic_module_->impl_->WaitConnectionFuture();
	}

	void SetRegistrationFuture() {
	test_l2cap_classic_module_->impl_->SetRegistrationFuture();
	}

	void WaitRegistrationFuture() {
	test_l2cap_classic_module_->impl_->WaitRegistrationFuture();
	}

	int NumberOfConnections() const {
	return test_l2cap_classic_module_->impl_->connections_;
	}

	int NumberOfServices() const {
	return test_l2cap_classic_module_->impl_->services_;
	}

	std::string connection_string_address_;
	uint16_t connection_psm_{0};
	uint16_t connection_cid_{0};
	bool connection_connected_{false};

	shim::L2cap* shim_l2cap_ = nullptr;
	TestL2capClassicModule* test_l2cap_classic_module_{nullptr};

	TestLink test_link_;
	std::promise<void> connection_complete_promise_;

	protected:
	void SetUp() override {
	handler_ = new os::Handler(&thread_);

	test_l2cap_classic_module_ = new TestL2capClassicModule();
	test_l2cap_classic_module_->Start();
	fake_registry_.InjectTestModule(&l2cap::classic::L2capClassicModule::Factory, test_l2cap_classic_module_);

	fake_registry_.Start<shim::L2cap>(&thread_);
	shim_l2cap_ = static_cast<shim::L2cap*>(fake_registry_.GetModuleUnderTest(&shim::L2cap::Factory));
	}

	void TearDown() override {
	fake_registry_.StopAll();
	handler_->Clear();
	delete handler_;
	}
	os::Handler* handler_ = nullptr;
	l2cap::classic::internal::testing::MockDynamicChannelServiceManagerImpl mock_;

	private:
	TestModuleRegistry fake_registry_;
	os::Thread& thread_ = fake_registry_.GetTestThread();
	};

	TEST_F(ShimL2capTest, CreateThenDisconnectBeforeCompletion) {
	SetConnectionFuture();

	ASSERT(NumberOfConnections() == 0);
	uint16_t cid = CreateConnection(kPsm, device_address);
	ASSERT(cid != 0);

	WaitConnectionFuture();
	ASSERT(NumberOfConnections() == 1);

	shim_l2cap_->CloseConnection(cid);
	}

	TEST_F(ShimL2capTest, MaxCreatedConnections) {
	for (int i = 0; i < 65536 - 64; i++) {
	SetConnectionFuture();
	uint16_t cid = CreateConnection(kPsm, device_address);
	ASSERT(cid != 0);
	WaitConnectionFuture();

	ASSERT(NumberOfConnections() == i + 1);
	}
	uint16_t cid = CreateConnection(kPsm, device_address);
	ASSERT(cid == 0);

	ASSERT(NumberOfConnections() == 65536 - 64);
	}

	TEST_F(ShimL2capTest, TwoDifferentCreatedConnections) {
	{
	SetConnectionFuture();
	uint16_t cid = CreateConnection(kPsm, device_address);
	ASSERT(cid != 0);
	WaitConnectionFuture();

	ASSERT(NumberOfConnections() == 1);
	}

	{
	SetConnectionFuture();
	uint16_t cid = CreateConnection(kPsm2, device_address2);
	ASSERT(cid != 0);
	WaitConnectionFuture();

	ASSERT(NumberOfConnections() == 2);
	}
	}

	TEST_F(ShimL2capTest, ConnectFail) {
	SetConnectionFuture();
	uint16_t cid = CreateConnection(kPsm, device_address);
	ASSERT(cid != 0);
	WaitConnectionFuture();

	ASSERT(NumberOfConnections() == 1);

	l2cap::classic::DynamicChannelManager::ConnectionResult result{
	.connection_result_code = TestDynamicChannelManager::ConnectionResultCode::FAIL_NO_SERVICE_REGISTERED,
	.hci_error = hci::ErrorCode::SUCCESS,
	.l2cap_connection_response_result = l2cap::ConnectionResponseResult::SUCCESS,
	};

	std::promise<void> on_fail_promise;
	auto on_fail_future = on_fail_promise.get_future();
	handler_->Post(common::BindOnce(&TestDynamicChannelManagerImpl::SetConnectionOnFail,
	common::Unretained(test_l2cap_classic_module_->impl_.get()), result,
	std::move(on_fail_promise)));
	on_fail_future.wait();

	ASSERT(connection_connected_ == false);

	shim_l2cap_->CloseConnection(cid);
	}

	TEST_F(ShimL2capTest, ConnectOpen) {
	SetConnectionFuture();
	uint16_t cid = CreateConnection(kPsm, device_address);
	ASSERT(cid != 0);
	WaitConnectionFuture();

	ASSERT(NumberOfConnections() == 1);

	hci::Address address;
	hci::Address::FromString(device_address, address);
	test_link_.device_with_type_ = hci::AddressWithType(address, hci::AddressType::PUBLIC_DEVICE_ADDRESS);

	l2cap::Psm psm = kPsm;
	l2cap::Cid local_cid = kCid;
	l2cap::Cid remote_cid = kCid2;

	std::shared_ptr<l2cap::internal::DynamicChannelImpl> impl =
	std::make_shared<l2cap::internal::DynamicChannelImpl>(psm, local_cid, remote_cid, &test_link_, handler_);

	auto channel = std::make_unique<l2cap::DynamicChannel>(impl, handler_);

	std::promise<void> on_fail_promise;
	auto on_fail_future = on_fail_promise.get_future();

	auto connection_complete_future = connection_complete_promise_.get_future();
	handler_->Post(common::BindOnce(&TestDynamicChannelManagerImpl::SetConnectionOnOpen,
	common::Unretained(test_l2cap_classic_module_->impl_.get()), std::move(channel),
	std::move(on_fail_promise)));
	connection_complete_future.wait();

	on_fail_future.wait();

	ASSERT(connection_connected_ == true);

	auto future = test_link_.connection_closed_promise_.get_future();
	shim_l2cap_->CloseConnection(cid);
	future.wait();
	}

	TEST_F(ShimL2capTest, RegisterService_Success) {
	std::promise<uint16_t> registration_promise;
	auto registration_pending = registration_promise.get_future();

	SetRegistrationFuture();
	shim_l2cap_->RegisterService(
	kPsm, kNoUseErtm, kMtu,
	std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
	std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
	std::move(registration_promise));
	WaitRegistrationFuture();
	ASSERT_LOG(test_l2cap_classic_module_->impl_->on_registration_complete_, "Synchronization failure");
	ASSERT(test_l2cap_classic_module_->impl_->services_ == 1);

	l2cap::classic::DynamicChannelManager::RegistrationResult result{
	l2cap::classic::DynamicChannelManager::RegistrationResult::SUCCESS,
	};
	auto service = std::make_unique<TestDynamicChannelService>(kPsm, &mock_, handler_);

	handler_->Post(common::BindOnce(std::move(test_l2cap_classic_module_->impl_->on_registration_complete_), result,
	std::move(service)));
	uint16_t psm = registration_pending.get();
	ASSERT(psm == kPsm);
	}

	TEST_F(ShimL2capTest, RegisterService_Duplicate) {
	std::promise<uint16_t> promise;
	auto future = promise.get_future();

	SetRegistrationFuture();
	shim_l2cap_->RegisterService(
	kPsm, kNoUseErtm, kMtu,
	std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
	std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
	std::move(promise));
	WaitRegistrationFuture();
	ASSERT_LOG(test_l2cap_classic_module_->impl_->on_registration_complete_, "Synchronization failure");
	ASSERT(test_l2cap_classic_module_->impl_->services_ == 1);

	l2cap::classic::DynamicChannelManager::RegistrationResult result{
	l2cap::classic::DynamicChannelManager::RegistrationResult::FAIL_DUPLICATE_SERVICE,
	};
	auto service = std::make_unique<TestDynamicChannelService>(kPsm, &mock_, handler_);

	handler_->Post(common::BindOnce(std::move(test_l2cap_classic_module_->impl_->on_registration_complete_), result,
	std::move(service)));
	uint16_t psm = future.get();
	ASSERT(psm == l2cap::kDefaultPsm);
	}

	TEST_F(ShimL2capTest, RegisterService_Invalid) {
	std::promise<uint16_t> promise;
	auto future = promise.get_future();

	SetRegistrationFuture();

	shim_l2cap_->RegisterService(
	kPsm, kNoUseErtm, kMtu,
	std::bind(&bluetooth::shim::ShimL2capTest::OnConnectionComplete, this, std::placeholders::_1,
	std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
	std::move(promise));

	l2cap::classic::DynamicChannelManager::RegistrationResult result{
	l2cap::classic::DynamicChannelManager::RegistrationResult::FAIL_INVALID_SERVICE,
	};
	auto service = std::make_unique<TestDynamicChannelService>(kPsm, &mock_, handler_);
	WaitRegistrationFuture();

	ASSERT_LOG(test_l2cap_classic_module_->impl_->on_registration_complete_, "Synchronization failure");
	handler_->Post(common::BindOnce(std::move(test_l2cap_classic_module_->impl_->on_registration_complete_), result,
	std::move(service)));
	uint16_t psm = future.get();
	ASSERT(psm == l2cap::kDefaultPsm);
	ASSERT(test_l2cap_classic_module_->impl_->services_ == 1);
	}

	} // namespace
	} // namespace shim
	} // namespace bluetooth