TaskScheduler [3/9] Task and Sequence

base/task_scheduler/sequence_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/sequence.h"
+
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace internal {
+
+namespace {
+
+class TaskSchedulerSequenceTest : public testing::Test {
+ public:
+  TaskSchedulerSequenceTest()
+      : task_a_(new Task(FROM_HERE,
+                         Closure(),
+                         TaskTraits().WithPriority(TaskPriority::BACKGROUND))),
+        task_b_(
+            new Task(FROM_HERE,
+                     Closure(),
+                     TaskTraits().WithPriority(TaskPriority::USER_VISIBLE))),
+        task_c_(
+            new Task(FROM_HERE,
+                     Closure(),
+                     TaskTraits().WithPriority(TaskPriority::USER_BLOCKING))),
+        task_d_(
+            new Task(FROM_HERE,
+                     Closure(),
+                     TaskTraits().WithPriority(TaskPriority::USER_BLOCKING))),
+        task_e_(new Task(FROM_HERE,
+                         Closure(),
+                         TaskTraits().WithPriority(TaskPriority::BACKGROUND))),
+        task_a_raw_(task_a_.get()),
+        task_b_raw_(task_b_.get()),
+        task_c_raw_(task_c_.get()),
+        task_d_raw_(task_d_.get()),
+        task_e_raw_(task_e_.get()) {}
+
+ protected:
+  scoped_ptr<Task> task_a_;

[gab, 2016/02/22 17:12:21]

// Tasks to handed off to a Sequence for testing.

[fdoray, 2016/02/22 18:07:54]

Done.

+  scoped_ptr<Task> task_b_;
+  scoped_ptr<Task> task_c_;
+  scoped_ptr<Task> task_d_;
+  scoped_ptr<Task> task_e_;
+
+  const Task* task_a_raw_;

[gab, 2016/02/22 17:12:21]

// Raw pointers to those same tasks for verification.

[fdoray, 2016/02/22 18:07:54]

Done.

+  const Task* task_b_raw_;
+  const Task* task_c_raw_;
+  const Task* task_d_raw_;
+  const Task* task_e_raw_;

[gab, 2016/02/22 17:12:21]

Why not just inline .get()? ".get()" almost the same # chars as "_raw_".. and
saves 6 member vars. Much preferred to me.

[fdoray, 2016/02/22 18:07:55]

Once |task_x_| has been moved in a sequence, task_x_.get() returns nullptr. I
added a comment to explain that.

[gab, 2016/02/22 20:00:20]

Oops, forgot to discard that comment after I read further and realized exactly
that (and then made the above two suggestions to clarify this for the reader
here instead of later) :-).

+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSequenceTest);
+};
+
+void ExpectSortKey(TaskPriority expected_priority,
+                   TimeTicks expected_sequenced_time,
+                   const SequenceSortKey& actual_sort_key) {
+  EXPECT_EQ(expected_priority, actual_sort_key.priority);
+  EXPECT_EQ(expected_sequenced_time, actual_sort_key.next_task_sequenced_time);
+}
+
+}  // namespace
+
+TEST_F(TaskSchedulerSequenceTest, PushPopPeek) {
+  scoped_refptr<Sequence> sequence(new Sequence);
+
+  EXPECT_TRUE(sequence->PushTask(std::move(task_a_)));
+  EXPECT_EQ(task_a_raw_, sequence->PeekTask());
+  EXPECT_FALSE(task_a_raw_->sequenced_time.is_null());
+
+  EXPECT_FALSE(sequence->PushTask(std::move(task_b_)));
+  EXPECT_EQ(task_a_raw_, sequence->PeekTask());
+  EXPECT_FALSE(task_b_raw_->sequenced_time.is_null());
+
+  EXPECT_FALSE(sequence->PushTask(std::move(task_c_)));
+  EXPECT_EQ(task_a_raw_, sequence->PeekTask());
+  EXPECT_FALSE(task_c_raw_->sequenced_time.is_null());
+
+  EXPECT_FALSE(sequence->PushTask(std::move(task_d_)));
+  EXPECT_EQ(task_a_raw_, sequence->PeekTask());
+  EXPECT_FALSE(task_d_raw_->sequenced_time.is_null());
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_b_raw_, sequence->PeekTask());
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_c_raw_, sequence->PeekTask());
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_d_raw_, sequence->PeekTask());
+
+  EXPECT_FALSE(sequence->PushTask(std::move(task_e_)));
+  EXPECT_EQ(task_d_raw_, sequence->PeekTask());
+  EXPECT_FALSE(task_e_raw_->sequenced_time.is_null());
+
+  EXPECT_FALSE(sequence->PopTask());
+  EXPECT_EQ(task_e_raw_, sequence->PeekTask());
+
+  EXPECT_TRUE(sequence->PopTask());
+  EXPECT_EQ(nullptr, sequence->PeekTask());
+}
+
+TEST_F(TaskSchedulerSequenceTest, GetSortKey) {
+  scoped_refptr<Sequence> sequence(new Sequence);
+
+  sequence->PushTask(std::move(task_a_));
+  ExpectSortKey(TaskPriority::BACKGROUND, task_a_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PushTask(std::move(task_b_));
+  ExpectSortKey(TaskPriority::USER_VISIBLE, task_a_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PushTask(std::move(task_c_));
+  ExpectSortKey(TaskPriority::USER_BLOCKING, task_a_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PushTask(std::move(task_d_));
+  ExpectSortKey(TaskPriority::USER_BLOCKING, task_a_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PopTask();
+  ExpectSortKey(TaskPriority::USER_BLOCKING, task_b_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PopTask();
+  ExpectSortKey(TaskPriority::USER_BLOCKING, task_c_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PopTask();
+  ExpectSortKey(TaskPriority::USER_BLOCKING, task_d_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PushTask(std::move(task_e_));
+  ExpectSortKey(TaskPriority::USER_BLOCKING, task_d_raw_->sequenced_time,
+                sequence->GetSortKey());
+
+  sequence->PopTask();
+  ExpectSortKey(TaskPriority::BACKGROUND, task_e_raw_->sequenced_time,
+                sequence->GetSortKey());
+}
+
+}  // namespace internal
+}  // namespace base