Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cf93a989 authored by Myles Watson's avatar Myles Watson
Browse files

Use HciLayerFake in LeAddressManagerTest 

Bug: 301661850
Test: atest bluetooth_test_gd_unit
Flag: EXEMPT, test-only change
Change-Id: I544ff7709a416d3e9267cb2b9f341b542dc09ac1
parent da39eb58

system/gd/hci/le_address_manager_test.cc

+117 −176
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 


#include "common/init_flags.h"

#include "hci/hci_layer.h"

#include "hci/hci_layer_fake.h"

#include "hci/octets.h"

#include "os/log.h"

#include "packet/raw_builder.h"
@@ -28,20 +29,6 @@ using ::bluetooth::hci::Octet16; 
using ::bluetooth::os::Handler;

using ::bluetooth::os::Thread;



namespace {



using namespace bluetooth;



packet::PacketView<packet::kLittleEndian> GetPacketView(std::unique_ptr<packet::BasePacketBuilder> packet) {

  auto bytes = std::make_shared<std::vector<uint8_t>>();

  packet::BitInserter i(*bytes);

  bytes->reserve(packet->size());

  packet->Serialize(i);

  return packet::PacketView<packet::kLittleEndian>(bytes);

}



}  // namespace



namespace bluetooth {

namespace hci {

namespace {
@@ -50,82 +37,6 @@ using packet::kLittleEndian; 
using packet::PacketView;

using packet::RawBuilder;



class TestHciLayer : public HciLayer {

 public:

  void EnqueueCommand(

      std::unique_ptr<CommandBuilder> command,

      common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) override {

    std::lock_guard<std::mutex> lock(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;

    }

  }



  void SetCommandFuture() {

    ASSERT_EQ(command_promise_, nullptr) << "Promises, Promises, ... Only one at a time.";

    command_promise_ = std::make_unique<std::promise<void>>();

    command_future_ = std::make_unique<std::future<void>>(command_promise_->get_future());

  }



  CommandView GetLastCommand() {

    if (command_queue_.size() == 0) {

      return CommandView::Create(PacketView<kLittleEndian>(std::make_shared<std::vector<uint8_t>>()));

    }

    auto last = std::move(command_queue_.front());

    command_queue_.pop();

    return CommandView::Create(GetPacketView(std::move(last)));

  }



  CommandView GetCommand(OpCode op_code) {

    if (!command_queue_.empty()) {

      std::lock_guard<std::mutex> lock(mutex_);

      if (command_future_ != nullptr) {

        command_future_.reset();

        command_promise_.reset();

      }

    } else if (command_future_ != nullptr) {

      auto result = command_future_->wait_for(std::chrono::milliseconds(1000));

      EXPECT_NE(std::future_status::timeout, result);

    }

    std::lock_guard<std::mutex> lock(mutex_);

    ASSERT_LOG(

        !command_queue_.empty(), "Expecting command %s but command queue was empty", OpCodeText(op_code).c_str());

    CommandView command_packet_view = GetLastCommand();

    EXPECT_TRUE(command_packet_view.IsValid());

    EXPECT_EQ(command_packet_view.GetOpCode(), op_code);

    return command_packet_view;

  }



  void IncomingEvent(std::unique_ptr<EventBuilder> event_builder) {

    auto packet = GetPacketView(std::move(event_builder));

    EventView event = EventView::Create(packet);

    ASSERT_TRUE(event.IsValid());

    CommandCompleteCallback(event);

  }



  void CommandCompleteCallback(EventView event) {

    CommandCompleteView complete_view = CommandCompleteView::Create(event);

    ASSERT_TRUE(complete_view.IsValid());

    std::move(command_complete_callbacks.front()).Invoke(complete_view);

    command_complete_callbacks.pop_front();

  }



  void ListDependencies(ModuleList* /* list */) const {}

  void Start() override {}

  void Stop() override {}



 private:

  std::list<common::ContextualOnceCallback<void(CommandCompleteView)>> command_complete_callbacks;

  std::queue<std::unique_ptr<CommandBuilder>> command_queue_;

  std::unique_ptr<std::promise<void>> command_promise_;

  std::unique_ptr<std::future<void>> command_future_;

  mutable std::mutex mutex_;

};



class RotatorClient : public LeAddressManagerCallback {

 public:

  RotatorClient(LeAddressManager* le_address_manager, size_t id) : le_address_manager_(le_address_manager), id_(id){};
@@ -165,7 +76,7 @@ class LeAddressManagerTest : public ::testing::Test { 
  void SetUp() override {

    thread_ = new Thread("thread", Thread::Priority::NORMAL);

    handler_ = new Handler(thread_);

    test_hci_layer_ = new TestHciLayer;

    hci_layer_ = new HciLayerFake();

    Address address({0x01, 0x02, 0x03, 0x04, 0x05, 0x06});

    le_address_manager_ = new LeAddressManager(

        common::Bind(&LeAddressManagerTest::enqueue_command, common::Unretained(this)), handler_, address, 0x3F, 0x3F);
@@ -183,7 +94,7 @@ class LeAddressManagerTest : public ::testing::Test { 
  void TearDown() override {

    sync_handler(handler_);

    delete le_address_manager_;

    delete test_hci_layer_;

    delete hci_layer_;

    handler_->Clear();

    delete handler_;

    delete thread_;
@@ -197,14 +108,15 @@ class LeAddressManagerTest : public ::testing::Test { 
  }



  void enqueue_command(std::unique_ptr<CommandBuilder> command_packet) {

    test_hci_layer_->EnqueueCommand(

    hci_layer_->EnqueueCommand(

        std::move(command_packet),

        handler_->BindOnce(&LeAddressManager::OnCommandComplete, common::Unretained(le_address_manager_)));

        handler_->BindOnce(

            &LeAddressManager::OnCommandComplete, common::Unretained(le_address_manager_)));

  }



  Thread* thread_;

  Handler* handler_;

  TestHciLayer* test_hci_layer_ = nullptr;

  HciLayerFake* hci_layer_ = nullptr;

  LeAddressManager* le_address_manager_;

  std::vector<std::unique_ptr<RotatorClient>> clients;

};
@@ -231,11 +143,10 @@ TEST_F(LeAddressManagerTest, rotator_address_for_single_client) { 
      minimum_rotation_time,

      maximum_rotation_time);



  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->Register(clients[0].get());

  sync_handler(handler_);

  test_hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);

  test_hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);

  hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  clients[0].get()->WaitForResume();

  le_address_manager_->Unregister(clients[0].get());

  sync_handler(handler_);
@@ -254,11 +165,10 @@ TEST_F(LeAddressManagerTest, rotator_non_resolvable_address_for_single_client) { 
      minimum_rotation_time,

      maximum_rotation_time);



  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->Register(clients[0].get());

  sync_handler(handler_);

  test_hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);

  test_hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);

  hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  clients[0].get()->WaitForResume();

  le_address_manager_->Unregister(clients[0].get());

  sync_handler(handler_);
@@ -295,7 +205,7 @@ class LeAddressManagerWithSingleClientTest : public LeAddressManagerTest { 
    bluetooth::common::InitFlags::SetAllForTesting();

    thread_ = new Thread("thread", Thread::Priority::NORMAL);

    handler_ = new Handler(thread_);

    test_hci_layer_ = new TestHciLayer;

    hci_layer_ = new HciLayerFake();

    Address address({0x01, 0x02, 0x03, 0x04, 0x05, 0x06});

    le_address_manager_ = new LeAddressManager(

        common::Bind(&LeAddressManagerWithSingleClientTest::enqueue_command, common::Unretained(this)),
@@ -317,24 +227,24 @@ class LeAddressManagerWithSingleClientTest : public LeAddressManagerTest { 
        minimum_rotation_time,

        maximum_rotation_time);



    ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

    le_address_manager_->Register(clients[0].get());

    sync_handler(handler_);

    test_hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);

    test_hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->GetCommand(OpCode::LE_SET_RANDOM_ADDRESS);

    hci_layer_->IncomingEvent(LeSetRandomAddressCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }



  void enqueue_command(std::unique_ptr<CommandBuilder> command_packet) {

    test_hci_layer_->EnqueueCommand(

    hci_layer_->EnqueueCommand(

        std::move(command_packet),

        handler_->BindOnce(&LeAddressManager::OnCommandComplete, common::Unretained(le_address_manager_)));

        handler_->BindOnce(

            &LeAddressManager::OnCommandComplete, common::Unretained(le_address_manager_)));

  }



  void TearDown() override {

    le_address_manager_->Unregister(clients[0].get());

    sync_handler(handler_);

    delete le_address_manager_;

    delete test_hci_layer_;

    delete hci_layer_;

    handler_->Clear();

    delete handler_;

    delete thread_;
@@ -344,51 +254,51 @@ class LeAddressManagerWithSingleClientTest : public LeAddressManagerTest { 
TEST_F(LeAddressManagerWithSingleClientTest, add_device_to_connect_list) {

  Address address;

  Address::FromString("01:02:03:04:05:06", address);

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);

  auto packet = test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  auto packet = hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  auto packet_view = LeAddDeviceToFilterAcceptListView::Create(

      LeConnectionManagementCommandView::Create(AclCommandView::Create(packet)));

  ASSERT_TRUE(packet_view.IsValid());

  ASSERT_EQ(FilterAcceptListAddressType::RANDOM, packet_view.GetAddressType());

  ASSERT_EQ(address, packet_view.GetAddress());



  test_hci_layer_->IncomingEvent(LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->IncomingEvent(

      LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  clients[0].get()->WaitForResume();

}



TEST_F(LeAddressManagerWithSingleClientTest, remove_device_from_connect_list) {

  Address address;

  Address::FromString("01:02:03:04:05:06", address);

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);

  test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  test_hci_layer_->IncomingEvent(LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  hci_layer_->IncomingEvent(

      LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));



  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->RemoveDeviceFromFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);

  auto packet = test_hci_layer_->GetCommand(OpCode::LE_REMOVE_DEVICE_FROM_FILTER_ACCEPT_LIST);

  auto packet = hci_layer_->GetCommand(OpCode::LE_REMOVE_DEVICE_FROM_FILTER_ACCEPT_LIST);

  auto packet_view = LeRemoveDeviceFromFilterAcceptListView::Create(

      LeConnectionManagementCommandView::Create(AclCommandView::Create(packet)));

  ASSERT_TRUE(packet_view.IsValid());

  ASSERT_EQ(FilterAcceptListAddressType::RANDOM, packet_view.GetAddressType());

  ASSERT_EQ(address, packet_view.GetAddress());

  test_hci_layer_->IncomingEvent(LeRemoveDeviceFromFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->IncomingEvent(

      LeRemoveDeviceFromFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  clients[0].get()->WaitForResume();

}



TEST_F(LeAddressManagerWithSingleClientTest, clear_filter_accept_list) {

  Address address;

  Address::FromString("01:02:03:04:05:06", address);

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);

  test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  test_hci_layer_->IncomingEvent(LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  hci_layer_->IncomingEvent(

      LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));



  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->ClearFilterAcceptList();

  test_hci_layer_->GetCommand(OpCode::LE_CLEAR_FILTER_ACCEPT_LIST);

  test_hci_layer_->IncomingEvent(LeClearFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_CLEAR_FILTER_ACCEPT_LIST);

  hci_layer_->IncomingEvent(

      LeClearFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  clients[0].get()->WaitForResume();

}
@@ -399,34 +309,34 @@ TEST_F(LeAddressManagerWithSingleClientTest, DISABLED_add_device_to_resolving_li 
  Octet16 peer_irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05, 0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};

  Octet16 local_irk = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};



  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->AddDeviceToResolvingList(

      PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS, address, peer_irk, local_irk);

  {

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet_view = LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(Enable::DISABLED, packet_view.GetAddressResolutionEnable());

    test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  {

    ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);

    auto packet = hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);

    auto packet_view = LeAddDeviceToResolvingListView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS, packet_view.GetPeerIdentityAddressType());

    ASSERT_EQ(address, packet_view.GetPeerIdentityAddress());

    ASSERT_EQ(peer_irk, packet_view.GetPeerIrk());

    ASSERT_EQ(local_irk, packet_view.GetLocalIrk());

    test_hci_layer_->IncomingEvent(LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  {

    ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet_view = LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(Enable::ENABLED, packet_view.GetAddressResolutionEnable());

    test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  clients[0].get()->WaitForResume();

}
@@ -436,44 +346,60 @@ TEST_F(LeAddressManagerWithSingleClientTest, DISABLED_remove_device_from_resolvi 
  Address address;

  Address::FromString("01:02:03:04:05:06", address);

  Octet16 peer_irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05, 0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};

  Octet16 local_irk = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  Octet16 local_irk = {

      0x01,

      0x02,

      0x03,

      0x04,

      0x05,

      0x06,

      0x07,

      0x08,

      0x09,

      0x0a,

      0x0b,

      0x0c,

      0x0d,

      0x0e,

      0x0f,

      0x10};

  le_address_manager_->AddDeviceToResolvingList(

      PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS, address, peer_irk, local_irk);

  test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);

  test_hci_layer_->IncomingEvent(LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));



  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  hci_layer_->IncomingEvent(

      LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);

  hci_layer_->IncomingEvent(

      LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  hci_layer_->IncomingEvent(

      LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));



  le_address_manager_->RemoveDeviceFromResolvingList(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS, address);

  {

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet_view = LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(Enable::DISABLED, packet_view.GetAddressResolutionEnable());

    test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  {

    ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_REMOVE_DEVICE_FROM_RESOLVING_LIST);

    auto packet = hci_layer_->GetCommand(OpCode::LE_REMOVE_DEVICE_FROM_RESOLVING_LIST);

    auto packet_view = LeRemoveDeviceFromResolvingListView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS, packet_view.GetPeerIdentityAddressType());

    ASSERT_EQ(address, packet_view.GetPeerIdentityAddress());

    test_hci_layer_->IncomingEvent(LeRemoveDeviceFromResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeRemoveDeviceFromResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  {

    ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet_view = LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(Enable::ENABLED, packet_view.GetAddressResolutionEnable());

    test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  clients[0].get()->WaitForResume();

}
@@ -483,42 +409,58 @@ TEST_F(LeAddressManagerWithSingleClientTest, DISABLED_clear_resolving_list) { 
  Address address;

  Address::FromString("01:02:03:04:05:06", address);

  Octet16 peer_irk = {0xec, 0x02, 0x34, 0xa3, 0x57, 0xc8, 0xad, 0x05, 0x34, 0x10, 0x10, 0xa6, 0x0a, 0x39, 0x7d, 0x9b};

  Octet16 local_irk = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  Octet16 local_irk = {

      0x01,

      0x02,

      0x03,

      0x04,

      0x05,

      0x06,

      0x07,

      0x08,

      0x09,

      0x0a,

      0x0b,

      0x0c,

      0x0d,

      0x0e,

      0x0f,

      0x10};

  le_address_manager_->AddDeviceToResolvingList(

      PeerAddressType::RANDOM_DEVICE_OR_IDENTITY_ADDRESS, address, peer_irk, local_irk);

  test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);

  test_hci_layer_->IncomingEvent(LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));



  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  hci_layer_->IncomingEvent(

      LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);

  hci_layer_->IncomingEvent(

      LeAddDeviceToResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

  hci_layer_->IncomingEvent(

      LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));



  le_address_manager_->ClearResolvingList();

  {

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet_view = LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(Enable::DISABLED, packet_view.GetAddressResolutionEnable());

    test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  {

    ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_CLEAR_RESOLVING_LIST);

    auto packet = hci_layer_->GetCommand(OpCode::LE_CLEAR_RESOLVING_LIST);

    auto packet_view = LeClearResolvingListView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    test_hci_layer_->IncomingEvent(LeClearResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeClearResolvingListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }

  {

    ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

    auto packet = test_hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet = hci_layer_->GetCommand(OpCode::LE_SET_ADDRESS_RESOLUTION_ENABLE);

    auto packet_view = LeSetAddressResolutionEnableView::Create(LeSecurityCommandView::Create(packet));

    ASSERT_TRUE(packet_view.IsValid());

    ASSERT_EQ(Enable::ENABLED, packet_view.GetAddressResolutionEnable());

    test_hci_layer_->IncomingEvent(LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

    hci_layer_->IncomingEvent(

        LeSetAddressResolutionEnableCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  }



  clients[0].get()->WaitForResume();
@@ -527,18 +469,17 @@ TEST_F(LeAddressManagerWithSingleClientTest, DISABLED_clear_resolving_list) { 
TEST_F(LeAddressManagerWithSingleClientTest, register_during_command_complete) {

  Address address;

  Address::FromString("01:02:03:04:05:06", address);

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->AddDeviceToFilterAcceptList(FilterAcceptListAddressType::RANDOM, address);

  auto packet = test_hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  auto packet = hci_layer_->GetCommand(OpCode::LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST);

  auto packet_view = LeAddDeviceToFilterAcceptListView::Create(

      LeConnectionManagementCommandView::Create(AclCommandView::Create(packet)));

  ASSERT_TRUE(packet_view.IsValid());

  ASSERT_EQ(FilterAcceptListAddressType::RANDOM, packet_view.GetAddressType());

  ASSERT_EQ(address, packet_view.GetAddress());

  test_hci_layer_->IncomingEvent(LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));

  hci_layer_->IncomingEvent(

      LeAddDeviceToFilterAcceptListCompleteBuilder::Create(0x01, ErrorCode::SUCCESS));



  AllocateClients(1);

  ASSERT_NO_FATAL_FAILURE(test_hci_layer_->SetCommandFuture());

  le_address_manager_->Register(clients[1].get());

  clients[0].get()->WaitForResume();

  clients[1].get()->WaitForResume();