base/task_scheduler/scheduler_service_thread_unittest.cc

// Copyright 2016 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 "base/task_scheduler/scheduler_service_thread.h"

#include <memory>

#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
#include "base/synchronization/waitable_event.h"
#include "base/task_scheduler/delayed_task_manager.h"
#include "base/task_scheduler/scheduler_worker_pool_impl.h"
#include "base/task_scheduler/scheduler_worker_pool_params.h"
#include "base/task_scheduler/sequence.h"
#include "base/task_scheduler/task.h"
#include "base/task_scheduler/task_tracker.h"
#include "base/task_scheduler/task_traits.h"
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace base {
namespace internal {
namespace {

// The goal of the tests here is to verify the behavior of the Service Thread.
// Some tests may be better part of DelayedTaskManager unit tests depending on
// the nature of the test.
//
// Timed waits are inherent in the service thread because one of its main
// purposes is to tell the delayed task manager when to post ready tasks.
// This also makes writing tests tricky since the goal isn't to test if
// WaitableEvent works but rather do the correct callbacks occur at the right
// time.
//
// As a result, there are a few assumptions that are made in the test:
// 1) Tests execute with balanced context switching. This means that there isn't
//    an adversary that context switches test main thread for an extended period
//    of time when the test main thread isn't waiting.
// 2) Time proceeds normally. Since timed waits determine how long the service
//    thread will wait, and timed waits is currently not mockable, time needs to
//    proceed in a forward fashion. If time is frozen (e.g. TimeTicks::Now()
//    doesn't advance), some tests below may fail.
// 3) Short waits sufficiently cover longer waits. Having tests run quickly is
//    desirable. Since the tests can't change the behavior of timed waiting, the
//    delay durations should be reasonably short on the order of hundreds of
//    milliseconds.
class TaskSchedulerServiceThreadTest : public testing::Test {
 protected:
  TaskSchedulerServiceThreadTest() : delayed_task_manager_(Bind(&DoNothing)) {}

  void SetUp() override {
    scheduler_worker_pool_ = SchedulerWorkerPoolImpl::Create(
        SchedulerWorkerPoolParams("TestWorkerPoolForSchedulerServiceThread",
                                  ThreadPriority::BACKGROUND,
                                  SchedulerWorkerPoolParams::IORestriction::
                                      DISALLOWED,
                                  1u,
                                  TimeDelta::Max()),
        Bind(&ReEnqueueSequenceCallback), &task_tracker_,
        &delayed_task_manager_);
    ASSERT_TRUE(scheduler_worker_pool_);
    service_thread_ = SchedulerServiceThread::Create(
        &task_tracker_, &delayed_task_manager_);
    ASSERT_TRUE(service_thread_);
  }

  void TearDown() override {
    scheduler_worker_pool_->JoinForTesting();
    service_thread_->JoinForTesting();
  }

  SchedulerServiceThread* service_thread() {
    return service_thread_.get();
  }

  DelayedTaskManager& delayed_task_manager() {
    return delayed_task_manager_;
  }

  SchedulerWorkerPoolImpl* worker_pool() {
    return scheduler_worker_pool_.get();
  }

 private:
  static void ReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
    ADD_FAILURE() << "This test only expects one task per sequence.";
  }

  DelayedTaskManager delayed_task_manager_;
  TaskTracker task_tracker_;
  std::unique_ptr<SchedulerWorkerPoolImpl> scheduler_worker_pool_;
  std::unique_ptr<SchedulerServiceThread> service_thread_;

  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerServiceThreadTest);
};

}  // namespace

// Tests that the service thread can handle a single delayed task.
TEST_F(TaskSchedulerServiceThreadTest, RunSingleDelayedTask) {
  WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                      WaitableEvent::InitialState::NOT_SIGNALED);
  delayed_task_manager().AddDelayedTask(
      WrapUnique(new Task(FROM_HERE,
                          Bind(&WaitableEvent::Signal, Unretained(&event)),
                          TaskTraits(), TimeDelta::FromMilliseconds(100))),
      make_scoped_refptr(new Sequence), nullptr, worker_pool());
  // Waking the service thread shouldn't cause the task to be executed per its
  // delay not having expired (racy in theory, see test-fixture meta-comment).
  service_thread()->WakeUp();
  // Yield to increase the likelihood of catching a bug where these tasks would
  // be released before their delay is passed.
  PlatformThread::YieldCurrentThread();
  EXPECT_FALSE(event.IsSignaled());
  // When the delay expires, the delayed task is posted, signaling |event|.
  event.Wait();
}

// Tests that the service thread can handle more than one delayed task with
// different delays.
TEST_F(TaskSchedulerServiceThreadTest, RunMultipleDelayedTasks) {
  const TimeTicks test_begin_time = TimeTicks::Now();
  const TimeDelta delay1 = TimeDelta::FromMilliseconds(100);
  const TimeDelta delay2 = TimeDelta::FromMilliseconds(200);

  WaitableEvent event1(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
  delayed_task_manager().AddDelayedTask(
      WrapUnique(new Task(FROM_HERE,
                          Bind(&WaitableEvent::Signal, Unretained(&event1)),
                          TaskTraits(), delay1)),
      make_scoped_refptr(new Sequence), nullptr, worker_pool());

  WaitableEvent event2(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
  delayed_task_manager().AddDelayedTask(
      WrapUnique(new Task(FROM_HERE,
                          Bind(&WaitableEvent::Signal, Unretained(&event2)),
                          TaskTraits(), delay2)),
      make_scoped_refptr(new Sequence), nullptr, worker_pool());

  // Adding the task shouldn't have caused them to be executed.
  EXPECT_FALSE(event1.IsSignaled());
  EXPECT_FALSE(event2.IsSignaled());

  // Waking the service thread shouldn't cause the tasks to be executed per
  // their delays not having expired (note: this is racy if the delay somehow
  // expires before this runs but 100ms is a long time in a unittest...). It
  // should instead cause the service thread to schedule itself for wakeup when
  // |delay1| expires.
  service_thread()->WakeUp();
  // Yield to increase the likelihood of catching a bug where these tasks would
  // be released before their delay is passed.
  PlatformThread::YieldCurrentThread();
  EXPECT_FALSE(event1.IsSignaled());
  EXPECT_FALSE(event2.IsSignaled());

  // Confirm the above assumption about the evolution of time in the test.
  EXPECT_LT(TimeTicks::Now() - test_begin_time, delay1);

  // Wait until |delay1| expires and service thread wakes up to schedule the
  // first task, signalling |event1|.
  event1.Wait();

  // Only the first task should have been released.
  EXPECT_TRUE(event1.IsSignaled());
  EXPECT_FALSE(event2.IsSignaled());

  // At least |delay1| should have passed for |event1| to fire.
  EXPECT_GE(TimeTicks::Now() - test_begin_time, delay1);

  // And assuming a sane test timeline |delay2| shouldn't have expired yet.
  EXPECT_LT(TimeTicks::Now() - test_begin_time, delay2);

  // Now wait for the second task to be fired.
  event2.Wait();

  // Which should only have fired after |delay2| was expired.
  EXPECT_GE(TimeTicks::Now() - test_begin_time, delay2);
}

}  // namespace internal
}  // namespace base