aboutsummaryrefslogtreecommitdiff
path: root/gd/hci/controller_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'gd/hci/controller_test.cc')
-rw-r--r--gd/hci/controller_test.cc172
1 files changed, 87 insertions, 85 deletions
diff --git a/gd/hci/controller_test.cc b/gd/hci/controller_test.cc
index c77ed7ba3..75f6db10b 100644
--- a/gd/hci/controller_test.cc
+++ b/gd/hci/controller_test.cc
@@ -25,6 +25,7 @@
#include "common/bind.h"
#include "common/callback.h"
+#include "common/init_flags.h"
#include "hci/address.h"
#include "hci/hci_layer.h"
#include "os/thread.h"
@@ -56,22 +57,25 @@ PacketView<kLittleEndian> GetPacketView(std::unique_ptr<packet::BasePacketBuilde
class TestHciLayer : public HciLayer {
public:
- void EnqueueCommand(std::unique_ptr<CommandPacketBuilder> command,
- common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) override {
+ void EnqueueCommand(
+ std::unique_ptr<CommandBuilder> command,
+ common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) override {
GetHandler()->Post(common::BindOnce(&TestHciLayer::HandleCommand, common::Unretained(this), std::move(command),
- std::move(on_complete), common::Unretained(handler)));
+ std::move(on_complete)));
}
- void EnqueueCommand(std::unique_ptr<CommandPacketBuilder> command,
- common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) override {
+ void EnqueueCommand(
+ std::unique_ptr<CommandBuilder> command,
+ common::ContextualOnceCallback<void(CommandStatusView)> on_status) override {
EXPECT_TRUE(false) << "Controller properties should not generate Command Status";
}
- void HandleCommand(std::unique_ptr<CommandPacketBuilder> command_builder,
- common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) {
+ void HandleCommand(
+ std::unique_ptr<CommandBuilder> command_builder,
+ common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) {
auto packet_view = GetPacketView(std::move(command_builder));
- CommandPacketView command = CommandPacketView::Create(packet_view);
- ASSERT(command.IsValid());
+ CommandView command = CommandView::Create(packet_view);
+ ASSERT_TRUE(command.IsValid());
uint8_t num_packets = 1;
std::unique_ptr<packet::BasePacketBuilder> event_builder;
@@ -101,14 +105,9 @@ class TestHciLayer : public HciLayer {
event_builder =
ReadLocalSupportedCommandsCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, supported_commands);
} break;
- case (OpCode::READ_LOCAL_SUPPORTED_FEATURES): {
- uint64_t lmp_features = 0x012345678abcdef;
- event_builder =
- ReadLocalSupportedFeaturesCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, lmp_features);
- } break;
case (OpCode::READ_LOCAL_EXTENDED_FEATURES): {
ReadLocalExtendedFeaturesView read_command = ReadLocalExtendedFeaturesView::Create(command);
- ASSERT(read_command.IsValid());
+ ASSERT_TRUE(read_command.IsValid());
uint8_t page_bumber = read_command.GetPageNumber();
uint64_t lmp_features = 0x012345678abcdef;
lmp_features += page_bumber;
@@ -123,11 +122,11 @@ class TestHciLayer : public HciLayer {
case (OpCode::READ_BD_ADDR): {
event_builder = ReadBdAddrCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, Address::kAny);
} break;
- case (OpCode::LE_READ_BUFFER_SIZE): {
+ case (OpCode::LE_READ_BUFFER_SIZE_V1): {
LeBufferSize le_buffer_size;
le_buffer_size.le_data_packet_length_ = 0x16;
le_buffer_size.total_num_le_packets_ = 0x08;
- event_builder = LeReadBufferSizeCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, le_buffer_size);
+ event_builder = LeReadBufferSizeV1CompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, le_buffer_size);
} break;
case (OpCode::LE_READ_LOCAL_SUPPORTED_FEATURES): {
event_builder =
@@ -175,14 +174,20 @@ class TestHciLayer : public HciLayer {
} break;
case (OpCode::SET_EVENT_MASK): {
auto view = SetEventMaskView::Create(command);
- ASSERT(view.IsValid());
+ ASSERT_TRUE(view.IsValid());
event_mask = view.GetEventMask();
event_builder = SetEventMaskCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS);
} break;
+ case (OpCode::LE_SET_EVENT_MASK): {
+ auto view = LeSetEventMaskView::Create(command);
+ ASSERT_TRUE(view.IsValid());
+ le_event_mask = view.GetLeEventMask();
+ event_builder = LeSetEventMaskCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS);
+ } break;
+
case (OpCode::RESET):
case (OpCode::SET_EVENT_FILTER):
case (OpCode::HOST_BUFFER_SIZE):
- case (OpCode::LE_SET_EVENT_MASK):
command_queue_.push(command);
not_empty_.notify_all();
return;
@@ -191,24 +196,21 @@ class TestHciLayer : public HciLayer {
return;
}
auto packet = GetPacketView(std::move(event_builder));
- EventPacketView event = EventPacketView::Create(packet);
- ASSERT(event.IsValid());
+ EventView event = EventView::Create(packet);
+ ASSERT_TRUE(event.IsValid());
CommandCompleteView command_complete = CommandCompleteView::Create(event);
- ASSERT(command_complete.IsValid());
- handler->Post(common::BindOnce(std::move(on_complete), std::move(command_complete)));
+ ASSERT_TRUE(command_complete.IsValid());
+ on_complete.Invoke(std::move(command_complete));
}
- void RegisterEventHandler(EventCode event_code, common::Callback<void(EventPacketView)> event_handler,
- os::Handler* handler) override {
+ void RegisterEventHandler(EventCode event_code, common::ContextualCallback<void(EventView)> event_handler) override {
EXPECT_EQ(event_code, EventCode::NUMBER_OF_COMPLETED_PACKETS) << "Only NUMBER_OF_COMPLETED_PACKETS is needed";
number_of_completed_packets_callback_ = event_handler;
- client_handler_ = handler;
}
void UnregisterEventHandler(EventCode event_code) override {
EXPECT_EQ(event_code, EventCode::NUMBER_OF_COMPLETED_PACKETS) << "Only NUMBER_OF_COMPLETED_PACKETS is needed";
number_of_completed_packets_callback_ = {};
- client_handler_ = nullptr;
}
void IncomingCredit() {
@@ -222,12 +224,12 @@ class TestHciLayer : public HciLayer {
completed_packets.push_back(cp);
auto event_builder = NumberOfCompletedPacketsBuilder::Create(completed_packets);
auto packet = GetPacketView(std::move(event_builder));
- EventPacketView event = EventPacketView::Create(packet);
- ASSERT(event.IsValid());
- client_handler_->Post(common::BindOnce(number_of_completed_packets_callback_, event));
+ EventView event = EventView::Create(packet);
+ ASSERT_TRUE(event.IsValid());
+ number_of_completed_packets_callback_.Invoke(event);
}
- CommandPacketView GetCommand(OpCode op_code) {
+ CommandView GetCommand(OpCode op_code) {
std::unique_lock<std::mutex> lock(mutex_);
std::chrono::milliseconds time = std::chrono::milliseconds(3000);
@@ -237,8 +239,11 @@ class TestHciLayer : public HciLayer {
break;
}
}
- ASSERT(command_queue_.size() > 0);
- CommandPacketView command = command_queue_.front();
+ EXPECT_TRUE(command_queue_.size() > 0);
+ if (command_queue_.empty()) {
+ return CommandView::Create(PacketView<kLittleEndian>(std::make_shared<std::vector<uint8_t>>()));
+ }
+ CommandView command = command_queue_.front();
EXPECT_EQ(command.GetOpCode(), op_code);
command_queue_.pop();
return command;
@@ -253,11 +258,11 @@ class TestHciLayer : public HciLayer {
constexpr static uint16_t total_num_acl_data_packets = 10;
constexpr static uint16_t total_num_synchronous_data_packets = 12;
uint64_t event_mask = 0;
+ uint64_t le_event_mask = 0;
private:
- common::Callback<void(EventPacketView)> number_of_completed_packets_callback_;
- os::Handler* client_handler_;
- std::queue<CommandPacketView> command_queue_;
+ common::ContextualCallback<void(EventView)> number_of_completed_packets_callback_;
+ std::queue<CommandView> command_queue_;
mutable std::mutex mutex_;
std::condition_variable not_empty_;
};
@@ -265,6 +270,7 @@ class TestHciLayer : public HciLayer {
class ControllerTest : public ::testing::Test {
protected:
void SetUp() override {
+ bluetooth::common::InitFlags::SetAllForTesting();
test_hci_layer_ = new TestHciLayer;
fake_registry_.InjectTestModule(&HciLayer::Factory, test_hci_layer_);
client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
@@ -286,45 +292,32 @@ class ControllerTest : public ::testing::Test {
TEST_F(ControllerTest, startup_teardown) {}
TEST_F(ControllerTest, read_controller_info) {
- ASSERT_EQ(controller_->GetControllerAclPacketLength(), test_hci_layer_->acl_data_packet_length);
- ASSERT_EQ(controller_->GetControllerNumAclPacketBuffers(), test_hci_layer_->total_num_acl_data_packets);
- ASSERT_EQ(controller_->GetControllerScoPacketLength(), test_hci_layer_->synchronous_data_packet_length);
- ASSERT_EQ(controller_->GetControllerNumScoPacketBuffers(), test_hci_layer_->total_num_synchronous_data_packets);
- ASSERT_EQ(controller_->GetControllerMacAddress(), Address::kAny);
- LocalVersionInformation local_version_information = controller_->GetControllerLocalVersionInformation();
+ ASSERT_EQ(controller_->GetAclPacketLength(), test_hci_layer_->acl_data_packet_length);
+ ASSERT_EQ(controller_->GetNumAclPacketBuffers(), test_hci_layer_->total_num_acl_data_packets);
+ ASSERT_EQ(controller_->GetScoPacketLength(), test_hci_layer_->synchronous_data_packet_length);
+ ASSERT_EQ(controller_->GetNumScoPacketBuffers(), test_hci_layer_->total_num_synchronous_data_packets);
+ ASSERT_EQ(controller_->GetMacAddress(), Address::kAny);
+ LocalVersionInformation local_version_information = controller_->GetLocalVersionInformation();
ASSERT_EQ(local_version_information.hci_version_, HciVersion::V_5_0);
ASSERT_EQ(local_version_information.hci_revision_, 0x1234);
ASSERT_EQ(local_version_information.lmp_version_, LmpVersion::V_4_2);
ASSERT_EQ(local_version_information.manufacturer_name_, 0xBAD);
ASSERT_EQ(local_version_information.lmp_subversion_, 0x5678);
- std::array<uint8_t, 64> supported_commands;
- for (int i = 0; i < 37; i++) {
- supported_commands[i] = 0xff;
- }
- for (int i = 37; i < 64; i++) {
- supported_commands[i] = 0x00;
- }
- ASSERT_EQ(controller_->GetControllerLocalSupportedCommands(), supported_commands);
- ASSERT_EQ(controller_->GetControllerLocalSupportedFeatures(), 0x012345678abcdef);
- ASSERT_EQ(controller_->GetControllerLocalExtendedFeaturesMaxPageNumber(), 0x02);
- ASSERT_EQ(controller_->GetControllerLocalExtendedFeatures(0), 0x012345678abcdef);
- ASSERT_EQ(controller_->GetControllerLocalExtendedFeatures(1), 0x012345678abcdf0);
- ASSERT_EQ(controller_->GetControllerLocalExtendedFeatures(2), 0x012345678abcdf1);
- ASSERT_EQ(controller_->GetControllerLocalExtendedFeatures(100), 0x00);
- ASSERT_EQ(controller_->GetControllerLeBufferSize().le_data_packet_length_, 0x16);
- ASSERT_EQ(controller_->GetControllerLeBufferSize().total_num_le_packets_, 0x08);
- ASSERT_EQ(controller_->GetControllerLeLocalSupportedFeatures(), 0x001f123456789abc);
- ASSERT_EQ(controller_->GetControllerLeSupportedStates(), 0x001f123456789abe);
- ASSERT_EQ(controller_->GetControllerLeMaximumDataLength().supported_max_tx_octets_, 0x12);
- ASSERT_EQ(controller_->GetControllerLeMaximumDataLength().supported_max_rx_octets_, 0x56);
- ASSERT_EQ(controller_->GetControllerLeMaximumAdvertisingDataLength(), 0x0672);
- ASSERT_EQ(controller_->GetControllerLeNumberOfSupportedAdverisingSets(), 0xF0);
+ ASSERT_EQ(controller_->GetLeBufferSize().le_data_packet_length_, 0x16);
+ ASSERT_EQ(controller_->GetLeBufferSize().total_num_le_packets_, 0x08);
+ ASSERT_EQ(controller_->GetLeSupportedStates(), 0x001f123456789abe);
+ ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_tx_octets_, 0x12);
+ ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_tx_time_, 0x34);
+ ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_rx_octets_, 0x56);
+ ASSERT_EQ(controller_->GetLeMaximumDataLength().supported_max_rx_time_, 0x78);
+ ASSERT_EQ(controller_->GetLeMaximumAdvertisingDataLength(), 0x0672);
+ ASSERT_EQ(controller_->GetLeNumberOfSupportedAdverisingSets(), 0xF0);
}
TEST_F(ControllerTest, read_write_local_name) {
- ASSERT_EQ(controller_->GetControllerLocalName(), "DUT");
+ ASSERT_EQ(controller_->GetLocalName(), "DUT");
controller_->WriteLocalName("New name");
- ASSERT_EQ(controller_->GetControllerLocalName(), "New name");
+ ASSERT_EQ(controller_->GetLocalName(), "New name");
}
TEST_F(ControllerTest, send_set_event_mask_command) {
@@ -340,7 +333,7 @@ TEST_F(ControllerTest, send_reset_command) {
controller_->Reset();
auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
auto command = ResetView::Create(packet);
- ASSERT(command.IsValid());
+ ASSERT_TRUE(command.IsValid());
}
TEST_F(ControllerTest, send_set_event_filter_command) {
@@ -349,7 +342,7 @@ TEST_F(ControllerTest, send_set_event_filter_command) {
auto set_event_filter_view1 = SetEventFilterView::Create(packet);
auto set_event_filter_inquiry_result_view1 = SetEventFilterInquiryResultView::Create(set_event_filter_view1);
auto command1 = SetEventFilterInquiryResultAllDevicesView::Create(set_event_filter_inquiry_result_view1);
- ASSERT(command1.IsValid());
+ ASSERT_TRUE(command1.IsValid());
ClassOfDevice class_of_device({0xab, 0xcd, 0xef});
ClassOfDevice class_of_device_mask({0x12, 0x34, 0x56});
@@ -358,7 +351,7 @@ TEST_F(ControllerTest, send_set_event_filter_command) {
auto set_event_filter_view2 = SetEventFilterView::Create(packet);
auto set_event_filter_inquiry_result_view2 = SetEventFilterInquiryResultView::Create(set_event_filter_view2);
auto command2 = SetEventFilterInquiryResultClassOfDeviceView::Create(set_event_filter_inquiry_result_view2);
- ASSERT(command2.IsValid());
+ ASSERT_TRUE(command2.IsValid());
ASSERT_EQ(command2.GetClassOfDevice(), class_of_device);
Address bdaddr({0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc});
@@ -367,7 +360,7 @@ TEST_F(ControllerTest, send_set_event_filter_command) {
auto set_event_filter_view3 = SetEventFilterView::Create(packet);
auto set_event_filter_connection_setup_view = SetEventFilterConnectionSetupView::Create(set_event_filter_view3);
auto command3 = SetEventFilterConnectionSetupAddressView::Create(set_event_filter_connection_setup_view);
- ASSERT(command3.IsValid());
+ ASSERT_TRUE(command3.IsValid());
ASSERT_EQ(command3.GetAddress(), bdaddr);
}
@@ -375,7 +368,7 @@ TEST_F(ControllerTest, send_host_buffer_size_command) {
controller_->HostBufferSize(0xFF00, 0xF1, 0xFF02, 0xFF03);
auto packet = test_hci_layer_->GetCommand(OpCode::HOST_BUFFER_SIZE);
auto command = HostBufferSizeView::Create(packet);
- ASSERT(command.IsValid());
+ ASSERT_TRUE(command.IsValid());
ASSERT_EQ(command.GetHostAclDataPacketLength(), 0xFF00);
ASSERT_EQ(command.GetHostSynchronousDataPacketLength(), 0xF1);
ASSERT_EQ(command.GetHostTotalNumAclDataPackets(), 0xFF02);
@@ -383,11 +376,12 @@ TEST_F(ControllerTest, send_host_buffer_size_command) {
}
TEST_F(ControllerTest, send_le_set_event_mask_command) {
- controller_->LeSetEventMask(0x000000000000001F);
- auto packet = test_hci_layer_->GetCommand(OpCode::LE_SET_EVENT_MASK);
- auto command = LeSetEventMaskView::Create(packet);
- ASSERT(command.IsValid());
- ASSERT_EQ(command.GetLeEventMask(), 0x000000000000001F);
+ uint64_t new_le_event_mask = test_hci_layer_->event_mask - 1;
+ controller_->LeSetEventMask(new_le_event_mask);
+ // Send another command to make sure it was applied
+ controller_->Reset();
+ auto packet = test_hci_layer_->GetCommand(OpCode::RESET);
+ ASSERT_EQ(new_le_event_mask, test_hci_layer_->le_event_mask);
}
TEST_F(ControllerTest, is_supported_test) {
@@ -400,36 +394,32 @@ TEST_F(ControllerTest, is_supported_test) {
}
TEST_F(ControllerTest, feature_spec_version_055_test) {
- EXPECT_EQ(controller_->GetControllerVendorCapabilities().version_supported_, 55);
+ EXPECT_EQ(controller_->GetVendorCapabilities().version_supported_, 55);
EXPECT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
- EXPECT_FALSE(controller_->IsSupported(OpCode::LE_TRACK_ADV));
EXPECT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
EXPECT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
feature_spec_version = 95;
}
TEST_F(ControllerTest, feature_spec_version_095_test) {
- EXPECT_EQ(controller_->GetControllerVendorCapabilities().version_supported_, 95);
+ EXPECT_EQ(controller_->GetVendorCapabilities().version_supported_, 95);
EXPECT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
- EXPECT_TRUE(controller_->IsSupported(OpCode::LE_TRACK_ADV));
EXPECT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
EXPECT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
feature_spec_version = 96;
}
TEST_F(ControllerTest, feature_spec_version_096_test) {
- EXPECT_EQ(controller_->GetControllerVendorCapabilities().version_supported_, 96);
+ EXPECT_EQ(controller_->GetVendorCapabilities().version_supported_, 96);
EXPECT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
- EXPECT_TRUE(controller_->IsSupported(OpCode::LE_TRACK_ADV));
EXPECT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
EXPECT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
feature_spec_version = 98;
}
TEST_F(ControllerTest, feature_spec_version_098_test) {
- EXPECT_EQ(controller_->GetControllerVendorCapabilities().version_supported_, 98);
+ EXPECT_EQ(controller_->GetVendorCapabilities().version_supported_, 98);
EXPECT_TRUE(controller_->IsSupported(OpCode::LE_MULTI_ADVT));
- EXPECT_TRUE(controller_->IsSupported(OpCode::LE_TRACK_ADV));
EXPECT_FALSE(controller_->IsSupported(OpCode::CONTROLLER_DEBUG_INFO));
EXPECT_TRUE(controller_->IsSupported(OpCode::CONTROLLER_A2DP_OPCODE));
}
@@ -453,13 +443,25 @@ void CheckReceivedCredits(uint16_t handle, uint16_t credits) {
}
TEST_F(ControllerTest, aclCreditCallbacksTest) {
- controller_->RegisterCompletedAclPacketsCallback(common::Bind(&CheckReceivedCredits), client_handler_);
+ controller_->RegisterCompletedAclPacketsCallback(client_handler_->Bind(&CheckReceivedCredits));
test_hci_layer_->IncomingCredit();
credits1_set.get_future().wait();
credits2_set.get_future().wait();
}
+
+TEST_F(ControllerTest, aclCreditCallbackListenerUnregistered) {
+ os::Thread thread("test_thread", os::Thread::Priority::NORMAL);
+ os::Handler handler(&thread);
+ controller_->RegisterCompletedAclPacketsCallback(handler.Bind(&CheckReceivedCredits));
+
+ handler.Clear();
+ handler.WaitUntilStopped(std::chrono::milliseconds(100));
+ controller_->UnregisterCompletedAclPacketsCallback();
+
+ test_hci_layer_->IncomingCredit();
+}
} // namespace
} // namespace hci
} // namespace bluetooth
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-01 02:28:31 +0000