OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/task_scheduler/sequence.h" | |
6 | |
7 #include "base/macros.h" | |
8 #include "base/time/time.h" | |
9 #include "testing/gtest/include/gtest/gtest.h" | |
10 | |
11 namespace base { | |
12 namespace internal { | |
13 | |
14 namespace { | |
15 | |
16 class TaskSchedulerSequenceTest : public testing::Test { | |
17 public: | |
18 TaskSchedulerSequenceTest() | |
19 : task_a_(new Task(FROM_HERE, | |
20 Closure(), | |
21 TaskTraits().WithPriority(TaskPriority::BACKGROUND))), | |
22 task_b_( | |
23 new Task(FROM_HERE, | |
24 Closure(), | |
25 TaskTraits().WithPriority(TaskPriority::USER_VISIBLE))), | |
26 task_c_( | |
27 new Task(FROM_HERE, | |
28 Closure(), | |
29 TaskTraits().WithPriority(TaskPriority::USER_BLOCKING))), | |
30 task_d_( | |
31 new Task(FROM_HERE, | |
32 Closure(), | |
33 TaskTraits().WithPriority(TaskPriority::USER_BLOCKING))), | |
34 task_e_(new Task(FROM_HERE, | |
35 Closure(), | |
36 TaskTraits().WithPriority(TaskPriority::BACKGROUND))), | |
37 task_a_raw_(task_a_.get()), | |
38 task_b_raw_(task_b_.get()), | |
39 task_c_raw_(task_c_.get()), | |
40 task_d_raw_(task_d_.get()), | |
41 task_e_raw_(task_e_.get()) {} | |
42 | |
43 protected: | |
44 // Tasks to be handed off to a Sequence for testing. | |
45 scoped_ptr<Task> task_a_; | |
46 scoped_ptr<Task> task_b_; | |
47 scoped_ptr<Task> task_c_; | |
48 scoped_ptr<Task> task_d_; | |
49 scoped_ptr<Task> task_e_; | |
50 | |
51 // Raw pointers to those same tasks for verification. This is needed because | |
52 // the scoped_ptrs above no longer point to the tasks once they have been | |
53 // moved into a Sequence. | |
54 const Task* task_a_raw_; | |
danakj
2016/03/15 23:16:32
fwiw, in this type of pattern, i usually name the
fdoray
2016/03/16 19:11:44
Done.
| |
55 const Task* task_b_raw_; | |
56 const Task* task_c_raw_; | |
57 const Task* task_d_raw_; | |
58 const Task* task_e_raw_; | |
59 | |
60 private: | |
61 DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSequenceTest); | |
62 }; | |
63 | |
64 void ExpectSortKey(TaskPriority expected_priority, | |
65 TimeTicks expected_sequenced_time, | |
66 const SequenceSortKey& actual_sort_key) { | |
67 EXPECT_EQ(expected_priority, actual_sort_key.priority); | |
68 EXPECT_EQ(expected_sequenced_time, actual_sort_key.next_task_sequenced_time); | |
69 } | |
70 | |
71 } // namespace | |
72 | |
73 TEST_F(TaskSchedulerSequenceTest, PushPopPeek) { | |
74 scoped_refptr<Sequence> sequence(new Sequence); | |
75 | |
76 EXPECT_TRUE(sequence->PushTask(std::move(task_a_))); | |
77 EXPECT_EQ(task_a_raw_, sequence->PeekTask()); | |
78 EXPECT_FALSE(task_a_raw_->sequenced_time.is_null()); | |
79 | |
80 EXPECT_FALSE(sequence->PushTask(std::move(task_b_))); | |
81 EXPECT_EQ(task_a_raw_, sequence->PeekTask()); | |
82 EXPECT_FALSE(task_b_raw_->sequenced_time.is_null()); | |
83 | |
84 EXPECT_FALSE(sequence->PushTask(std::move(task_c_))); | |
85 EXPECT_EQ(task_a_raw_, sequence->PeekTask()); | |
86 EXPECT_FALSE(task_c_raw_->sequenced_time.is_null()); | |
87 | |
88 EXPECT_FALSE(sequence->PushTask(std::move(task_d_))); | |
89 EXPECT_EQ(task_a_raw_, sequence->PeekTask()); | |
90 EXPECT_FALSE(task_d_raw_->sequenced_time.is_null()); | |
91 | |
92 EXPECT_FALSE(sequence->PopTask()); | |
93 EXPECT_EQ(task_b_raw_, sequence->PeekTask()); | |
94 | |
95 EXPECT_FALSE(sequence->PopTask()); | |
96 EXPECT_EQ(task_c_raw_, sequence->PeekTask()); | |
97 | |
98 EXPECT_FALSE(sequence->PopTask()); | |
99 EXPECT_EQ(task_d_raw_, sequence->PeekTask()); | |
100 | |
101 EXPECT_FALSE(sequence->PushTask(std::move(task_e_))); | |
102 EXPECT_EQ(task_d_raw_, sequence->PeekTask()); | |
103 EXPECT_FALSE(task_e_raw_->sequenced_time.is_null()); | |
104 | |
105 EXPECT_FALSE(sequence->PopTask()); | |
106 EXPECT_EQ(task_e_raw_, sequence->PeekTask()); | |
107 | |
108 EXPECT_TRUE(sequence->PopTask()); | |
109 EXPECT_EQ(nullptr, sequence->PeekTask()); | |
110 } | |
111 | |
112 TEST_F(TaskSchedulerSequenceTest, GetSortKey) { | |
113 scoped_refptr<Sequence> sequence(new Sequence); | |
114 | |
115 sequence->PushTask(std::move(task_a_)); | |
116 ExpectSortKey(TaskPriority::BACKGROUND, task_a_raw_->sequenced_time, | |
117 sequence->GetSortKey()); | |
118 | |
119 sequence->PushTask(std::move(task_b_)); | |
120 ExpectSortKey(TaskPriority::USER_VISIBLE, task_a_raw_->sequenced_time, | |
121 sequence->GetSortKey()); | |
122 | |
123 sequence->PushTask(std::move(task_c_)); | |
124 ExpectSortKey(TaskPriority::USER_BLOCKING, task_a_raw_->sequenced_time, | |
125 sequence->GetSortKey()); | |
126 | |
127 sequence->PushTask(std::move(task_d_)); | |
128 ExpectSortKey(TaskPriority::USER_BLOCKING, task_a_raw_->sequenced_time, | |
129 sequence->GetSortKey()); | |
130 | |
131 sequence->PopTask(); | |
danakj
2016/03/15 23:16:32
This test would benefit from some comments along t
fdoray
2016/03/16 19:11:44
Done.
| |
132 ExpectSortKey(TaskPriority::USER_BLOCKING, task_b_raw_->sequenced_time, | |
133 sequence->GetSortKey()); | |
134 | |
135 sequence->PopTask(); | |
136 ExpectSortKey(TaskPriority::USER_BLOCKING, task_c_raw_->sequenced_time, | |
137 sequence->GetSortKey()); | |
138 | |
139 sequence->PopTask(); | |
140 ExpectSortKey(TaskPriority::USER_BLOCKING, task_d_raw_->sequenced_time, | |
141 sequence->GetSortKey()); | |
142 | |
143 sequence->PushTask(std::move(task_e_)); | |
144 ExpectSortKey(TaskPriority::USER_BLOCKING, task_d_raw_->sequenced_time, | |
145 sequence->GetSortKey()); | |
146 | |
147 sequence->PopTask(); | |
danakj
2016/03/15 23:16:32
// Pop task_d from the sequence, the highest prior
fdoray
2016/03/16 19:11:44
Done.
| |
148 ExpectSortKey(TaskPriority::BACKGROUND, task_e_raw_->sequenced_time, | |
149 sequence->GetSortKey()); | |
150 } | |
151 | |
152 } // namespace internal | |
153 } // namespace base | |
OLD | NEW |