Merge "SecurityManagerChannel: Unit tests" (845cfc42) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/hci_packets.pdl

+21 −2

Original line number	Diff line number	Diff line
		@@ -3026,8 +3026,15 @@ packet ModeChange : EventPacket (event_code = MODE_CHANGE){
		interval : 16, // 0x002 - 0xFFFE (1.25ms - 40.9s)
		}

		struct ZeroKeyAndAddress {
		address : Address,
		_fixed_ = 0 : 64,
		_fixed_ = 0 : 64,
		}

		packet ReturnLinkKeys : EventPacket (event_code = RETURN_LINK_KEYS){
		_payload_, // placeholder (unimplemented)
		_count_(keys) : 8,
		keys : ZeroKeyAndAddress[],
		}

		packet PinCodeRequest : EventPacket (event_code = PIN_CODE_REQUEST){
		@@ -3038,8 +3045,20 @@ packet LinkKeyRequest : EventPacket (event_code = LINK_KEY_REQUEST){
		bd_addr : Address,
		}

		enum KeyType : 8 {
		COMBINATION = 0x00,
		DEBUG_COMBINATION = 0x03,
		UNAUTHENTICATED_P192 = 0x04,
		AUTHENTICATED_P192 = 0x05,
		CHANGED = 0x06,
		UNAUTHENTICATED_P256 = 0x07,
		AUTHENTICATED_P256 = 0x08,
		}

		packet LinkKeyNotification : EventPacket (event_code = LINK_KEY_NOTIFICATION){
		_payload_, // placeholder (unimplemented)
		bd_addr : Address,
		link_key : 8[16],
		key_type : KeyType,
		}

		packet LoopbackCommand : EventPacket (event_code = LOOPBACK_COMMAND){

system/gd/security/channel/security_manager_channel.cc

+3 −3

Original line number	Diff line number	Diff line
		@@ -39,7 +39,7 @@ void SecurityManagerChannel::OnHciEventReceived(EventPacketView packet) {
		ASSERT_LOG(listener_ != nullptr, "No listener set!");
		std::shared_ptr<Device> device = nullptr;
		auto event = EventPacketView::Create(std::move(packet));
		ASSERT_LOG(event.IsValid(), "Received invalid packet: %hhx", event.GetEventCode());
		ASSERT_LOG(event.IsValid(), "Received invalid packet");
		const hci::EventCode code = event.GetEventCode();
		switch (code) {
		case hci::EventCode::CHANGE_CONNECTION_LINK_KEY_COMPLETE:
		@@ -81,10 +81,10 @@ void SecurityManagerChannel::OnHciEventReceived(EventPacketView packet) {
		listener_->OnRemoteOobDataRequest(device, hci::RemoteOobDataRequestView::Create(std::move(event)));
		break;
		case hci::EventCode::USER_PASSKEY_NOTIFICATION:
		// listener_->OnUserPasskeyNotification(device, <packet>);
		listener_->OnUserPasskeyNotification(device, hci::UserPasskeyNotificationView::Create(std::move(event)));
		break;
		case hci::EventCode::KEYPRESS_NOTIFICATION:
		// listener_->OnSendKeypressNotification(device, <packet>);
		listener_->OnKeypressNotification(device, hci::KeypressNotificationView::Create(std::move(event)));
		break;
		default:
		ASSERT_LOG(false, "Invalid packet received: %hhx", code);

system/gd/security/channel/security_manager_channel.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -55,6 +55,9 @@ class ISecurityManagerChannelListener {
		virtual void OnEncryptionKeyRefreshComplete(std::shared_ptr<hci::Device> device,
		hci::EncryptionKeyRefreshCompleteView packet) = 0;
		virtual void OnRemoteOobDataRequest(std::shared_ptr<hci::Device> device, hci::RemoteOobDataRequestView packet) = 0;
		virtual void OnUserPasskeyNotification(std::shared_ptr<hci::Device> device,
		hci::UserPasskeyNotificationView packet) = 0;
		virtual void OnKeypressNotification(std::shared_ptr<hci::Device> device, hci::KeypressNotificationView packet) = 0;
		};

		/**

system/gd/security/channel/security_manager_channel_unittest.cc

+324 −42

Original line number	Diff line number	Diff line
		@@ -46,21 +46,6 @@ using packet::RawBuilder;

		static DeviceDatabase kDeviceDatabase;

		class TestPayloadBuilder : public PacketBuilder<kLittleEndian> {
		public:
		~TestPayloadBuilder() override = default;
		size_t size() const override {
		return 1;
		}
		void Serialize(BitInserter& inserter) const override {}
		static std::unique_ptr<TestPayloadBuilder> Create() {
		return std::unique_ptr<TestPayloadBuilder>(new TestPayloadBuilder());
		}

		private:
		TestPayloadBuilder() : PacketBuilder<kLittleEndian>(){};
		};

		class SecurityManagerChannelCallback : public ISecurityManagerChannelListener {
		public:
		// HCI
		@@ -76,6 +61,8 @@ class SecurityManagerChannelCallback : public ISecurityManagerChannelListener {
		bool receivedEncryptionChange = false;
		bool receivedEncryptionKeyRefreshComplete = false;
		bool receivedRemoteOobDataRequest = false;
		bool receivedUserPasskeyNotification = false;
		bool receivedKeypressNotification = false;

		void OnChangeConnectionLinkKeyComplete(std::shared_ptr<hci::Device> device,
		hci::ChangeConnectionLinkKeyCompleteView packet) {
		@@ -126,6 +113,14 @@ class SecurityManagerChannelCallback : public ISecurityManagerChannelListener {
		EXPECT_TRUE(packet.IsValid());
		receivedRemoteOobDataRequest = true;
		}
		void OnUserPasskeyNotification(std::shared_ptr<hci::Device> device, hci::UserPasskeyNotificationView packet) {
		EXPECT_TRUE(packet.IsValid());
		receivedUserPasskeyNotification = true;
		}
		void OnKeypressNotification(std::shared_ptr<hci::Device> device, hci::KeypressNotificationView packet) {
		EXPECT_TRUE(packet.IsValid());
		receivedKeypressNotification = true;
		}
		};

		class SecurityManagerChannelTest : public ::testing::Test {
		@@ -216,59 +211,346 @@ TEST_F(SecurityManagerChannelTest, recv_pin_code_request) {
		EXPECT_TRUE(callback_->receivedPinCodeRequest);
		}

		TEST_F(SecurityManagerChannelTest, send_pin_code_request_reply) {}
		TEST_F(SecurityManagerChannelTest, send_pin_code_request_reply) {
		// Arrange
		uint8_t pin_code_length = 6;
		std::array<uint8_t, 16> pin_code = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
		auto packet = hci::PinCodeRequestReplyBuilder::Create(device_->GetAddress(), pin_code_length, pin_code);

		TEST_F(SecurityManagerChannelTest, send_pin_code_request_neg_reply) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, recv_user_passkey_notification) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::PIN_CODE_REQUEST_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_user_confirmation_request_reply) {}
		TEST_F(SecurityManagerChannelTest, send_pin_code_request_neg_reply) {
		// Arrange
		auto packet = hci::PinCodeRequestNegativeReplyBuilder::Create(device_->GetAddress());

		TEST_F(SecurityManagerChannelTest, send_user_confirmation_request_neg_reply) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, recv_remote_oob_data_request) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::PIN_CODE_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_remote_oob_data_request_reply) {}
		TEST_F(SecurityManagerChannelTest, recv_user_passkey_notification) {
		uint32_t passkey = 0x00;
		hci_layer_->IncomingEvent(hci::UserPasskeyNotificationBuilder::Create(device_->GetAddress(), passkey));
		EXPECT_TRUE(callback_->receivedUserPasskeyNotification);
		}

		TEST_F(SecurityManagerChannelTest, send_remote_oob_data_request_neg_reply) {}
		TEST_F(SecurityManagerChannelTest, send_user_confirmation_request_reply) {
		// Arrange
		auto packet = hci::UserConfirmationRequestReplyBuilder::Create(device_->GetAddress());

		TEST_F(SecurityManagerChannelTest, send_read_local_oob_data) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, send_read_local_oob_extended_data) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, recv_link_key_request) {}
		TEST_F(SecurityManagerChannelTest, send_user_confirmation_request_neg_reply) {
		// Arrange
		auto packet = hci::UserConfirmationRequestNegativeReplyBuilder::Create(device_->GetAddress());

		TEST_F(SecurityManagerChannelTest, recv_link_key_notification) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, recv_master_link_complete) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::USER_CONFIRMATION_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, recv_change_connection_link_key_complete) {}
		TEST_F(SecurityManagerChannelTest, recv_remote_oob_data_request) {
		hci_layer_->IncomingEvent(hci::RemoteOobDataRequestBuilder::Create(device_->GetAddress()));
		EXPECT_TRUE(callback_->receivedRemoteOobDataRequest);
		}

		TEST_F(SecurityManagerChannelTest, recv_return_link_keys) {}
		TEST_F(SecurityManagerChannelTest, send_remote_oob_data_request_reply) {
		// Arrange
		std::array<uint8_t, 16> c = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
		std::array<uint8_t, 16> r = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
		auto packet = hci::RemoteOobDataRequestReplyBuilder::Create(device_->GetAddress(), c, r);

		TEST_F(SecurityManagerChannelTest, send_link_key_reply) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, send_link_key_neg_reply) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::REMOTE_OOB_DATA_REQUEST_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_read_stored_link_key) {}
		TEST_F(SecurityManagerChannelTest, send_remote_oob_data_request_neg_reply) {
		// Arrange
		auto packet = hci::RemoteOobDataRequestNegativeReplyBuilder::Create(device_->GetAddress());

		TEST_F(SecurityManagerChannelTest, send_write_stored_link_key) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, send_delete_stored_link_key) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::REMOTE_OOB_DATA_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, recv_encryption_change) {}
		TEST_F(SecurityManagerChannelTest, send_read_local_oob_data) {
		// Arrange
		auto packet = hci::ReadLocalOobDataBuilder::Create();

		TEST_F(SecurityManagerChannelTest, send_refresh_encryption_key) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, send_read_encryption_key_size) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::READ_LOCAL_OOB_DATA, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, recv_simple_pairing_complete) {}
		TEST_F(SecurityManagerChannelTest, send_read_local_oob_extended_data) {
		// Arrange
		auto packet = hci::ReadLocalOobExtendedDataBuilder::Create();

		TEST_F(SecurityManagerChannelTest, send_read_simple_pairing_mode) {}
		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		TEST_F(SecurityManagerChannelTest, send_write_simple_pairing_mode) {}
		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::READ_LOCAL_OOB_EXTENDED_DATA, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_keypress_notification) {}
		TEST_F(SecurityManagerChannelTest, recv_link_key_request) {
		hci_layer_->IncomingEvent(hci::LinkKeyRequestBuilder::Create(device_->GetAddress()));
		EXPECT_TRUE(callback_->receivedLinkKeyRequest);
		}

		TEST_F(SecurityManagerChannelTest, recv_link_key_notification) {
		std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
		hci_layer_->IncomingEvent(
		hci::LinkKeyNotificationBuilder::Create(device_->GetAddress(), link_key, hci::KeyType::DEBUG_COMBINATION));
		EXPECT_TRUE(callback_->receivedLinkKeyNotification);
		}

		TEST_F(SecurityManagerChannelTest, recv_master_link_key_complete) {
		uint16_t connection_handle = 0x0;
		hci_layer_->IncomingEvent(
		hci::MasterLinkKeyCompleteBuilder::Create(hci::ErrorCode::SUCCESS, connection_handle, hci::KeyFlag::TEMPORARY));
		EXPECT_TRUE(callback_->receivedMasterLinkKeyComplete);
		}

		TEST_F(SecurityManagerChannelTest, recv_change_connection_link_key_complete) {
		uint16_t connection_handle = 0x0;
		hci_layer_->IncomingEvent(
		hci::ChangeConnectionLinkKeyCompleteBuilder::Create(hci::ErrorCode::SUCCESS, connection_handle));
		EXPECT_TRUE(callback_->receivedChangeConnectionLinkKeyComplete);
		}

		TEST_F(SecurityManagerChannelTest, recv_return_link_keys) {
		std::vector<hci::ZeroKeyAndAddress> keys;
		hci_layer_->IncomingEvent(hci::ReturnLinkKeysBuilder::Create(keys));
		EXPECT_TRUE(callback_->receivedReturnLinkKeys);
		}

		TEST_F(SecurityManagerChannelTest, send_link_key_request_reply) {
		// Arrange
		std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
		auto packet = hci::LinkKeyRequestReplyBuilder::Create(device_->GetAddress(), link_key);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::LINK_KEY_REQUEST_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_link_key_request_neg_reply) {
		// Arrange
		auto packet = hci::LinkKeyRequestNegativeReplyBuilder::Create(device_->GetAddress());

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_read_stored_link_key) {
		// Arrange
		auto packet = hci::ReadStoredLinkKeyBuilder::Create(device_->GetAddress(), hci::ReadStoredLinkKeyReadAllFlag::ALL);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::READ_STORED_LINK_KEY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_write_stored_link_key) {
		// Arrange
		std::vector<hci::KeyAndAddress> keys_to_write;
		auto packet = hci::WriteStoredLinkKeyBuilder::Create(keys_to_write);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::WRITE_STORED_LINK_KEY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_delete_stored_link_key) {
		// Arrange
		auto packet =
		hci::DeleteStoredLinkKeyBuilder::Create(device_->GetAddress(), hci::DeleteStoredLinkKeyDeleteAllFlag::ALL);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::DELETE_STORED_LINK_KEY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, recv_encryption_change) {
		uint16_t connection_handle = 0x0;
		hci_layer_->IncomingEvent(
		hci::EncryptionChangeBuilder::Create(hci::ErrorCode::SUCCESS, connection_handle, hci::EncryptionEnabled::ON));
		EXPECT_TRUE(callback_->receivedEncryptionChange);
		}

		TEST_F(SecurityManagerChannelTest, send_refresh_encryption_key) {
		// Arrange
		uint16_t connection_handle = 0x0;
		auto packet = hci::RefreshEncryptionKeyBuilder::Create(connection_handle);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::REFRESH_ENCRYPTION_KEY, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_read_encryption_key_size) {
		// Arrange
		uint16_t connection_handle = 0x0;
		auto packet = hci::ReadEncryptionKeySizeBuilder::Create(connection_handle);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::READ_ENCRYPTION_KEY_SIZE, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, recv_simple_pairing_complete) {
		hci_layer_->IncomingEvent(hci::SimplePairingCompleteBuilder::Create(hci::ErrorCode::SUCCESS, device_->GetAddress()));
		EXPECT_TRUE(callback_->receivedSimplePairingComplete);
		}

		TEST_F(SecurityManagerChannelTest, send_read_simple_pairing_mode) {
		// Arrange
		auto packet = hci::ReadSimplePairingModeBuilder::Create();

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::READ_SIMPLE_PAIRING_MODE, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, send_write_simple_pairing_mode) {
		// Arrange
		auto packet = hci::WriteSimplePairingModeBuilder::Create(hci::Enable::ENABLED);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::WRITE_SIMPLE_PAIRING_MODE, packet_view.GetOpCode());
		}

		TEST_F(SecurityManagerChannelTest, recv_keypress_notification) {
		hci_layer_->IncomingEvent(
		hci::KeypressNotificationBuilder::Create(device_->GetAddress(), hci::KeypressNotificationType::ENTRY_COMPLETED));
		EXPECT_TRUE(callback_->receivedKeypressNotification);
		}

		TEST_F(SecurityManagerChannelTest, send_keypress_notification) {
		// Arrange
		auto packet =
		hci::SendKeypressNotificationBuilder::Create(device_->GetAddress(), hci::KeypressNotificationType::ENTRY_STARTED);

		// Act
		channel_->SendCommand(device_, std::move(packet));
		auto last_command = std::move(hci_layer_->GetLastCommand()->command);
		auto command_packet = GetPacketView(std::move(last_command));
		hci::CommandPacketView packet_view = hci::CommandPacketView::Create(command_packet);

		// Assert
		EXPECT_TRUE(packet_view.IsValid());
		EXPECT_EQ(OpCode::SEND_KEYPRESS_NOTIFICATION, packet_view.GetOpCode());
		}

		} // namespace
		} // namespace channel

system/gd/security/test/fake_hci_layer.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -96,7 +96,7 @@ class FakeHciLayer : public HciLayer {
		void IncomingEvent(std::unique_ptr<EventPacketBuilder> event_builder) {
		auto packet = GetPacketView(std::move(event_builder));
		EventPacketView event = EventPacketView::Create(packet);
		EXPECT_TRUE(event.IsValid());
		ASSERT_TRUE(event.IsValid());
		EventCode event_code = event.GetEventCode();
		EXPECT_TRUE(registered_events_.find(event_code) != registered_events_.end());
		registered_events_[event_code].Run(event);