gd/security/channel/security_manager_channel_unittest.cc

/******************************************************************************
 *
 *  Copyright 2019 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 "security_manager_channel.h"

#include <gtest/gtest.h>

#include "hci/device.h"
#include "hci/device_database.h"
#include "hci/hci_packets.h"
#include "packet/raw_builder.h"
#include "security/smp_packets.h"
#include "security/test/fake_hci_layer.h"

namespace bluetooth {
namespace security {
namespace channel {
namespace {

using bluetooth::security::channel::SecurityManagerChannel;
using hci::AuthenticationRequirements;
using hci::CommandCompleteBuilder;
using hci::Device;
using hci::DeviceDatabase;
using hci::IoCapabilityRequestReplyBuilder;
using hci::IoCapabilityRequestView;
using hci::OobDataPresent;
using hci::OpCode;
using os::Handler;
using os::Thread;
using packet::RawBuilder;

static DeviceDatabase kDeviceDatabase;

class SecurityManagerChannelCallback : public ISecurityManagerChannelListener {
 public:
  // HCI
  bool receivedChangeConnectionLinkKeyComplete = false;
  bool receivedMasterLinkKeyComplete = false;
  bool receivedPinCodeRequest = false;
  bool receivedLinkKeyRequest = false;
  bool receivedLinkKeyNotification = false;
  bool receivedIoCapabilityRequest = false;
  bool receivedIoCapabilityResponse = false;
  bool receivedSimplePairingComplete = false;
  bool receivedReturnLinkKeys = false;
  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) {
    EXPECT_TRUE(packet.IsValid());
    receivedChangeConnectionLinkKeyComplete = true;
  }
  void OnMasterLinkKeyComplete(std::shared_ptr<hci::Device> device, hci::MasterLinkKeyCompleteView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedMasterLinkKeyComplete = true;
  }
  void OnPinCodeRequest(std::shared_ptr<hci::Device> device, hci::PinCodeRequestView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedPinCodeRequest = true;
  }
  void OnLinkKeyRequest(std::shared_ptr<hci::Device> device, hci::LinkKeyRequestView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedLinkKeyRequest = true;
  }
  void OnLinkKeyNotification(std::shared_ptr<hci::Device> device, hci::LinkKeyNotificationView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedLinkKeyNotification = true;
  }
  void OnIoCapabilityRequest(std::shared_ptr<Device> device, hci::IoCapabilityRequestView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedIoCapabilityRequest = true;
  }
  void OnIoCapabilityResponse(std::shared_ptr<Device> device, hci::IoCapabilityResponseView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedIoCapabilityResponse = true;
  }
  void OnSimplePairingComplete(std::shared_ptr<Device> device, hci::SimplePairingCompleteView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedSimplePairingComplete = true;
  }
  void OnReturnLinkKeys(std::shared_ptr<Device> device, hci::ReturnLinkKeysView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedReturnLinkKeys = true;
  }
  void OnEncryptionChange(std::shared_ptr<Device> device, hci::EncryptionChangeView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedEncryptionChange = true;
  }
  void OnEncryptionKeyRefreshComplete(std::shared_ptr<Device> device, hci::EncryptionKeyRefreshCompleteView packet) {
    EXPECT_TRUE(packet.IsValid());
    receivedEncryptionKeyRefreshComplete = true;
  }
  void OnRemoteOobDataRequest(std::shared_ptr<Device> device, hci::RemoteOobDataRequestView packet) {
    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 {
 protected:
  void SetUp() override {
    device_ = kDeviceDatabase.CreateClassicDevice(hci::Address({0x01, 0x02, 0x03, 0x04, 0x05, 0x06}));
    handler_ = new Handler(&thread_);
    callback_ = new SecurityManagerChannelCallback();
    hci_layer_ = new FakeHciLayer();
    fake_registry_.InjectTestModule(&FakeHciLayer::Factory, hci_layer_);
    fake_registry_.Start<FakeHciLayer>(&thread_);
    channel_ = new SecurityManagerChannel(handler_, hci_layer_);
    channel_->SetChannelListener(callback_);
  }

  void TearDown() override {
    channel_->SetChannelListener(nullptr);
    handler_->Clear();
    fake_registry_.SynchronizeModuleHandler(&FakeHciLayer::Factory, std::chrono::milliseconds(20));
    fake_registry_.StopAll();
    delete handler_;
    delete channel_;
    delete callback_;
  }

  TestModuleRegistry fake_registry_;
  Thread& thread_ = fake_registry_.GetTestThread();
  Handler* handler_ = nullptr;
  FakeHciLayer* hci_layer_ = nullptr;
  SecurityManagerChannel* channel_ = nullptr;
  SecurityManagerChannelCallback* callback_ = nullptr;
  std::shared_ptr<Device> device_ = nullptr;
};

TEST_F(SecurityManagerChannelTest, setup_teardown) {}

TEST_F(SecurityManagerChannelTest, recv_io_cap_request) {
  hci_layer_->IncomingEvent(hci::IoCapabilityRequestBuilder::Create(device_->GetAddress()));
  EXPECT_TRUE(callback_->receivedIoCapabilityRequest);
}

TEST_F(SecurityManagerChannelTest, send_io_cap_request_reply) {
  // Arrange
  hci::IoCapability io_capability = (hci::IoCapability)0x00;
  OobDataPresent oob_present = (OobDataPresent)0x00;
  AuthenticationRequirements authentication_requirements = (AuthenticationRequirements)0x00;
  auto packet = hci::IoCapabilityRequestReplyBuilder::Create(device_->GetAddress(), io_capability, oob_present,
                                                             authentication_requirements);

  // 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::IO_CAPABILITY_REQUEST_REPLY, packet_view.GetOpCode());
}

TEST_F(SecurityManagerChannelTest, send_io_cap_request_neg_reply) {
  // Arrange
  auto packet =
      hci::IoCapabilityRequestNegativeReplyBuilder::Create(device_->GetAddress(), hci::ErrorCode::COMMAND_DISALLOWED);

  // 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::IO_CAPABILITY_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
}

TEST_F(SecurityManagerChannelTest, recv_io_cap_response) {
  hci::IoCapability io_capability = (hci::IoCapability)0x00;
  OobDataPresent oob_present = (OobDataPresent)0x00;
  AuthenticationRequirements authentication_requirements = (AuthenticationRequirements)0x00;
  hci_layer_->IncomingEvent(hci::IoCapabilityResponseBuilder::Create(device_->GetAddress(), io_capability, oob_present,
                                                                     authentication_requirements));
  EXPECT_TRUE(callback_->receivedIoCapabilityResponse);
}

TEST_F(SecurityManagerChannelTest, recv_pin_code_request) {
  hci_layer_->IncomingEvent(hci::PinCodeRequestBuilder::Create(device_->GetAddress()));
  EXPECT_TRUE(callback_->receivedPinCodeRequest);
}

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);

  // 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::PIN_CODE_REQUEST_REPLY, packet_view.GetOpCode());
}

TEST_F(SecurityManagerChannelTest, send_pin_code_request_neg_reply) {
  // Arrange
  auto packet = hci::PinCodeRequestNegativeReplyBuilder::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::PIN_CODE_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
}

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_user_confirmation_request_reply) {
  // Arrange
  auto packet = hci::UserConfirmationRequestReplyBuilder::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::USER_CONFIRMATION_REQUEST_REPLY, packet_view.GetOpCode());
}

TEST_F(SecurityManagerChannelTest, send_user_confirmation_request_neg_reply) {
  // Arrange
  auto packet = hci::UserConfirmationRequestNegativeReplyBuilder::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::USER_CONFIRMATION_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
}

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

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);

  // 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::REMOTE_OOB_DATA_REQUEST_REPLY, packet_view.GetOpCode());
}

TEST_F(SecurityManagerChannelTest, send_remote_oob_data_request_neg_reply) {
  // Arrange
  auto packet = hci::RemoteOobDataRequestNegativeReplyBuilder::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::REMOTE_OOB_DATA_REQUEST_NEGATIVE_REPLY, packet_view.GetOpCode());
}

TEST_F(SecurityManagerChannelTest, send_read_local_oob_data) {
  // Arrange
  auto packet = hci::ReadLocalOobDataBuilder::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_LOCAL_OOB_DATA, packet_view.GetOpCode());
}

TEST_F(SecurityManagerChannelTest, send_read_local_oob_extended_data) {
  // Arrange
  auto packet = hci::ReadLocalOobExtendedDataBuilder::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_LOCAL_OOB_EXTENDED_DATA, packet_view.GetOpCode());
}

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
}  // namespace security
}  // namespace bluetooth