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

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

Merge "Fix flaky gd unit tests"

parents 3b2cee52 ece7c9e8

system/gd/hci/acl_manager_test.cc

+9 −1
Original line number Diff line number Diff line
@@ -397,6 +397,14 @@ class AclManagerWithConnectionTest : public AclManagerTest { 
    connection_->RegisterCallbacks(&mock_connection_management_callbacks_, client_handler_);

  }



  void sync_client_handler() {

    std::promise<void> promise;

    auto future = promise.get_future();

    client_handler_->Post(common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));

    auto future_status = future.wait_for(std::chrono::seconds(1));

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

  }



  uint16_t handle_;

  std::shared_ptr<AclConnection> connection_;
@@ -1092,7 +1100,7 @@ TEST_F(AclManagerWithConnectionTest, send_read_rssi) { 
  auto packet = test_hci_layer_->GetCommandPacket(OpCode::READ_RSSI);

  auto command_view = ReadRssiView::Create(packet);

  ASSERT(command_view.IsValid());



  sync_client_handler();

  EXPECT_CALL(mock_connection_management_callbacks_, OnReadRssiComplete(0x00));

  uint8_t num_packets = 1;

  test_hci_layer_->IncomingEvent(ReadRssiCompleteBuilder::Create(num_packets, ErrorCode::SUCCESS, handle_, 0x00));

system/gd/l2cap/classic/internal/dynamic_channel_service_manager_test.cc

+4 −1
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ namespace bluetooth { 
namespace l2cap {

namespace classic {

namespace internal {

namespace {



class L2capDynamicServiceManagerTest : public ::testing::Test {

 public:
@@ -62,7 +63,8 @@ class L2capDynamicServiceManagerTest : public ::testing::Test { 
    std::promise<void> promise;

    auto future = promise.get_future();

    user_handler_->Post(common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));

    future.wait_for(std::chrono::milliseconds(3));

    auto future_status = future.wait_for(std::chrono::seconds(1));

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

  }



  DynamicChannelServiceManagerImpl* manager_ = nullptr;
@@ -101,6 +103,7 @@ TEST_F(L2capDynamicServiceManagerTest, register_classic_dynamic_channel_bad_cid) 
  EXPECT_FALSE(service_registered_);

}



}  // namespace

}  // namespace internal

}  // namespace classic

}  // namespace l2cap

system/gd/l2cap/classic/internal/fixed_channel_impl_test.cc

+32 −4
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ class L2capClassicFixedChannelImplTest : public ::testing::Test { 
    std::promise<void> promise;

    auto future = promise.get_future();

    handler->Post(common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));

    future.wait_for(std::chrono::milliseconds(3));

    future.wait_for(std::chrono::seconds(1));

  }



 protected:
@@ -60,6 +60,8 @@ class L2capClassicFixedChannelImplTest : public ::testing::Test { 


TEST_F(L2capClassicFixedChannelImplTest, get_device) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -70,6 +72,8 @@ TEST_F(L2capClassicFixedChannelImplTest, get_device) { 


TEST_F(L2capClassicFixedChannelImplTest, close_triggers_callback) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -92,6 +96,8 @@ TEST_F(L2capClassicFixedChannelImplTest, close_triggers_callback) { 


TEST_F(L2capClassicFixedChannelImplTest, register_callback_after_close_should_call_immediately) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -114,6 +120,8 @@ TEST_F(L2capClassicFixedChannelImplTest, register_callback_after_close_should_ca 


TEST_F(L2capClassicFixedChannelImplTest, close_twice_should_fail) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -139,6 +147,8 @@ TEST_F(L2capClassicFixedChannelImplTest, close_twice_should_fail) { 


TEST_F(L2capClassicFixedChannelImplTest, multiple_registeration_should_fail) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -160,6 +170,8 @@ TEST_F(L2capClassicFixedChannelImplTest, multiple_registeration_should_fail) { 


TEST_F(L2capClassicFixedChannelImplTest, call_acquire_before_registeration_should_fail) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -170,6 +182,8 @@ TEST_F(L2capClassicFixedChannelImplTest, call_acquire_before_registeration_shoul 


TEST_F(L2capClassicFixedChannelImplTest, call_release_before_registeration_should_fail) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -180,6 +194,10 @@ TEST_F(L2capClassicFixedChannelImplTest, call_release_before_registeration_shoul 


TEST_F(L2capClassicFixedChannelImplTest, test_acquire_release_channel) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -190,7 +208,8 @@ TEST_F(L2capClassicFixedChannelImplTest, test_acquire_release_channel) { 
  auto user_handler = std::make_unique<os::Handler>(thread_);

  hci::ErrorCode my_status = hci::ErrorCode::SUCCESS;

  fixed_channel_impl.RegisterOnCloseCallback(

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

      user_handler.get(),

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



  // Default should be false

  EXPECT_FALSE(fixed_channel_impl.IsAcquired());
@@ -209,6 +228,8 @@ TEST_F(L2capClassicFixedChannelImplTest, test_acquire_release_channel) { 


TEST_F(L2capClassicFixedChannelImplTest, test_acquire_after_close) {

  MockParameterProvider mock_parameter_provider;

  EXPECT_CALL(mock_parameter_provider, GetClassicLinkIdleDisconnectTimeout())

      .WillRepeatedly(Return(std::chrono::seconds(5)));

  MockLink mock_classic_link(l2cap_handler_, &mock_parameter_provider);

  hci::AddressWithType device{hci::Address{{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},

                              hci::AddressType::PUBLIC_IDENTITY_ADDRESS};
@@ -218,12 +239,19 @@ TEST_F(L2capClassicFixedChannelImplTest, test_acquire_after_close) { 
  // Register on close callback

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

  hci::ErrorCode my_status = hci::ErrorCode::SUCCESS;

  fixed_channel_impl.RegisterOnCloseCallback(

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

  std::promise<void> promise;

  auto future = promise.get_future();

  fixed_channel_impl.RegisterOnCloseCallback(user_handler.get(),

                                             common::testing::BindLambdaForTesting([&](hci::ErrorCode status) {

                                               my_status = status;

                                               promise.set_value();

                                             }));



  // Channel closure should trigger such callback

  fixed_channel_impl.OnClosed(hci::ErrorCode::REMOTE_USER_TERMINATED_CONNECTION);

  SyncHandler(user_handler.get());

  auto future_status = future.wait_for(std::chrono::seconds(1));

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

  EXPECT_EQ(hci::ErrorCode::REMOTE_USER_TERMINATED_CONNECTION, my_status);



  // Release or Acquire after closing should crash

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

+71 −25
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ namespace bluetooth { 
namespace l2cap {

namespace classic {

namespace internal {

namespace {



using hci::testing::MockAclConnection;

using hci::testing::MockAclManager;
@@ -53,7 +54,7 @@ using ::testing::Return; 
using ::testing::SaveArg;



constexpr static auto kTestIdleDisconnectTimeoutLong = std::chrono::milliseconds(1000);

constexpr static auto kTestIdleDisconnectTimeoutShort = std::chrono::milliseconds(30);

constexpr static auto kTestIdleDisconnectTimeoutShort = std::chrono::milliseconds(1000);



class L2capClassicLinkManagerTest : public ::testing::Test {

 public:
@@ -122,16 +123,27 @@ TEST_F(L2capClassicLinkManagerTest, connect_fixed_channel_service_without_acl) { 
  EXPECT_CALL(*acl_connection, RegisterDisconnectCallback(_, l2cap_handler_)).Times(1);

  EXPECT_CALL(*acl_connection, GetAddress()).WillRepeatedly(Return(device));

  std::unique_ptr<FixedChannel> channel_1, channel_2;

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_)).WillOnce([&channel_1](std::unique_ptr<FixedChannel> channel) {

  std::promise<void> promise_1, promise_2;

  auto future_1 = promise_1.get_future();

  auto future_2 = promise_2.get_future();

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))

      .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {

        channel_1 = std::move(channel);

        promise_1.set_value();

      });

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_)).WillOnce([&channel_2](std::unique_ptr<FixedChannel> channel) {

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))

      .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {

        channel_2 = std::move(channel);

        promise_2.set_value();

      });

  hci_callback_handler->Post(common::BindOnce(&hci::ConnectionCallbacks::OnConnectSuccess,

                                              common::Unretained(hci_connection_callbacks), std::move(acl_connection)));

  SyncHandler(hci_callback_handler);

  auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_1, nullptr);

  auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_2, nullptr);



  // Step 4: Calling ConnectServices() to the same device will no trigger another connection attempt
@@ -279,16 +291,27 @@ TEST_F(L2capClassicLinkManagerTest, not_acquiring_channels_should_disconnect_acl 
  std::unique_ptr<MockAclConnection> acl_connection(raw_acl_connection);

  EXPECT_CALL(*acl_connection, GetAddress()).WillRepeatedly(Return(device));

  std::unique_ptr<FixedChannel> channel_1, channel_2;

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_)).WillOnce([&channel_1](std::unique_ptr<FixedChannel> channel) {

  std::promise<void> promise_1, promise_2;

  auto future_1 = promise_1.get_future();

  auto future_2 = promise_2.get_future();

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))

      .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {

        channel_1 = std::move(channel);

        promise_1.set_value();

      });

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_)).WillOnce([&channel_2](std::unique_ptr<FixedChannel> channel) {

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))

      .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {

        channel_2 = std::move(channel);

        promise_2.set_value();

      });

  hci_callback_handler->Post(common::BindOnce(&hci::ConnectionCallbacks::OnConnectSuccess,

                                              common::Unretained(hci_connection_callbacks), std::move(acl_connection)));

  SyncHandler(hci_callback_handler);

  auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_1, nullptr);

  auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_2, nullptr);

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

  channel_1->RegisterOnCloseCallback(
@@ -347,16 +370,27 @@ TEST_F(L2capClassicLinkManagerTest, acquiring_channels_should_not_disconnect_acl 
  std::unique_ptr<MockAclConnection> acl_connection(raw_acl_connection);

  EXPECT_CALL(*acl_connection, GetAddress()).WillRepeatedly(Return(device));

  std::unique_ptr<FixedChannel> channel_1, channel_2;

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_)).WillOnce([&channel_1](std::unique_ptr<FixedChannel> channel) {

  std::promise<void> promise_1, promise_2;

  auto future_1 = promise_1.get_future();

  auto future_2 = promise_2.get_future();

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))

      .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {

        channel_1 = std::move(channel);

        promise_1.set_value();

      });

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_)).WillOnce([&channel_2](std::unique_ptr<FixedChannel> channel) {

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))

      .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {

        channel_2 = std::move(channel);

        promise_2.set_value();

      });

  hci_callback_handler->Post(common::BindOnce(&hci::ConnectionCallbacks::OnConnectSuccess,

                                              common::Unretained(hci_connection_callbacks), std::move(acl_connection)));

  SyncHandler(hci_callback_handler);

  auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_1, nullptr);

  auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_2, nullptr);

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

  channel_1->RegisterOnCloseCallback(
@@ -417,16 +451,27 @@ TEST_F(L2capClassicLinkManagerTest, acquiring_and_releasing_channels_should_even 
  std::unique_ptr<MockAclConnection> acl_connection(raw_acl_connection);

  EXPECT_CALL(*acl_connection, GetAddress()).WillRepeatedly(Return(device));

  std::unique_ptr<FixedChannel> channel_1, channel_2;

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_)).WillOnce([&channel_1](std::unique_ptr<FixedChannel> channel) {

  std::promise<void> promise_1, promise_2;

  auto future_1 = promise_1.get_future();

  auto future_2 = promise_2.get_future();

  EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))

      .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {

        channel_1 = std::move(channel);

        promise_1.set_value();

      });

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_)).WillOnce([&channel_2](std::unique_ptr<FixedChannel> channel) {

  EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))

      .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {

        channel_2 = std::move(channel);

        promise_2.set_value();

      });

  hci_callback_handler->Post(common::BindOnce(&hci::ConnectionCallbacks::OnConnectSuccess,

                                              common::Unretained(hci_connection_callbacks), std::move(acl_connection)));

  SyncHandler(hci_callback_handler);

  auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_1, nullptr);

  auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);

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

  EXPECT_NE(channel_2, nullptr);

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

  channel_1->RegisterOnCloseCallback(
@@ -455,6 +500,7 @@ TEST_F(L2capClassicLinkManagerTest, acquiring_and_releasing_channels_should_even 
  user_handler->Clear();

}



}  // namespace

}  // namespace internal

}  // namespace classic

}  // namespace l2cap

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

+86 −34

File changed.

Preview size limit exceeded, changes collapsed.