system/gd/hci/acl_manager/classic_acl_connection_test.cc - platform/packages/modules/Bluetooth - Git at Google

 /*
  * Copyright 2022 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 "hci/acl_manager/classic_acl_connection.h"

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include <chrono>
 #include <cstdint>
 #include <future>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <queue>
 #include <vector>

 #include "hci/acl_connection_interface.h"
 #include "hci/acl_manager/connection_management_callbacks.h"
 #include "hci/address.h"
 #include "hci/hci_packets.h"
 #include "os/handler.h"
 #include "os/log.h"
 #include "os/thread.h"

 using namespace bluetooth;
 using namespace std::chrono_literals;

 namespace {
 constexpr char kAddress[] = "00:11:22:33:44:55";
 constexpr uint16_t kConnectionHandle = 123;
 constexpr size_t kQueueSize = 10;

 std::vector<hci::DisconnectReason> disconnect_reason_vector = {
     hci::DisconnectReason::AUTHENTICATION_FAILURE,
     hci::DisconnectReason::REMOTE_USER_TERMINATED_CONNECTION,
     hci::DisconnectReason::REMOTE_DEVICE_TERMINATED_CONNECTION_LOW_RESOURCES,
     hci::DisconnectReason::REMOTE_DEVICE_TERMINATED_CONNECTION_POWER_OFF,
     hci::DisconnectReason::UNSUPPORTED_REMOTE_FEATURE,
     hci::DisconnectReason::PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED,
     hci::DisconnectReason::UNACCEPTABLE_CONNECTION_PARAMETERS,
 };

 std::vector<hci::ErrorCode> error_code_vector = {
     hci::ErrorCode::SUCCESS,
     hci::ErrorCode::UNKNOWN_HCI_COMMAND,
     hci::ErrorCode::UNKNOWN_CONNECTION,
     hci::ErrorCode::HARDWARE_FAILURE,
     hci::ErrorCode::PAGE_TIMEOUT,
     hci::ErrorCode::AUTHENTICATION_FAILURE,
     hci::ErrorCode::PIN_OR_KEY_MISSING,
     hci::ErrorCode::MEMORY_CAPACITY_EXCEEDED,
     hci::ErrorCode::CONNECTION_TIMEOUT,
     hci::ErrorCode::CONNECTION_LIMIT_EXCEEDED,
     hci::ErrorCode::SYNCHRONOUS_CONNECTION_LIMIT_EXCEEDED,
     hci::ErrorCode::CONNECTION_ALREADY_EXISTS,
     hci::ErrorCode::COMMAND_DISALLOWED,
     hci::ErrorCode::CONNECTION_REJECTED_LIMITED_RESOURCES,
     hci::ErrorCode::CONNECTION_REJECTED_SECURITY_REASONS,
     hci::ErrorCode::CONNECTION_REJECTED_UNACCEPTABLE_BD_ADDR,
     hci::ErrorCode::CONNECTION_ACCEPT_TIMEOUT,
     hci::ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE,
     hci::ErrorCode::INVALID_HCI_COMMAND_PARAMETERS,
     hci::ErrorCode::REMOTE_USER_TERMINATED_CONNECTION,
     hci::ErrorCode::REMOTE_DEVICE_TERMINATED_CONNECTION_LOW_RESOURCES,
     hci::ErrorCode::REMOTE_DEVICE_TERMINATED_CONNECTION_POWER_OFF,
     hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST,
     hci::ErrorCode::REPEATED_ATTEMPTS,
     hci::ErrorCode::PAIRING_NOT_ALLOWED,
     hci::ErrorCode::UNKNOWN_LMP_PDU,
     hci::ErrorCode::UNSUPPORTED_REMOTE_OR_LMP_FEATURE,
     hci::ErrorCode::SCO_OFFSET_REJECTED,
     hci::ErrorCode::SCO_INTERVAL_REJECTED,
     hci::ErrorCode::SCO_AIR_MODE_REJECTED,
     hci::ErrorCode::INVALID_LMP_OR_LL_PARAMETERS,
     hci::ErrorCode::UNSPECIFIED_ERROR,
     hci::ErrorCode::UNSUPPORTED_LMP_OR_LL_PARAMETER,
     hci::ErrorCode::ROLE_CHANGE_NOT_ALLOWED,
     hci::ErrorCode::TRANSACTION_RESPONSE_TIMEOUT,
     hci::ErrorCode::LINK_LAYER_COLLISION,
     hci::ErrorCode::ENCRYPTION_MODE_NOT_ACCEPTABLE,
     hci::ErrorCode::ROLE_SWITCH_FAILED,
     hci::ErrorCode::CONTROLLER_BUSY,
     hci::ErrorCode::ADVERTISING_TIMEOUT,
     hci::ErrorCode::CONNECTION_FAILED_ESTABLISHMENT,
     hci::ErrorCode::LIMIT_REACHED,
     hci::ErrorCode::STATUS_UNKNOWN,
 };

 // Generic template for all commands
 template <typename T, typename U>
 T CreateCommand(U u) {
   T command;
   return command;
 }

 template <>
 hci::DisconnectView CreateCommand(std::shared_ptr<std::vector<uint8_t>> bytes) {
   return hci::DisconnectView::Create(
       hci::AclCommandView::Create(hci::CommandView::Create(hci::PacketView<hci::kLittleEndian>(bytes))));
 }

 }  // namespace

 class TestAclConnectionInterface : public hci::AclConnectionInterface {
  private:
   void EnqueueCommand(
       std::unique_ptr<hci::AclCommandBuilder> command,
       common::ContextualOnceCallback<void(hci::CommandStatusView)> on_status) override {
     const std::lock_guard<std::mutex> lock(command_queue_mutex_);
     command_queue_.push(std::move(command));
     command_status_callbacks.push_back(std::move(on_status));
     if (command_promise_ != nullptr) {
       std::promise<void>* prom = command_promise_.release();
       prom->set_value();
       delete prom;
     }
   }

   void EnqueueCommand(
       std::unique_ptr<hci::AclCommandBuilder> command,
       common::ContextualOnceCallback<void(hci::CommandCompleteView)> on_complete) override {
     const std::lock_guard<std::mutex> lock(command_queue_mutex_);
     command_queue_.push(std::move(command));
     command_complete_callbacks.push_back(std::move(on_complete));
     if (command_promise_ != nullptr) {
       std::promise<void>* prom = command_promise_.release();
       prom->set_value();
       delete prom;
     }
   }

  public:
   virtual ~TestAclConnectionInterface() = default;

   std::unique_ptr<hci::CommandBuilder> DequeueCommand() {
     const std::lock_guard<std::mutex> lock(command_queue_mutex_);
     auto packet = std::move(command_queue_.front());
     command_queue_.pop();
     return std::move(packet);
   }

   std::shared_ptr<std::vector<uint8_t>> DequeueCommandBytes() {
     auto command = DequeueCommand();
     auto bytes = std::make_shared<std::vector<uint8_t>>();
     packet::BitInserter bi(*bytes);
     command->Serialize(bi);
     return bytes;
   }

   bool IsPacketQueueEmpty() const {
     const std::lock_guard<std::mutex> lock(command_queue_mutex_);
     return command_queue_.empty();
   }

   size_t NumberOfQueuedCommands() const {
     const std::lock_guard<std::mutex> lock(command_queue_mutex_);
     return command_queue_.size();
   }

  private:
   std::list<common::ContextualOnceCallback<void(hci::CommandCompleteView)>> command_complete_callbacks;
   std::list<common::ContextualOnceCallback<void(hci::CommandStatusView)>> command_status_callbacks;
   std::queue<std::unique_ptr<hci::CommandBuilder>> command_queue_;
   mutable std::mutex command_queue_mutex_;
   std::unique_ptr<std::promise<void>> command_promise_;
   std::unique_ptr<std::future<void>> command_future_;
 };

 class TestConnectionManagementCallbacks : public hci::acl_manager::ConnectionManagementCallbacks {
  public:
   ~TestConnectionManagementCallbacks() = default;
   void OnConnectionPacketTypeChanged(uint16_t packet_type) override {}
   void OnAuthenticationComplete(hci::ErrorCode hci_status) override {}
   void OnEncryptionChange(hci::EncryptionEnabled enabled) override {}
   void OnChangeConnectionLinkKeyComplete() override {}
   void OnReadClockOffsetComplete(uint16_t clock_offset) override {}
   void OnModeChange(hci::ErrorCode status, hci::Mode current_mode, uint16_t interval) override {}
   void OnSniffSubrating(
       hci::ErrorCode hci_status,
       uint16_t maximum_transmit_latency,
       uint16_t maximum_receive_latency,
       uint16_t minimum_remote_timeout,
       uint16_t minimum_local_timeout) override {}
   void OnQosSetupComplete(
       hci::ServiceType service_type,
       uint32_t token_rate,
       uint32_t peak_bandwidth,
       uint32_t latency,
       uint32_t delay_variation) override {}
   void OnFlowSpecificationComplete(
       hci::FlowDirection flow_direction,
       hci::ServiceType service_type,
       uint32_t token_rate,
       uint32_t token_bucket_size,
       uint32_t peak_bandwidth,
       uint32_t access_latency) override {}
   void OnFlushOccurred() override {}
   void OnRoleDiscoveryComplete(hci::Role current_role) override {}
   void OnReadLinkPolicySettingsComplete(uint16_t link_policy_settings) override {}
   void OnReadAutomaticFlushTimeoutComplete(uint16_t flush_timeout) override {}
   void OnReadTransmitPowerLevelComplete(uint8_t transmit_power_level) override {}
   void OnReadLinkSupervisionTimeoutComplete(uint16_t link_supervision_timeout) override {}
   void OnReadFailedContactCounterComplete(uint16_t failed_contact_counter) override {}
   void OnReadLinkQualityComplete(uint8_t link_quality) override {}
   void OnReadAfhChannelMapComplete(hci::AfhMode afh_mode, std::array<uint8_t, 10> afh_channel_map) override {}
   void OnReadRssiComplete(uint8_t rssi) override {}
   void OnReadClockComplete(uint32_t clock, uint16_t accuracy) override {}
   void OnCentralLinkKeyComplete(hci::KeyFlag key_flag) override {}
   void OnRoleChange(hci::ErrorCode hci_status, hci::Role new_role) override {}
   void OnDisconnection(hci::ErrorCode reason) override {
     on_disconnection_error_code_queue_.push(reason);
   }
   void OnReadRemoteVersionInformationComplete(
       hci::ErrorCode hci_status, uint8_t lmp_version, uint16_t manufacturer_name, uint16_t sub_version) override {}
   void OnReadRemoteSupportedFeaturesComplete(uint64_t features) override {}
   void OnReadRemoteExtendedFeaturesComplete(uint8_t page_number, uint8_t max_page_number, uint64_t features) override {}

   std::queue<hci::ErrorCode> on_disconnection_error_code_queue_;
 };

 namespace bluetooth {
 namespace hci {
 namespace acl_manager {

 class ClassicAclConnectionTest : public ::testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(hci::Address::FromString(kAddress, address_));
     thread_ = new os::Thread("thread", os::Thread::Priority::NORMAL);
     handler_ = new os::Handler(thread_);
     queue_ = std::make_shared<hci::acl_manager::AclConnection::Queue>(kQueueSize);
     sync_handler();
   }

   void TearDown() override {
     handler_->Clear();
     delete handler_;
     delete thread_;
   }

   void sync_handler() {
     ASSERT(handler_ != nullptr);

     auto promise = std::promise<void>();
     auto future = promise.get_future();
     handler_->BindOnceOn(&promise, &std::promise<void>::set_value).Invoke();
     auto status = future.wait_for(2s);
     ASSERT_EQ(status, std::future_status::ready);
   }

   Address address_;
   os::Handler* handler_{nullptr};
   os::Thread* thread_{nullptr};
   std::shared_ptr<hci::acl_manager::AclConnection::Queue> queue_;

   TestAclConnectionInterface acl_connection_interface_;
   TestConnectionManagementCallbacks callbacks_;
 };

 TEST_F(ClassicAclConnectionTest, simple) {
   AclConnectionInterface* acl_connection_interface = nullptr;
   ClassicAclConnection* connection =
       new ClassicAclConnection(queue_, acl_connection_interface, kConnectionHandle, address_);
   connection->RegisterCallbacks(&callbacks_, handler_);

   delete connection;
 }

 class ClassicAclConnectionWithCallbacksTest : public ClassicAclConnectionTest {
  protected:
   void SetUp() override {
     ClassicAclConnectionTest::SetUp();
     connection_ =
         std::make_unique<ClassicAclConnection>(queue_, &acl_connection_interface_, kConnectionHandle, address_);
     connection_->RegisterCallbacks(&callbacks_, handler_);
     is_callbacks_registered_ = true;
     connection_management_callbacks_ =
         connection_->GetEventCallbacks([this](uint16_t hci_handle) { is_callbacks_invalidated_ = true; });
     is_callbacks_invalidated_ = false;
   }

   void TearDown() override {
     connection_.reset();
     ASSERT_TRUE(is_callbacks_invalidated_);
     ClassicAclConnectionTest::TearDown();
   }

  protected:
   std::unique_ptr<ClassicAclConnection> connection_;
   ConnectionManagementCallbacks* connection_management_callbacks_;
   bool is_callbacks_registered_{false};
   bool is_callbacks_invalidated_{false};
 };

 TEST_F(ClassicAclConnectionWithCallbacksTest, Disconnect) {
   for (const auto& reason : disconnect_reason_vector) {
     ASSERT_TRUE(connection_->Disconnect(reason));
   }

   for (const auto& reason : disconnect_reason_vector) {
     ASSERT_FALSE(acl_connection_interface_.IsPacketQueueEmpty());
     auto command = CreateCommand<DisconnectView>(acl_connection_interface_.DequeueCommandBytes());
     ASSERT_TRUE(command.IsValid());
     ASSERT_EQ(reason, command.GetReason());
     ASSERT_EQ(kConnectionHandle, command.GetConnectionHandle());
   }
   ASSERT_TRUE(acl_connection_interface_.IsPacketQueueEmpty());
 }

 TEST_F(ClassicAclConnectionWithCallbacksTest, OnDisconnection) {
   for (const auto& error_code : error_code_vector) {
     connection_management_callbacks_->OnDisconnection(error_code);
   }

   sync_handler();
   ASSERT_TRUE(!callbacks_.on_disconnection_error_code_queue_.empty());

   for (const auto& error_code : error_code_vector) {
     ASSERT_EQ(error_code, callbacks_.on_disconnection_error_code_queue_.front());
     callbacks_.on_disconnection_error_code_queue_.pop();
   }
 }

 }  // namespace acl_manager
 }  // namespace hci
 }  // namespace bluetooth
	/*
	* Copyright 2022 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 "hci/acl_manager/classic_acl_connection.h"

	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include <chrono>
	#include <cstdint>
	#include <future>
	#include <list>
	#include <memory>
	#include <mutex>
	#include <queue>
	#include <vector>

	#include "hci/acl_connection_interface.h"
	#include "hci/acl_manager/connection_management_callbacks.h"
	#include "hci/address.h"
	#include "hci/hci_packets.h"
	#include "os/handler.h"
	#include "os/log.h"
	#include "os/thread.h"

	using namespace bluetooth;
	using namespace std::chrono_literals;

	namespace {
	constexpr char kAddress[] = "00:11:22:33:44:55";
	constexpr uint16_t kConnectionHandle = 123;
	constexpr size_t kQueueSize = 10;

	std::vector<hci::DisconnectReason> disconnect_reason_vector = {
	hci::DisconnectReason::AUTHENTICATION_FAILURE,
	hci::DisconnectReason::REMOTE_USER_TERMINATED_CONNECTION,
	hci::DisconnectReason::REMOTE_DEVICE_TERMINATED_CONNECTION_LOW_RESOURCES,
	hci::DisconnectReason::REMOTE_DEVICE_TERMINATED_CONNECTION_POWER_OFF,
	hci::DisconnectReason::UNSUPPORTED_REMOTE_FEATURE,
	hci::DisconnectReason::PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED,
	hci::DisconnectReason::UNACCEPTABLE_CONNECTION_PARAMETERS,
	};

	std::vector<hci::ErrorCode> error_code_vector = {
	hci::ErrorCode::SUCCESS,
	hci::ErrorCode::UNKNOWN_HCI_COMMAND,
	hci::ErrorCode::UNKNOWN_CONNECTION,
	hci::ErrorCode::HARDWARE_FAILURE,
	hci::ErrorCode::PAGE_TIMEOUT,
	hci::ErrorCode::AUTHENTICATION_FAILURE,
	hci::ErrorCode::PIN_OR_KEY_MISSING,
	hci::ErrorCode::MEMORY_CAPACITY_EXCEEDED,
	hci::ErrorCode::CONNECTION_TIMEOUT,
	hci::ErrorCode::CONNECTION_LIMIT_EXCEEDED,
	hci::ErrorCode::SYNCHRONOUS_CONNECTION_LIMIT_EXCEEDED,
	hci::ErrorCode::CONNECTION_ALREADY_EXISTS,
	hci::ErrorCode::COMMAND_DISALLOWED,
	hci::ErrorCode::CONNECTION_REJECTED_LIMITED_RESOURCES,
	hci::ErrorCode::CONNECTION_REJECTED_SECURITY_REASONS,
	hci::ErrorCode::CONNECTION_REJECTED_UNACCEPTABLE_BD_ADDR,
	hci::ErrorCode::CONNECTION_ACCEPT_TIMEOUT,
	hci::ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE,
	hci::ErrorCode::INVALID_HCI_COMMAND_PARAMETERS,
	hci::ErrorCode::REMOTE_USER_TERMINATED_CONNECTION,
	hci::ErrorCode::REMOTE_DEVICE_TERMINATED_CONNECTION_LOW_RESOURCES,
	hci::ErrorCode::REMOTE_DEVICE_TERMINATED_CONNECTION_POWER_OFF,
	hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST,
	hci::ErrorCode::REPEATED_ATTEMPTS,
	hci::ErrorCode::PAIRING_NOT_ALLOWED,
	hci::ErrorCode::UNKNOWN_LMP_PDU,
	hci::ErrorCode::UNSUPPORTED_REMOTE_OR_LMP_FEATURE,
	hci::ErrorCode::SCO_OFFSET_REJECTED,
	hci::ErrorCode::SCO_INTERVAL_REJECTED,
	hci::ErrorCode::SCO_AIR_MODE_REJECTED,
	hci::ErrorCode::INVALID_LMP_OR_LL_PARAMETERS,
	hci::ErrorCode::UNSPECIFIED_ERROR,
	hci::ErrorCode::UNSUPPORTED_LMP_OR_LL_PARAMETER,
	hci::ErrorCode::ROLE_CHANGE_NOT_ALLOWED,
	hci::ErrorCode::TRANSACTION_RESPONSE_TIMEOUT,
	hci::ErrorCode::LINK_LAYER_COLLISION,
	hci::ErrorCode::ENCRYPTION_MODE_NOT_ACCEPTABLE,
	hci::ErrorCode::ROLE_SWITCH_FAILED,
	hci::ErrorCode::CONTROLLER_BUSY,
	hci::ErrorCode::ADVERTISING_TIMEOUT,
	hci::ErrorCode::CONNECTION_FAILED_ESTABLISHMENT,
	hci::ErrorCode::LIMIT_REACHED,
	hci::ErrorCode::STATUS_UNKNOWN,
	};

	// Generic template for all commands
	template <typename T, typename U>
	T CreateCommand(U u) {
	T command;
	return command;
	}

	template <>
	hci::DisconnectView CreateCommand(std::shared_ptr<std::vector<uint8_t>> bytes) {
	return hci::DisconnectView::Create(
	hci::AclCommandView::Create(hci::CommandView::Create(hci::PacketView<hci::kLittleEndian>(bytes))));
	}

	} // namespace

	class TestAclConnectionInterface : public hci::AclConnectionInterface {
	private:
	void EnqueueCommand(
	std::unique_ptr<hci::AclCommandBuilder> command,
	common::ContextualOnceCallback<void(hci::CommandStatusView)> on_status) override {
	const std::lock_guard<std::mutex> lock(command_queue_mutex_);
	command_queue_.push(std::move(command));
	command_status_callbacks.push_back(std::move(on_status));
	if (command_promise_ != nullptr) {
	std::promise<void>* prom = command_promise_.release();
	prom->set_value();
	delete prom;
	}
	}

	void EnqueueCommand(
	std::unique_ptr<hci::AclCommandBuilder> command,
	common::ContextualOnceCallback<void(hci::CommandCompleteView)> on_complete) override {
	const std::lock_guard<std::mutex> lock(command_queue_mutex_);
	command_queue_.push(std::move(command));
	command_complete_callbacks.push_back(std::move(on_complete));
	if (command_promise_ != nullptr) {
	std::promise<void>* prom = command_promise_.release();
	prom->set_value();
	delete prom;
	}
	}

	public:
	virtual ~TestAclConnectionInterface() = default;

	std::unique_ptr<hci::CommandBuilder> DequeueCommand() {
	const std::lock_guard<std::mutex> lock(command_queue_mutex_);
	auto packet = std::move(command_queue_.front());
	command_queue_.pop();
	return std::move(packet);
	}

	std::shared_ptr<std::vector<uint8_t>> DequeueCommandBytes() {
	auto command = DequeueCommand();
	auto bytes = std::make_shared<std::vector<uint8_t>>();
	packet::BitInserter bi(*bytes);
	command->Serialize(bi);
	return bytes;
	}

	bool IsPacketQueueEmpty() const {
	const std::lock_guard<std::mutex> lock(command_queue_mutex_);
	return command_queue_.empty();
	}

	size_t NumberOfQueuedCommands() const {
	const std::lock_guard<std::mutex> lock(command_queue_mutex_);
	return command_queue_.size();
	}

	private:
	std::list<common::ContextualOnceCallback<void(hci::CommandCompleteView)>> command_complete_callbacks;
	std::list<common::ContextualOnceCallback<void(hci::CommandStatusView)>> command_status_callbacks;
	std::queue<std::unique_ptr<hci::CommandBuilder>> command_queue_;
	mutable std::mutex command_queue_mutex_;
	std::unique_ptr<std::promise<void>> command_promise_;
	std::unique_ptr<std::future<void>> command_future_;
	};

	class TestConnectionManagementCallbacks : public hci::acl_manager::ConnectionManagementCallbacks {
	public:
	~TestConnectionManagementCallbacks() = default;
	void OnConnectionPacketTypeChanged(uint16_t packet_type) override {}
	void OnAuthenticationComplete(hci::ErrorCode hci_status) override {}
	void OnEncryptionChange(hci::EncryptionEnabled enabled) override {}
	void OnChangeConnectionLinkKeyComplete() override {}
	void OnReadClockOffsetComplete(uint16_t clock_offset) override {}
	void OnModeChange(hci::ErrorCode status, hci::Mode current_mode, uint16_t interval) override {}
	void OnSniffSubrating(
	hci::ErrorCode hci_status,
	uint16_t maximum_transmit_latency,
	uint16_t maximum_receive_latency,
	uint16_t minimum_remote_timeout,
	uint16_t minimum_local_timeout) override {}
	void OnQosSetupComplete(
	hci::ServiceType service_type,
	uint32_t token_rate,
	uint32_t peak_bandwidth,
	uint32_t latency,
	uint32_t delay_variation) override {}
	void OnFlowSpecificationComplete(
	hci::FlowDirection flow_direction,
	hci::ServiceType service_type,
	uint32_t token_rate,
	uint32_t token_bucket_size,
	uint32_t peak_bandwidth,
	uint32_t access_latency) override {}
	void OnFlushOccurred() override {}
	void OnRoleDiscoveryComplete(hci::Role current_role) override {}
	void OnReadLinkPolicySettingsComplete(uint16_t link_policy_settings) override {}
	void OnReadAutomaticFlushTimeoutComplete(uint16_t flush_timeout) override {}
	void OnReadTransmitPowerLevelComplete(uint8_t transmit_power_level) override {}
	void OnReadLinkSupervisionTimeoutComplete(uint16_t link_supervision_timeout) override {}
	void OnReadFailedContactCounterComplete(uint16_t failed_contact_counter) override {}
	void OnReadLinkQualityComplete(uint8_t link_quality) override {}
	void OnReadAfhChannelMapComplete(hci::AfhMode afh_mode, std::array<uint8_t, 10> afh_channel_map) override {}
	void OnReadRssiComplete(uint8_t rssi) override {}
	void OnReadClockComplete(uint32_t clock, uint16_t accuracy) override {}
	void OnCentralLinkKeyComplete(hci::KeyFlag key_flag) override {}
	void OnRoleChange(hci::ErrorCode hci_status, hci::Role new_role) override {}
	void OnDisconnection(hci::ErrorCode reason) override {
	on_disconnection_error_code_queue_.push(reason);
	}
	void OnReadRemoteVersionInformationComplete(
	hci::ErrorCode hci_status, uint8_t lmp_version, uint16_t manufacturer_name, uint16_t sub_version) override {}
	void OnReadRemoteSupportedFeaturesComplete(uint64_t features) override {}
	void OnReadRemoteExtendedFeaturesComplete(uint8_t page_number, uint8_t max_page_number, uint64_t features) override {}

	std::queue<hci::ErrorCode> on_disconnection_error_code_queue_;
	};

	namespace bluetooth {
	namespace hci {
	namespace acl_manager {

	class ClassicAclConnectionTest : public ::testing::Test {
	protected:
	void SetUp() override {
	ASSERT_TRUE(hci::Address::FromString(kAddress, address_));
	thread_ = new os::Thread("thread", os::Thread::Priority::NORMAL);
	handler_ = new os::Handler(thread_);
	queue_ = std::make_shared<hci::acl_manager::AclConnection::Queue>(kQueueSize);
	sync_handler();
	}

	void TearDown() override {
	handler_->Clear();
	delete handler_;
	delete thread_;
	}

	void sync_handler() {
	ASSERT(handler_ != nullptr);

	auto promise = std::promise<void>();
	auto future = promise.get_future();
	handler_->BindOnceOn(&promise, &std::promise<void>::set_value).Invoke();
	auto status = future.wait_for(2s);
	ASSERT_EQ(status, std::future_status::ready);
	}

	Address address_;
	os::Handler* handler_{nullptr};
	os::Thread* thread_{nullptr};
	std::shared_ptr<hci::acl_manager::AclConnection::Queue> queue_;

	TestAclConnectionInterface acl_connection_interface_;
	TestConnectionManagementCallbacks callbacks_;
	};

	TEST_F(ClassicAclConnectionTest, simple) {
	AclConnectionInterface* acl_connection_interface = nullptr;
	ClassicAclConnection* connection =
	new ClassicAclConnection(queue_, acl_connection_interface, kConnectionHandle, address_);
	connection->RegisterCallbacks(&callbacks_, handler_);

	delete connection;
	}

	class ClassicAclConnectionWithCallbacksTest : public ClassicAclConnectionTest {
	protected:
	void SetUp() override {
	ClassicAclConnectionTest::SetUp();
	connection_ =
	std::make_unique<ClassicAclConnection>(queue_, &acl_connection_interface_, kConnectionHandle, address_);
	connection_->RegisterCallbacks(&callbacks_, handler_);
	is_callbacks_registered_ = true;
	connection_management_callbacks_ =
	connection_->GetEventCallbacks([this](uint16_t hci_handle) { is_callbacks_invalidated_ = true; });
	is_callbacks_invalidated_ = false;
	}

	void TearDown() override {
	connection_.reset();
	ASSERT_TRUE(is_callbacks_invalidated_);
	ClassicAclConnectionTest::TearDown();
	}

	protected:
	std::unique_ptr<ClassicAclConnection> connection_;
	ConnectionManagementCallbacks* connection_management_callbacks_;
	bool is_callbacks_registered_{false};
	bool is_callbacks_invalidated_{false};
	};

	TEST_F(ClassicAclConnectionWithCallbacksTest, Disconnect) {
	for (const auto& reason : disconnect_reason_vector) {
	ASSERT_TRUE(connection_->Disconnect(reason));
	}

	for (const auto& reason : disconnect_reason_vector) {
	ASSERT_FALSE(acl_connection_interface_.IsPacketQueueEmpty());
	auto command = CreateCommand<DisconnectView>(acl_connection_interface_.DequeueCommandBytes());
	ASSERT_TRUE(command.IsValid());
	ASSERT_EQ(reason, command.GetReason());
	ASSERT_EQ(kConnectionHandle, command.GetConnectionHandle());
	}
	ASSERT_TRUE(acl_connection_interface_.IsPacketQueueEmpty());
	}

	TEST_F(ClassicAclConnectionWithCallbacksTest, OnDisconnection) {
	for (const auto& error_code : error_code_vector) {
	connection_management_callbacks_->OnDisconnection(error_code);
	}

	sync_handler();
	ASSERT_TRUE(!callbacks_.on_disconnection_error_code_queue_.empty());

	for (const auto& error_code : error_code_vector) {
	ASSERT_EQ(error_code, callbacks_.on_disconnection_error_code_queue_.front());
	callbacks_.on_disconnection_error_code_queue_.pop();
	}
	}

	} // namespace acl_manager
	} // namespace hci
	} // namespace bluetooth