TaskScheduler [3/9] Task and Sequence

base/task_scheduler/sequence_unittest.cc

Index: base/task_scheduler/sequence_unittest.cc
diff --git a/base/task_scheduler/sequence_unittest.cc b/base/task_scheduler/sequence_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..020e24d07f69869ed7021f456644b611ffb9eede
--- /dev/null
+++ b/base/task_scheduler/sequence_unittest.cc
@@ -0,0 +1,130 @@
+// 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/sequence.h"
+
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace internal {
+
+class TaskSchedulerSequenceTest : public testing::Test {
+ public:
+  TaskSchedulerSequenceTest()
+      : task_a_(FROM_HERE,
+                Closure(),
+                TaskTraits().WithPriority(TaskPriority::BACKGROUND),
+                TimeTicks::FromInternalValue(1)),
+        task_b_(FROM_HERE,
+                Closure(),
+                TaskTraits().WithPriority(TaskPriority::USER_VISIBLE),
+                TimeTicks::FromInternalValue(2)),
+        task_c_(FROM_HERE,
+                Closure(),
+                TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
+                TimeTicks::FromInternalValue(3)),
+        task_d_(FROM_HERE,
+                Closure(),
+                TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
+                TimeTicks::FromInternalValue(4)) {}
+
+ protected:
+  const Task task_a_;
+  const Task task_b_;
+  const Task task_c_;
+  const Task task_d_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSequenceTest);
+};
+
+TEST_F(TaskSchedulerSequenceTest, PushPopPeek) {
+  scoped_refptr<Sequence> sequence(new Sequence);
+
+  EXPECT_TRUE(sequence->PushTask(scoped_ptr<Task>(new Task(task_a_))));
+  EXPECT_EQ(task_a_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PushTask(scoped_ptr<Task>(new Task(task_b_))));
+  EXPECT_EQ(task_a_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PushTask(scoped_ptr<Task>(new Task(task_c_))));
+  EXPECT_EQ(task_a_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PushTask(scoped_ptr<Task>(new Task(task_d_))));
+  EXPECT_EQ(task_a_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_b_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_c_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_d_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PushTask(scoped_ptr<Task>(new Task(task_a_))));
+  EXPECT_EQ(task_d_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_a_.sequenced_time, sequence->PeekTask()->sequenced_time);
+
+  EXPECT_TRUE(sequence->PopTask());
+  EXPECT_EQ(nullptr, sequence->PeekTask());
+}
+
+TEST_F(TaskSchedulerSequenceTest, GetSortKey) {
+  scoped_refptr<Sequence> sequence(new Sequence);
+
+  sequence->PushTask(scoped_ptr<Task>(new Task(task_a_)));
+  SequenceSortKey sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::BACKGROUND, sort_key.priority_);
+  EXPECT_EQ(task_a_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PushTask(scoped_ptr<Task>(new Task(task_b_)));
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::USER_VISIBLE, sort_key.priority_);
+  EXPECT_EQ(task_a_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PushTask(scoped_ptr<Task>(new Task(task_c_)));
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key.priority_);
+  EXPECT_EQ(task_a_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PushTask(scoped_ptr<Task>(new Task(task_d_)));
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key.priority_);
+  EXPECT_EQ(task_a_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PopTask();
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key.priority_);
+  EXPECT_EQ(task_b_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PopTask();
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key.priority_);
+  EXPECT_EQ(task_c_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PopTask();
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key.priority_);
+  EXPECT_EQ(task_d_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PushTask(scoped_ptr<Task>(new Task(task_a_)));
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key.priority_);
+  EXPECT_EQ(task_d_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PopTask();
+  sort_key = sequence->GetSortKey();
+  EXPECT_EQ(TaskPriority::BACKGROUND, sort_key.priority_);
+  EXPECT_EQ(task_a_.sequenced_time, sort_key.next_task_sequenced_time_);
+
+  sequence->PopTask();

[gab, 2016/02/18 20:22:34]

Remove this last statement given we're not testing anything from it nor after
it?

[fdoray, 2016/02/18 20:52:04]

Done.

+}
+
+}  // namespace internal
+}  // namespace base