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

Commit f90babf6 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "LE link_manager_test factor out user_handler"

parents 282c0993 5fd14304

system/gd/l2cap/le/internal/link_manager_test.cc

+28 −40
Original line number Diff line number Diff line
@@ -67,6 +67,7 @@ class L2capLeLinkManagerTest : public ::testing::Test { 
  void SetUp() override {

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

    l2cap_handler_ = new os::Handler(thread_);

    user_handler_ = new os::Handler(thread_);

    mock_parameter_provider_ = new MockParameterProvider;

    EXPECT_CALL(*mock_parameter_provider_, GetLeLinkIdleDisconnectTimeout)

        .WillRepeatedly(Return(kTestIdleDisconnectTimeoutLong));
@@ -76,11 +77,14 @@ class L2capLeLinkManagerTest : public ::testing::Test { 
    delete mock_parameter_provider_;

    l2cap_handler_->Clear();

    delete l2cap_handler_;

    user_handler_->Clear();

    delete user_handler_;

    delete thread_;

  }



  os::Thread* thread_ = nullptr;

  os::Handler* l2cap_handler_ = nullptr;

  os::Handler* user_handler_ = nullptr;

  MockParameterProvider* mock_parameter_provider_ = nullptr;

};
@@ -89,7 +93,6 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { 
  MockAclManager mock_acl_manager;

  hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                                         hci::AddressType::RANDOM_DEVICE_ADDRESS);

  auto user_handler = os::Handler(thread_);



  // Step 1: Verify callback registration with HCI

  hci::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
@@ -111,7 +114,7 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { 
  // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process

  EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type)).Times(1);

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{

      .handler_ = &user_handler,

      .handler_ = user_handler_,

      .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};

  le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
@@ -142,17 +145,17 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { 
  EXPECT_EQ(future_1_status, std::future_status::ready);

  auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);

  EXPECT_EQ(future_2_status, std::future_status::ready);

  EXPECT_NE(channel_1, nullptr);

  EXPECT_NE(channel_2, nullptr);

  ASSERT_NE(channel_1, nullptr);

  ASSERT_NE(channel_2, nullptr);



  // Step 4: Calling ConnectServices() to the same device will no trigger another connection attempt

  // Step 4: Calling ConnectServices() to the same device will not trigger another connection attempt

  FixedChannelManager::ConnectionResult my_result;

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection_2{

      .handler_ = &user_handler,

      .handler_ = user_handler_,

      .on_fail_callback_ = common::testing::BindLambdaForTesting(

          [&my_result](FixedChannelManager::ConnectionResult result) { my_result = result; })};

  le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection_2));

  SyncHandler(&user_handler);

  SyncHandler(user_handler_);

  EXPECT_EQ(my_result.connection_result_code,

            FixedChannelManager::ConnectionResultCode::FAIL_ALL_SERVICES_HAVE_CHANNEL);
@@ -161,7 +164,7 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { 
  results.emplace_back(kSmpBrCid + 1, &mock_service_3);

  EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection_3{

      .handler_ = &user_handler,

      .handler_ = user_handler_,

      .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};

  std::unique_ptr<FixedChannel> channel_3;

  std::promise<void> promise_3;
@@ -176,7 +179,6 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { 
  EXPECT_EQ(future_3_status, std::future_status::ready);

  EXPECT_NE(channel_3, nullptr);



  user_handler.Clear();



  le_link_manager.OnDisconnect(address_with_type, hci::ErrorCode::SUCCESS);

}
@@ -186,7 +188,6 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_no 
  MockAclManager mock_acl_manager;

  hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                                         hci::AddressType::PUBLIC_DEVICE_ADDRESS);

  auto user_handler = std::make_unique<os::Handler>(thread_);



  // Step 1: Verify callback registration with HCI

  hci::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
@@ -206,14 +207,13 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_no 
  EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type)).Times(0);

  FixedChannelManager::ConnectionResult my_result;

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{

      .handler_ = user_handler.get(),

      .handler_ = user_handler_,

      .on_fail_callback_ = common::testing::BindLambdaForTesting(

          [&my_result](FixedChannelManager::ConnectionResult result) { my_result = result; })};

  le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));

  SyncHandler(user_handler.get());

  SyncHandler(user_handler_);

  EXPECT_EQ(my_result.connection_result_code, FixedChannelManager::ConnectionResultCode::FAIL_NO_SERVICE_REGISTERED);



  user_handler->Clear();

}



TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_hci_failure) {
@@ -221,7 +221,6 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_hc 
  MockAclManager mock_acl_manager;

  hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                                         hci::AddressType::RANDOM_DEVICE_ADDRESS);

  auto user_handler = std::make_unique<os::Handler>(thread_);



  // Step 1: Verify callback registration with HCI

  hci::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
@@ -243,7 +242,7 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_hc 
  EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type)).Times(1);

  FixedChannelManager::ConnectionResult my_result;

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{

      .handler_ = user_handler.get(),

      .handler_ = user_handler_,

      .on_fail_callback_ = common::testing::BindLambdaForTesting(

          [&my_result](FixedChannelManager::ConnectionResult result) { my_result = result; })};

  le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
@@ -254,11 +253,9 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_hc 
                                              common::Unretained(hci_le_connection_callbacks), address_with_type,

                                              hci::ErrorCode::PAGE_TIMEOUT));

  SyncHandler(hci_callback_handler);

  SyncHandler(user_handler.get());

  SyncHandler(user_handler_);

  EXPECT_EQ(my_result.connection_result_code, FixedChannelManager::ConnectionResultCode::FAIL_HCI_ERROR);

  EXPECT_EQ(my_result.hci_error, hci::ErrorCode::PAGE_TIMEOUT);



  user_handler->Clear();

}



TEST_F(L2capLeLinkManagerTest, not_acquiring_channels_should_disconnect_acl_after_timeout) {
@@ -268,7 +265,6 @@ TEST_F(L2capLeLinkManagerTest, not_acquiring_channels_should_disconnect_acl_afte 
  MockAclManager mock_acl_manager;

  hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                                         hci::AddressType::RANDOM_DEVICE_ADDRESS);

  auto user_handler = std::make_unique<os::Handler>(thread_);



  // Step 1: Verify callback registration with HCI

  hci::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
@@ -290,7 +286,7 @@ TEST_F(L2capLeLinkManagerTest, not_acquiring_channels_should_disconnect_acl_afte 
  // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process

  EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type)).Times(1);

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{

      .handler_ = user_handler.get(),

      .handler_ = user_handler_,

      .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};

  le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
@@ -324,22 +320,20 @@ TEST_F(L2capLeLinkManagerTest, not_acquiring_channels_should_disconnect_acl_afte 
  EXPECT_NE(channel_2, nullptr);

  hci::ErrorCode status_1 = hci::ErrorCode::SUCCESS;

  channel_1->RegisterOnCloseCallback(

      user_handler.get(), common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));

      user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));

  hci::ErrorCode status_2 = hci::ErrorCode::SUCCESS;

  channel_2->RegisterOnCloseCallback(

      user_handler.get(), common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));

      user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));



  // Step 4: ave channel IDLE long enough, they will disconnect

  // Step 4: Leave channel IDLE long enough, they will disconnect

  EXPECT_CALL(*raw_acl_connection, Disconnect(hci::DisconnectReason::REMOTE_USER_TERMINATED_CONNECTION)).Times(1);

  std::this_thread::sleep_for(kTestIdleDisconnectTimeoutShort * 1.2);



  // Step 5: Link disconnect will trigger all callbacks

  le_link_manager.OnDisconnect(address_with_type, hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST);

  SyncHandler(user_handler.get());

  SyncHandler(user_handler_);

  EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_1);

  EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_2);



  user_handler->Clear();

}



TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_after_timeout) {
@@ -349,7 +343,6 @@ TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_afte 
  MockAclManager mock_acl_manager;

  hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                                         hci::AddressType::RANDOM_DEVICE_ADDRESS);

  auto user_handler = std::make_unique<os::Handler>(thread_);



  // Step 1: Verify callback registration with HCI

  hci::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
@@ -371,7 +364,7 @@ TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_afte 
  // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process

  EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type)).Times(1);

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{

      .handler_ = user_handler.get(),

      .handler_ = user_handler_,

      .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};

  le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
@@ -405,10 +398,10 @@ TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_afte 
  EXPECT_NE(channel_2, nullptr);

  hci::ErrorCode status_1 = hci::ErrorCode::SUCCESS;

  channel_1->RegisterOnCloseCallback(

      user_handler.get(), common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));

      user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));

  hci::ErrorCode status_2 = hci::ErrorCode::SUCCESS;

  channel_2->RegisterOnCloseCallback(

      user_handler.get(), common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));

      user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));



  channel_1->Acquire();
@@ -418,11 +411,9 @@ TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_afte 


  // Step 5: Link disconnect will trigger all callbacks

  le_link_manager.OnDisconnect(address_with_type, hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST);

  SyncHandler(user_handler.get());

  SyncHandler(user_handler_);

  EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_1);

  EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_2);



  user_handler->Clear();

}



TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventually_disconnect_acl) {
@@ -432,7 +423,6 @@ TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventuall 
  MockAclManager mock_acl_manager;

  hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                                         hci::AddressType::PUBLIC_IDENTITY_ADDRESS);

  auto user_handler = std::make_unique<os::Handler>(thread_);



  // Step 1: Verify callback registration with HCI

  hci::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
@@ -454,7 +444,7 @@ TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventuall 
  // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process

  EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type)).Times(1);

  LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{

      .handler_ = user_handler.get(),

      .handler_ = user_handler_,

      .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};

  le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
@@ -488,10 +478,10 @@ TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventuall 
  EXPECT_NE(channel_2, nullptr);

  hci::ErrorCode status_1 = hci::ErrorCode::SUCCESS;

  channel_1->RegisterOnCloseCallback(

      user_handler.get(), common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));

      user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));

  hci::ErrorCode status_2 = hci::ErrorCode::SUCCESS;

  channel_2->RegisterOnCloseCallback(

      user_handler.get(), common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));

      user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));



  channel_1->Acquire();
@@ -506,11 +496,9 @@ TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventuall 


  // Step 6: Link disconnect will trigger all callbacks

  le_link_manager.OnDisconnect(address_with_type, hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST);

  SyncHandler(user_handler.get());

  SyncHandler(user_handler_);

  EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_1);

  EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_2);



  user_handler->Clear();

}



}  // namespace