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

Commit 993097c9 authored by Hyundo Moon's avatar Hyundo Moon
Browse files

Alarm: Create a new constructor for nonwake alarm support 

This CL also converts existing tests to parameterized tests
so that both wake/nonwake alarm can be tested.

Bug: 344712454
Bug: 360743527
Test: atest bluetooth_test_gd_unit
Test: atest bluetooth_test_with_timerfd
Change-Id: Iab41a8fae9eb09aaed3031ad98af524946b78b2e
parent 19410862

system/gd/os/alarm.h

+5 −1
Original line number Diff line number Diff line
@@ -33,9 +33,13 @@ namespace os { 
// it will unregister itself from the thread.

class Alarm {

public:

  // Create and register a single-shot alarm on a given handler

  // Create and register a single-shot alarm on a given handler. This creates a wake alarm.

  explicit Alarm(Handler* handler);



  // Create and register a single-shot alarm on a given handler.

  // This constructor can specify whether the alarm will be a wake alarm or a non-wake alarm.

  explicit Alarm(Handler* handler, bool isWakeAlarm);



  Alarm(const Alarm&) = delete;

  Alarm& operator=(const Alarm&) = delete;

system/gd/os/linux_generic/alarm.cc

+5 −2
Original line number Diff line number Diff line
@@ -39,10 +39,13 @@ namespace os { 
using common::Closure;

using common::OnceClosure;



Alarm::Alarm(Handler* handler) : handler_(handler) {

Alarm::Alarm(Handler* handler) : Alarm(handler, true) {}



Alarm::Alarm(Handler* handler, bool isWakeAlarm) : handler_(handler) {

  int timerfd_flag =

          com::android::bluetooth::flags::non_wake_alarm_for_rpa_rotation() ? TFD_NONBLOCK : 0;

  fd_ = TIMERFD_CREATE(ALARM_CLOCK, timerfd_flag);



  fd_ = TIMERFD_CREATE(isWakeAlarm ? ALARM_CLOCK : CLOCK_BOOTTIME, timerfd_flag);



  log::assert_that(fd_ != -1, "cannot create timerfd: {}", strerror(errno));

system/gd/os/linux_generic/alarm_timerfd_unittest.cc

+17 −10
Original line number Diff line number Diff line
@@ -45,12 +45,13 @@ using std::chrono::seconds; 
static constexpr seconds kForever = seconds(1);

static constexpr milliseconds kShortWait = milliseconds(10);



class AlarmOnTimerFdTest : public ::testing::Test {

class AlarmOnTimerFdTest : public ::testing::TestWithParam<bool> {

protected:

  void SetUp() override {

    bool isWakeAlarm = GetParam();

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

    handler_ = new Handler(thread_);

    alarm_ = std::make_shared<Alarm>(handler_);

    alarm_ = std::make_shared<Alarm>(handler_, isWakeAlarm);

  }



  void TearDown() override {
@@ -60,7 +61,7 @@ protected: 
    delete thread_;

  }



  std::shared_ptr<Alarm> get_new_alarm() { return std::make_shared<Alarm>(handler_); }

  std::shared_ptr<Alarm> get_new_alarm() { return std::make_shared<Alarm>(handler_, GetParam()); }



  std::shared_ptr<Alarm> alarm_;
@@ -69,16 +70,16 @@ private: 
  Thread* thread_;

};



TEST_F(AlarmOnTimerFdTest, cancel_while_not_armed) { alarm_->Cancel(); }

TEST_P(AlarmOnTimerFdTest, cancel_while_not_armed) { alarm_->Cancel(); }



TEST_F(AlarmOnTimerFdTest, schedule) {

TEST_P(AlarmOnTimerFdTest, schedule) {

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

  auto future = promise->get_future();

  alarm_->Schedule(BindOnce(&std::promise<void>::set_value, std::move(promise)), kShortWait);

  ASSERT_EQ(std::future_status::ready, future.wait_for(kForever));

}



TEST_F(AlarmOnTimerFdTest, cancel_alarm) {

TEST_P(AlarmOnTimerFdTest, cancel_alarm) {

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

  auto future = promise->get_future();

  alarm_->Schedule(BindOnce([]() { FAIL(); }), kForever);
@@ -86,7 +87,7 @@ TEST_F(AlarmOnTimerFdTest, cancel_alarm) { 
  ASSERT_NE(std::future_status::ready, future.wait_for(kShortWait));

}



TEST_F(AlarmOnTimerFdTest, cancel_alarm_from_callback) {

TEST_P(AlarmOnTimerFdTest, cancel_alarm_from_callback) {

  auto promise = std::promise<void>();

  auto future = promise.get_future();

  alarm_->Schedule(BindOnce(
@@ -100,7 +101,7 @@ TEST_F(AlarmOnTimerFdTest, cancel_alarm_from_callback) { 
  ASSERT_EQ(std::future_status::ready, future.wait_for(kForever));

}



TEST_F(AlarmOnTimerFdTest, schedule_while_alarm_armed) {

TEST_P(AlarmOnTimerFdTest, schedule_while_alarm_armed) {

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

  auto future = promise->get_future();

  alarm_->Schedule(BindOnce([]() { FAIL(); }), kForever);
@@ -108,7 +109,7 @@ TEST_F(AlarmOnTimerFdTest, schedule_while_alarm_armed) { 
  ASSERT_EQ(std::future_status::ready, future.wait_for(kForever));

}



TEST_F(AlarmOnTimerFdTest, delete_while_alarm_armed) {

TEST_P(AlarmOnTimerFdTest, delete_while_alarm_armed) {

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

  auto future = promise->get_future();

  alarm_->Schedule(BindOnce([]() { FAIL(); }), kForever);
@@ -131,7 +132,7 @@ protected: 
  std::shared_ptr<Alarm> alarm2;

};



TEST_F(TwoAlarmOnTimerFdTest, schedule_from_alarm) {

TEST_P(TwoAlarmOnTimerFdTest, schedule_from_alarm) {

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

  auto future = promise->get_future();

  alarm_->Schedule(
@@ -145,4 +146,10 @@ TEST_F(TwoAlarmOnTimerFdTest, schedule_from_alarm) { 
  EXPECT_EQ(std::future_status::ready, future.wait_for(kForever));

}



INSTANTIATE_TEST_SUITE_P(

        /* no label */, AlarmOnTimerFdTest, ::testing::Bool());



INSTANTIATE_TEST_SUITE_P(

        /* no label */, TwoAlarmOnTimerFdTest, ::testing::Bool());



}  // namespace bluetooth::os

system/gd/os/linux_generic/alarm_unittest.cc

+17 −10
Original line number Diff line number Diff line
@@ -31,12 +31,13 @@ using common::BindOnce; 
using fake_timer::fake_timerfd_advance;

using fake_timer::fake_timerfd_reset;



class AlarmTest : public ::testing::Test {

class AlarmTest : public ::testing::TestWithParam<bool> {

protected:

  void SetUp() override {

    bool isWakeAlarm = GetParam();

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

    handler_ = new Handler(thread_);

    alarm_ = std::make_shared<Alarm>(handler_);

    alarm_ = std::make_shared<Alarm>(handler_, isWakeAlarm);

  }



  void TearDown() override {
@@ -51,7 +52,7 @@ protected: 
    handler_->Post(common::BindOnce(fake_timerfd_advance, ms));

  }



  std::shared_ptr<Alarm> get_new_alarm() { return std::make_shared<Alarm>(handler_); }

  std::shared_ptr<Alarm> get_new_alarm() { return std::make_shared<Alarm>(handler_, GetParam()); }



  std::shared_ptr<Alarm> alarm_;
@@ -60,9 +61,9 @@ private: 
  Thread* thread_;

};



TEST_F(AlarmTest, cancel_while_not_armed) { alarm_->Cancel(); }

TEST_P(AlarmTest, cancel_while_not_armed) { alarm_->Cancel(); }



TEST_F(AlarmTest, schedule) {

TEST_P(AlarmTest, schedule) {

  std::promise<void> promise;

  auto future = promise.get_future();

  int delay_ms = 10;
@@ -73,13 +74,13 @@ TEST_F(AlarmTest, schedule) { 
  ASSERT_FALSE(future.valid());

}



TEST_F(AlarmTest, cancel_alarm) {

TEST_P(AlarmTest, cancel_alarm) {

  alarm_->Schedule(BindOnce([]() { FAIL() << "Should not happen"; }), std::chrono::milliseconds(3));

  alarm_->Cancel();

  std::this_thread::sleep_for(std::chrono::milliseconds(5));

}



TEST_F(AlarmTest, cancel_alarm_from_callback) {

TEST_P(AlarmTest, cancel_alarm_from_callback) {

  std::promise<void> promise;

  auto future = promise.get_future();

  alarm_->Schedule(BindOnce(
@@ -95,7 +96,7 @@ TEST_F(AlarmTest, cancel_alarm_from_callback) { 
  ASSERT_EQ(alarm_.use_count(), 1);

}



TEST_F(AlarmTest, schedule_while_alarm_armed) {

TEST_P(AlarmTest, schedule_while_alarm_armed) {

  alarm_->Schedule(BindOnce([]() { FAIL() << "Should not happen"; }), std::chrono::milliseconds(1));

  std::promise<void> promise;

  auto future = promise.get_future();
@@ -105,7 +106,7 @@ TEST_F(AlarmTest, schedule_while_alarm_armed) { 
  future.get();

}



TEST_F(AlarmTest, delete_while_alarm_armed) {

TEST_P(AlarmTest, delete_while_alarm_armed) {

  alarm_->Schedule(BindOnce([]() { FAIL() << "Should not happen"; }), std::chrono::milliseconds(1));

  alarm_.reset();

  std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -126,7 +127,7 @@ protected: 
  std::shared_ptr<Alarm> alarm2;

};



TEST_F(TwoAlarmTest, schedule_from_alarm_long) {

TEST_P(TwoAlarmTest, schedule_from_alarm_long) {

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

  auto future = promise->get_future();

  auto promise2 = std::make_unique<std::promise<void>>();
@@ -147,6 +148,12 @@ TEST_F(TwoAlarmTest, schedule_from_alarm_long) { 
  EXPECT_EQ(std::future_status::ready, future2.wait_for(std::chrono::milliseconds(20)));

}



INSTANTIATE_TEST_SUITE_P(

        /* no label */, AlarmTest, ::testing::Bool());



INSTANTIATE_TEST_SUITE_P(

        /* no label */, TwoAlarmTest, ::testing::Bool());



}  // namespace

}  // namespace os

}  // namespace bluetooth