Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(289)

Unified Diff: base/task_scheduler/sequence_unittest.cc

Issue 1705253002: TaskScheduler [3/9] Task and Sequence (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@s_1_scheduler_lock
Patch Set: address comments from robliao #13 Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
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..32cf08a95167a6166fd46be6d903cfae7fcc83aa
--- /dev/null
+++ b/base/task_scheduler/sequence_unittest.cc
@@ -0,0 +1,128 @@
+// 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_)));
+ const SequenceSortKey sort_key_1(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::BACKGROUND, sort_key_1.priority_);
+ EXPECT_EQ(task_a_.sequenced_time, sort_key_1.next_task_sequenced_time_);
+
+ sequence->PushTask(scoped_ptr<Task>(new Task(task_b_)));
+ const SequenceSortKey sort_key_2(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::USER_VISIBLE, sort_key_2.priority_);
+ EXPECT_EQ(task_a_.sequenced_time, sort_key_2.next_task_sequenced_time_);
+
+ sequence->PushTask(scoped_ptr<Task>(new Task(task_c_)));
+ const SequenceSortKey sort_key_3(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key_3.priority_);
+ EXPECT_EQ(task_a_.sequenced_time, sort_key_3.next_task_sequenced_time_);
+
+ sequence->PushTask(scoped_ptr<Task>(new Task(task_d_)));
+ const SequenceSortKey sort_key_4(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key_4.priority_);
+ EXPECT_EQ(task_a_.sequenced_time, sort_key_4.next_task_sequenced_time_);
+
+ sequence->PopTask();
+ const SequenceSortKey sort_key_5(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key_5.priority_);
+ EXPECT_EQ(task_b_.sequenced_time, sort_key_5.next_task_sequenced_time_);
+
+ sequence->PopTask();
+ const SequenceSortKey sort_key_6(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key_6.priority_);
+ EXPECT_EQ(task_c_.sequenced_time, sort_key_6.next_task_sequenced_time_);
+
+ sequence->PopTask();
+ const SequenceSortKey sort_key_7(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key_7.priority_);
+ EXPECT_EQ(task_d_.sequenced_time, sort_key_7.next_task_sequenced_time_);
+
+ sequence->PushTask(scoped_ptr<Task>(new Task(task_a_)));
+ const SequenceSortKey sort_key_8(sequence->GetSortKey());
+ EXPECT_EQ(TaskPriority::USER_BLOCKING, sort_key_8.priority_);
+ EXPECT_EQ(task_d_.sequenced_time, sort_key_8.next_task_sequenced_time_);
+
+ sequence->PopTask();
+ const SequenceSortKey sort_key_9(sequence->GetSortKey());
gab 2016/02/19 16:50:47 I'm not against const for these, but feels like co
fdoray 2016/02/19 22:28:30 Done.
+ EXPECT_EQ(TaskPriority::BACKGROUND, sort_key_9.priority_);
+ EXPECT_EQ(task_a_.sequenced_time, sort_key_9.next_task_sequenced_time_);
gab 2016/02/19 16:50:47 Instead of using different variable name (and risk
fdoray 2016/02/19 22:28:30 Done.
+}
+
+} // namespace internal
+} // namespace base

Powered by Google App Engine
This is Rietveld 408576698