// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <sys/timerfd.h>

#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/macros.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/threading/platform_thread.h"
#include "base/time/time.h"
#include "components/timers/alarm_timer_chromeos.h"
#include "testing/gtest/include/gtest/gtest.h"

// Most of these tests have been lifted right out of timer_unittest.cc with only
// cosmetic changes (like replacing calls to MessageLoop::current()->Run() with
// a RunLoop).  We want the AlarmTimer to be a drop-in replacement for the
// regular Timer so it should pass the same tests as the Timer class.
//
// The only new tests are the .*ConcurrentResetAndTimerFired tests, which test
// that race conditions that can come up in the AlarmTimer::Delegate are
// properly handled.
namespace timers {
namespace {
// The message loops on which each timer should be tested.
const base::MessageLoop::Type testing_message_loops[] = {
    base::MessageLoop::TYPE_DEFAULT,
    base::MessageLoop::TYPE_IO,
#if !defined(OS_IOS)  // iOS does not allow direct running of the UI loop.
    base::MessageLoop::TYPE_UI,
#endif
};

const int kNumTestingMessageLoops = arraysize(testing_message_loops);
const base::TimeDelta kTenMilliseconds = base::TimeDelta::FromMilliseconds(10);

class OneShotAlarmTimerTester {
 public:
  OneShotAlarmTimerTester(bool* did_run, base::TimeDelta delay)
      : did_run_(did_run),
        delay_(delay),
        timer_(new timers::OneShotAlarmTimer()) {}
  void Start() {
    timer_->Start(FROM_HERE, delay_, base::Bind(&OneShotAlarmTimerTester::Run,
                                                base::Unretained(this)));
  }

 private:
  void Run() {
    *did_run_ = true;

    base::MessageLoop::current()->PostTask(
        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
  }

  bool* did_run_;
  const base::TimeDelta delay_;
  scoped_ptr<timers::OneShotAlarmTimer> timer_;

  DISALLOW_COPY_AND_ASSIGN(OneShotAlarmTimerTester);
};

class OneShotSelfDeletingAlarmTimerTester {
 public:
  OneShotSelfDeletingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
      : did_run_(did_run),
        delay_(delay),
        timer_(new timers::OneShotAlarmTimer()) {}
  void Start() {
    timer_->Start(FROM_HERE, delay_,
                  base::Bind(&OneShotSelfDeletingAlarmTimerTester::Run,
                             base::Unretained(this)));
  }

 private:
  void Run() {
    *did_run_ = true;
    timer_.reset();

    base::MessageLoop::current()->PostTask(
        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
  }

  bool* did_run_;
  const base::TimeDelta delay_;
  scoped_ptr<timers::OneShotAlarmTimer> timer_;

  DISALLOW_COPY_AND_ASSIGN(OneShotSelfDeletingAlarmTimerTester);
};

class RepeatingAlarmTimerTester {
 public:
  RepeatingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
      : did_run_(did_run),
        delay_(delay),
        counter_(10),
        timer_(new timers::RepeatingAlarmTimer()) {}
  void Start() {
    timer_->Start(FROM_HERE, delay_, base::Bind(&RepeatingAlarmTimerTester::Run,
                                                base::Unretained(this)));
  }

 private:
  void Run() {
    if (--counter_ == 0) {
      *did_run_ = true;
      timer_->Stop();

      base::MessageLoop::current()->PostTask(
          FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
    }
  }

  bool* did_run_;
  const base::TimeDelta delay_;
  int counter_;
  scoped_ptr<timers::RepeatingAlarmTimer> timer_;

  DISALLOW_COPY_AND_ASSIGN(RepeatingAlarmTimerTester);
};

}  // namespace

//-----------------------------------------------------------------------------
// Each test is run against each type of MessageLoop.  That way we are sure
// that timers work properly in all configurations.

TEST(AlarmTimerTest, OneShotAlarmTimer) {
  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    bool did_run = false;
    OneShotAlarmTimerTester f(&did_run, kTenMilliseconds);
    f.Start();

    base::RunLoop().Run();

    EXPECT_TRUE(did_run);
  }
}

TEST(AlarmTimerTest, OneShotAlarmTimer_Cancel) {
  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    bool did_run_a = false;
    OneShotAlarmTimerTester* a =
        new OneShotAlarmTimerTester(&did_run_a, kTenMilliseconds);

    // This should run before the timer expires.
    base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

    // Now start the timer.
    a->Start();

    bool did_run_b = false;
    OneShotAlarmTimerTester b(&did_run_b, kTenMilliseconds);
    b.Start();

    base::RunLoop().Run();

    EXPECT_FALSE(did_run_a);
    EXPECT_TRUE(did_run_b);
  }
}

// If underlying timer does not handle this properly, we will crash or fail
// in full page heap environment.
TEST(AlarmTimerTest, OneShotSelfDeletingAlarmTimer) {
  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    bool did_run = false;
    OneShotSelfDeletingAlarmTimerTester f(&did_run, kTenMilliseconds);
    f.Start();

    base::RunLoop().Run();

    EXPECT_TRUE(did_run);
  }
}

TEST(AlarmTimerTest, RepeatingAlarmTimer) {
  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    bool did_run = false;
    RepeatingAlarmTimerTester f(&did_run, kTenMilliseconds);
    f.Start();

    base::RunLoop().Run();

    EXPECT_TRUE(did_run);
  }
}

TEST(AlarmTimerTest, RepeatingAlarmTimer_Cancel) {
  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    bool did_run_a = false;
    RepeatingAlarmTimerTester* a =
        new RepeatingAlarmTimerTester(&did_run_a, kTenMilliseconds);

    // This should run before the timer expires.
    base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

    // Now start the timer.
    a->Start();

    bool did_run_b = false;
    RepeatingAlarmTimerTester b(&did_run_b, kTenMilliseconds);
    b.Start();

    base::RunLoop().Run();

    EXPECT_FALSE(did_run_a);
    EXPECT_TRUE(did_run_b);
  }
}

TEST(AlarmTimerTest, RepeatingAlarmTimerZeroDelay) {
  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    bool did_run = false;
    RepeatingAlarmTimerTester f(&did_run, base::TimeDelta());
    f.Start();

    base::RunLoop().Run();

    EXPECT_TRUE(did_run);
  }
}

TEST(AlarmTimerTest, RepeatingAlarmTimerZeroDelay_Cancel) {
  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    bool did_run_a = false;
    RepeatingAlarmTimerTester* a =
        new RepeatingAlarmTimerTester(&did_run_a, base::TimeDelta());

    // This should run before the timer expires.
    base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

    // Now start the timer.
    a->Start();

    bool did_run_b = false;
    RepeatingAlarmTimerTester b(&did_run_b, base::TimeDelta());
    b.Start();

    base::RunLoop().Run();

    EXPECT_FALSE(did_run_a);
    EXPECT_TRUE(did_run_b);
  }
}

TEST(AlarmTimerTest, MessageLoopShutdown) {
  // This test is designed to verify that shutdown of the
  // message loop does not cause crashes if there were pending
  // timers not yet fired.  It may only trigger exceptions
  // if debug heap checking is enabled.
  bool did_run = false;
  {
    OneShotAlarmTimerTester a(&did_run, kTenMilliseconds);
    OneShotAlarmTimerTester b(&did_run, kTenMilliseconds);
    OneShotAlarmTimerTester c(&did_run, kTenMilliseconds);
    OneShotAlarmTimerTester d(&did_run, kTenMilliseconds);
    {
      base::MessageLoop loop;
      a.Start();
      b.Start();
    }  // MessageLoop destructs by falling out of scope.
  }    // OneShotTimers destruct.  SHOULD NOT CRASH, of course.

  EXPECT_FALSE(did_run);
}

TEST(AlarmTimerTest, NonRepeatIsRunning) {
  {
    base::MessageLoop loop;
    timers::OneShotAlarmTimer timer;
    EXPECT_FALSE(timer.IsRunning());
    timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
                base::Bind(&base::DoNothing));
    EXPECT_TRUE(timer.IsRunning());
    timer.Stop();
    EXPECT_FALSE(timer.IsRunning());
    EXPECT_TRUE(timer.user_task().is_null());
  }

  {
    timers::SimpleAlarmTimer timer;
    base::MessageLoop loop;
    EXPECT_FALSE(timer.IsRunning());
    timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
                base::Bind(&base::DoNothing));
    EXPECT_TRUE(timer.IsRunning());
    timer.Stop();
    EXPECT_FALSE(timer.IsRunning());
    ASSERT_FALSE(timer.user_task().is_null());
    timer.Reset();
    EXPECT_TRUE(timer.IsRunning());
  }
}

TEST(AlarmTimerTest, NonRepeatMessageLoopDeath) {
  timers::OneShotAlarmTimer timer;
  {
    base::MessageLoop loop;
    EXPECT_FALSE(timer.IsRunning());
    timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
                base::Bind(&base::DoNothing));
    EXPECT_TRUE(timer.IsRunning());
  }
  EXPECT_FALSE(timer.IsRunning());
  EXPECT_TRUE(timer.user_task().is_null());
}

TEST(AlarmTimerTest, RetainRepeatIsRunning) {
  base::MessageLoop loop;
  timers::RepeatingAlarmTimer timer(FROM_HERE, base::TimeDelta::FromDays(1),
                                    base::Bind(&base::DoNothing));
  EXPECT_FALSE(timer.IsRunning());
  timer.Reset();
  EXPECT_TRUE(timer.IsRunning());
  timer.Stop();
  EXPECT_FALSE(timer.IsRunning());
  timer.Reset();
  EXPECT_TRUE(timer.IsRunning());
}

TEST(AlarmTimerTest, RetainNonRepeatIsRunning) {
  base::MessageLoop loop;
  timers::SimpleAlarmTimer timer(FROM_HERE, base::TimeDelta::FromDays(1),
                                 base::Bind(&base::DoNothing));
  EXPECT_FALSE(timer.IsRunning());
  timer.Reset();
  EXPECT_TRUE(timer.IsRunning());
  timer.Stop();
  EXPECT_FALSE(timer.IsRunning());
  timer.Reset();
  EXPECT_TRUE(timer.IsRunning());
}

namespace {

bool g_callback_happened1 = false;
bool g_callback_happened2 = false;

void ClearAllCallbackHappened() {
  g_callback_happened1 = false;
  g_callback_happened2 = false;
}

void SetCallbackHappened1() {
  g_callback_happened1 = true;
  base::MessageLoop::current()->PostTask(
      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
}

void SetCallbackHappened2() {
  g_callback_happened2 = true;
  base::MessageLoop::current()->PostTask(
      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
}

TEST(AlarmTimerTest, ContinuationStopStart) {
  {
    ClearAllCallbackHappened();
    base::MessageLoop loop;
    timers::OneShotAlarmTimer timer;
    timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10),
                base::Bind(&SetCallbackHappened1));
    timer.Stop();
    timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(40),
                base::Bind(&SetCallbackHappened2));
    base::RunLoop().Run();
    EXPECT_FALSE(g_callback_happened1);
    EXPECT_TRUE(g_callback_happened2);
  }
}

TEST(AlarmTimerTest, ContinuationReset) {
  {
    ClearAllCallbackHappened();
    base::MessageLoop loop;
    timers::OneShotAlarmTimer timer;
    timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10),
                base::Bind(&SetCallbackHappened1));
    timer.Reset();
    // Since Reset happened before task ran, the user_task must not be cleared:
    ASSERT_FALSE(timer.user_task().is_null());
    base::RunLoop().Run();
    EXPECT_TRUE(g_callback_happened1);
  }
}

}  // namespace

namespace {
void TimerRanCallback(bool* did_run) {
  *did_run = true;

  base::MessageLoop::current()->PostTask(
      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
}

bool IsAlarmTimerSupported() {
  int fd = timerfd_create(CLOCK_REALTIME_ALARM, 0);

  if (fd == -1) {
    LOG(WARNING) << "CLOCK_REALTIME_ALARM is not supported on this system.  "
                 << "Skipping test.  Upgrade to at least linux version 3.11 to "
                 << "support this timer.";
    return false;
  }

  close(fd);
  return true;
}

TEST(AlarmTimerTest, OneShotTimerConcurrentResetAndTimerFired) {
  // The "Linux ChromiumOS .*" bots are still running Ubuntu 12.04, which
  // doesn't have a linux version high enough to support the AlarmTimer.  Since
  // this test depends on SetTimerFiredCallbackForTest(), which is specific to
  // the AlarmTimer, we have to just skip the test to stop it from failing.
  if (!IsAlarmTimerSupported())
    return;

  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    timers::OneShotAlarmTimer timer;
    bool did_run = false;

    base::RunLoop run_loop;

    timer.SetTimerFiredCallbackForTest(run_loop.QuitClosure());
    timer.Start(FROM_HERE, kTenMilliseconds,
                base::Bind(&TimerRanCallback, &did_run));

    // Wait until the timer has fired and a task has been queue in the
    // MessageLoop.
    run_loop.Run();

    // Now reset the timer.  This is attempting to simulate the timer firing and
    // being reset at the same time.  The previously queued task should be
    // removed.
    timer.Reset();

    base::RunLoop().RunUntilIdle();
    EXPECT_FALSE(did_run);

    // If the previous check failed, running the message loop again will hang
    // the test so we only do it if the callback has not run yet.
    if (!did_run) {
      base::RunLoop().Run();
      EXPECT_TRUE(did_run);
    }
  }
}

TEST(AlarmTimerTest, RepeatingTimerConcurrentResetAndTimerFired) {
  // The "Linux ChromiumOS .*" bots are still running Ubuntu 12.04, which
  // doesn't have a linux version high enough to support the AlarmTimer.  Since
  // this test depends on SetTimerFiredCallbackForTest(), which is specific to
  // the AlarmTimer, we have to just skip the test to stop it from failing.
  if (!IsAlarmTimerSupported())
    return;

  for (int i = 0; i < kNumTestingMessageLoops; i++) {
    base::MessageLoop loop(testing_message_loops[i]);

    timers::RepeatingAlarmTimer timer;
    bool did_run = false;

    base::RunLoop run_loop;

    timer.SetTimerFiredCallbackForTest(run_loop.QuitClosure());
    timer.Start(FROM_HERE, kTenMilliseconds,
                base::Bind(&TimerRanCallback, &did_run));

    // Wait until the timer has fired and a task has been queue in the
    // MessageLoop.
    run_loop.Run();

    // Now reset the timer.  This is attempting to simulate the timer firing and
    // being reset at the same time.  The previously queued task should be
    // removed.
    timer.Reset();

    base::RunLoop().RunUntilIdle();
    EXPECT_FALSE(did_run);

    // If the previous check failed, running the message loop again will hang
    // the test so we only do it if the callback has not run yet.
    if (!did_run) {
      base::RunLoop().Run();
      EXPECT_TRUE(did_run);
    }
  }
}

}  // namespace

}  // namespace timers