OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/scheduler/base/work_queue_sets.h" | 5 #include "components/scheduler/base/work_queue_sets.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include "components/scheduler/base/work_queue.h" | 9 #include "components/scheduler/base/work_queue.h" |
10 #include "testing/gmock/include/gmock/gmock.h" | 10 #include "testing/gmock/include/gmock/gmock.h" |
11 | 11 |
12 namespace scheduler { | 12 namespace scheduler { |
13 class TimeDomain; | 13 class TimeDomain; |
14 | 14 |
15 namespace internal { | 15 namespace internal { |
16 | 16 |
17 class WorkQueueSetsTest : public testing::Test { | 17 class WorkQueueSetsTest : public testing::Test { |
18 public: | 18 public: |
19 void SetUp() override { work_queue_sets_.reset(new WorkQueueSets(kNumSets)); } | 19 void SetUp() override { |
| 20 work_queue_sets_.reset(new WorkQueueSets(kNumSets, "test")); |
| 21 } |
| 22 |
| 23 void TearDown() override { |
| 24 for (scoped_ptr<WorkQueue>& work_queue : work_queues_) { |
| 25 if (work_queue->work_queue_sets()) |
| 26 work_queue_sets_->RemoveQueue(work_queue.get()); |
| 27 } |
| 28 } |
20 | 29 |
21 protected: | 30 protected: |
22 enum { | 31 enum { |
23 kNumSets = 5 // An arbitary choice. | 32 kNumSets = 5 // An arbitary choice. |
24 }; | 33 }; |
25 | 34 |
26 WorkQueue* NewTaskQueue(const char* queue_name) { | 35 WorkQueue* NewTaskQueue(const char* queue_name) { |
27 WorkQueue* queue = new WorkQueue(nullptr, "test"); | 36 WorkQueue* queue = new WorkQueue(nullptr, "test"); |
28 work_queues_.push_back(make_scoped_ptr(queue)); | 37 work_queues_.push_back(make_scoped_ptr(queue)); |
29 work_queue_sets_->AssignQueueToSet(queue, TaskQueue::CONTROL_PRIORITY); | 38 work_queue_sets_->AddQueue(queue, TaskQueue::CONTROL_PRIORITY); |
30 return queue; | 39 return queue; |
31 } | 40 } |
32 | 41 |
33 TaskQueueImpl::Task FakeTaskWithEnqueueOrder(int enqueue_order) { | 42 TaskQueueImpl::Task FakeTaskWithEnqueueOrder(int enqueue_order) { |
34 TaskQueueImpl::Task fake_task(FROM_HERE, base::Closure(), base::TimeTicks(), | 43 TaskQueueImpl::Task fake_task(FROM_HERE, base::Closure(), base::TimeTicks(), |
35 0, true); | 44 0, true); |
36 fake_task.set_enqueue_order(enqueue_order); | 45 fake_task.set_enqueue_order(enqueue_order); |
37 return fake_task; | 46 return fake_task; |
38 } | 47 } |
39 | 48 |
40 std::vector<scoped_ptr<WorkQueue>> work_queues_; | 49 std::vector<scoped_ptr<WorkQueue>> work_queues_; |
41 scoped_ptr<WorkQueueSets> work_queue_sets_; | 50 scoped_ptr<WorkQueueSets> work_queue_sets_; |
42 }; | 51 }; |
43 | 52 |
44 TEST_F(WorkQueueSetsTest, AssignQueueToSet) { | 53 TEST_F(WorkQueueSetsTest, ChangeSetIndex) { |
45 WorkQueue* work_queue = NewTaskQueue("queue"); | 54 WorkQueue* work_queue = NewTaskQueue("queue"); |
46 size_t set = TaskQueue::NORMAL_PRIORITY; | 55 size_t set = TaskQueue::NORMAL_PRIORITY; |
47 work_queue_sets_->AssignQueueToSet(work_queue, set); | 56 work_queue_sets_->ChangeSetIndex(work_queue, set); |
48 | 57 |
49 EXPECT_EQ(set, work_queue->work_queue_set_index()); | 58 EXPECT_EQ(set, work_queue->work_queue_set_index()); |
50 } | 59 } |
51 | 60 |
52 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_QueueEmpty) { | 61 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_QueueEmpty) { |
53 WorkQueue* work_queue = NewTaskQueue("queue"); | 62 WorkQueue* work_queue = NewTaskQueue("queue"); |
54 size_t set = TaskQueue::NORMAL_PRIORITY; | 63 size_t set = TaskQueue::NORMAL_PRIORITY; |
55 work_queue_sets_->AssignQueueToSet(work_queue, set); | 64 work_queue_sets_->ChangeSetIndex(work_queue, set); |
56 | 65 |
57 WorkQueue* selected_work_queue; | 66 WorkQueue* selected_work_queue; |
58 EXPECT_FALSE( | 67 EXPECT_FALSE( |
59 work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 68 work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
60 } | 69 } |
61 | 70 |
62 TEST_F(WorkQueueSetsTest, OnPushQueue) { | 71 TEST_F(WorkQueueSetsTest, OnPushQueue) { |
63 WorkQueue* work_queue = NewTaskQueue("queue"); | 72 WorkQueue* work_queue = NewTaskQueue("queue"); |
64 size_t set = TaskQueue::NORMAL_PRIORITY; | 73 size_t set = TaskQueue::NORMAL_PRIORITY; |
65 work_queue_sets_->AssignQueueToSet(work_queue, set); | 74 work_queue_sets_->ChangeSetIndex(work_queue, set); |
66 | 75 |
67 WorkQueue* selected_work_queue; | 76 WorkQueue* selected_work_queue; |
68 EXPECT_FALSE( | 77 EXPECT_FALSE( |
69 work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 78 work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
70 | 79 |
71 work_queue->Push(FakeTaskWithEnqueueOrder(10)); | 80 work_queue->Push(FakeTaskWithEnqueueOrder(10)); |
72 work_queue_sets_->OnPushQueue(work_queue); | 81 work_queue_sets_->OnPushQueue(work_queue); |
73 | 82 |
74 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 83 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
75 EXPECT_EQ(work_queue, selected_work_queue); | 84 EXPECT_EQ(work_queue, selected_work_queue); |
76 } | 85 } |
77 | 86 |
78 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_SingleTaskInSet) { | 87 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_SingleTaskInSet) { |
79 WorkQueue* work_queue = NewTaskQueue("queue"); | 88 WorkQueue* work_queue = NewTaskQueue("queue"); |
80 work_queue->Push(FakeTaskWithEnqueueOrder(10)); | 89 work_queue->Push(FakeTaskWithEnqueueOrder(10)); |
81 size_t set = 1; | 90 size_t set = 1; |
82 work_queue_sets_->AssignQueueToSet(work_queue, set); | 91 work_queue_sets_->ChangeSetIndex(work_queue, set); |
83 | 92 |
84 WorkQueue* selected_work_queue; | 93 WorkQueue* selected_work_queue; |
85 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 94 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
86 EXPECT_EQ(work_queue, selected_work_queue); | 95 EXPECT_EQ(work_queue, selected_work_queue); |
87 } | 96 } |
88 | 97 |
89 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_MultipleAgesInSet) { | 98 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_MultipleAgesInSet) { |
90 WorkQueue* queue1 = NewTaskQueue("queue1"); | 99 WorkQueue* queue1 = NewTaskQueue("queue1"); |
91 WorkQueue* queue2 = NewTaskQueue("queue2"); | 100 WorkQueue* queue2 = NewTaskQueue("queue2"); |
92 WorkQueue* queue3 = NewTaskQueue("queue2"); | 101 WorkQueue* queue3 = NewTaskQueue("queue2"); |
93 queue1->Push(FakeTaskWithEnqueueOrder(6)); | 102 queue1->Push(FakeTaskWithEnqueueOrder(6)); |
94 queue2->Push(FakeTaskWithEnqueueOrder(5)); | 103 queue2->Push(FakeTaskWithEnqueueOrder(5)); |
95 queue3->Push(FakeTaskWithEnqueueOrder(4)); | 104 queue3->Push(FakeTaskWithEnqueueOrder(4)); |
96 size_t set = 2; | 105 size_t set = 2; |
97 work_queue_sets_->AssignQueueToSet(queue1, set); | 106 work_queue_sets_->ChangeSetIndex(queue1, set); |
98 work_queue_sets_->AssignQueueToSet(queue2, set); | 107 work_queue_sets_->ChangeSetIndex(queue2, set); |
99 work_queue_sets_->AssignQueueToSet(queue3, set); | 108 work_queue_sets_->ChangeSetIndex(queue3, set); |
100 | 109 |
101 WorkQueue* selected_work_queue; | 110 WorkQueue* selected_work_queue; |
102 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 111 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
103 EXPECT_EQ(queue3, selected_work_queue); | 112 EXPECT_EQ(queue3, selected_work_queue); |
104 } | 113 } |
105 | 114 |
106 TEST_F(WorkQueueSetsTest, OnPopQueue) { | 115 TEST_F(WorkQueueSetsTest, OnPopQueue) { |
107 WorkQueue* queue1 = NewTaskQueue("queue1"); | 116 WorkQueue* queue1 = NewTaskQueue("queue1"); |
108 WorkQueue* queue2 = NewTaskQueue("queue2"); | 117 WorkQueue* queue2 = NewTaskQueue("queue2"); |
109 WorkQueue* queue3 = NewTaskQueue("queue3"); | 118 WorkQueue* queue3 = NewTaskQueue("queue3"); |
110 queue1->Push(FakeTaskWithEnqueueOrder(6)); | 119 queue1->Push(FakeTaskWithEnqueueOrder(6)); |
111 queue2->Push(FakeTaskWithEnqueueOrder(3)); | 120 queue2->Push(FakeTaskWithEnqueueOrder(3)); |
112 queue2->Push(FakeTaskWithEnqueueOrder(1)); | 121 queue2->Push(FakeTaskWithEnqueueOrder(1)); |
113 queue3->Push(FakeTaskWithEnqueueOrder(4)); | 122 queue3->Push(FakeTaskWithEnqueueOrder(4)); |
114 size_t set = 3; | 123 size_t set = 3; |
115 work_queue_sets_->AssignQueueToSet(queue1, set); | 124 work_queue_sets_->ChangeSetIndex(queue1, set); |
116 work_queue_sets_->AssignQueueToSet(queue2, set); | 125 work_queue_sets_->ChangeSetIndex(queue2, set); |
117 work_queue_sets_->AssignQueueToSet(queue3, set); | 126 work_queue_sets_->ChangeSetIndex(queue3, set); |
118 | 127 |
119 WorkQueue* selected_work_queue; | 128 WorkQueue* selected_work_queue; |
120 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 129 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
121 EXPECT_EQ(queue2, selected_work_queue); | 130 EXPECT_EQ(queue2, selected_work_queue); |
122 | 131 |
123 queue2->PopTaskForTest(); | 132 queue2->PopTaskForTest(); |
124 work_queue_sets_->OnPopQueue(queue2); | 133 work_queue_sets_->OnPopQueue(queue2); |
125 | 134 |
126 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 135 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
127 EXPECT_EQ(queue2, selected_work_queue); | 136 EXPECT_EQ(queue2, selected_work_queue); |
128 } | 137 } |
129 | 138 |
130 TEST_F(WorkQueueSetsTest, OnPopQueue_QueueBecomesEmpty) { | 139 TEST_F(WorkQueueSetsTest, OnPopQueue_QueueBecomesEmpty) { |
131 WorkQueue* queue1 = NewTaskQueue("queue"); | 140 WorkQueue* queue1 = NewTaskQueue("queue"); |
132 WorkQueue* queue2 = NewTaskQueue("queue"); | 141 WorkQueue* queue2 = NewTaskQueue("queue"); |
133 WorkQueue* queue3 = NewTaskQueue("queue"); | 142 WorkQueue* queue3 = NewTaskQueue("queue"); |
134 queue1->Push(FakeTaskWithEnqueueOrder(6)); | 143 queue1->Push(FakeTaskWithEnqueueOrder(6)); |
135 queue2->Push(FakeTaskWithEnqueueOrder(5)); | 144 queue2->Push(FakeTaskWithEnqueueOrder(5)); |
136 queue3->Push(FakeTaskWithEnqueueOrder(4)); | 145 queue3->Push(FakeTaskWithEnqueueOrder(4)); |
137 size_t set = 4; | 146 size_t set = 4; |
138 work_queue_sets_->AssignQueueToSet(queue1, set); | 147 work_queue_sets_->ChangeSetIndex(queue1, set); |
139 work_queue_sets_->AssignQueueToSet(queue2, set); | 148 work_queue_sets_->ChangeSetIndex(queue2, set); |
140 work_queue_sets_->AssignQueueToSet(queue3, set); | 149 work_queue_sets_->ChangeSetIndex(queue3, set); |
141 | 150 |
142 WorkQueue* selected_work_queue; | 151 WorkQueue* selected_work_queue; |
143 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 152 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
144 EXPECT_EQ(queue3, selected_work_queue); | 153 EXPECT_EQ(queue3, selected_work_queue); |
145 | 154 |
146 queue3->PopTaskForTest(); | 155 queue3->PopTaskForTest(); |
147 work_queue_sets_->OnPopQueue(queue3); | 156 work_queue_sets_->OnPopQueue(queue3); |
148 | 157 |
149 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 158 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
150 EXPECT_EQ(queue2, selected_work_queue); | 159 EXPECT_EQ(queue2, selected_work_queue); |
151 } | 160 } |
152 | 161 |
153 TEST_F(WorkQueueSetsTest, | 162 TEST_F(WorkQueueSetsTest, |
154 GetOldestQueueInSet_MultipleAgesInSetIntegerRollover) { | 163 GetOldestQueueInSet_MultipleAgesInSetIntegerRollover) { |
155 WorkQueue* queue1 = NewTaskQueue("queue1"); | 164 WorkQueue* queue1 = NewTaskQueue("queue1"); |
156 WorkQueue* queue2 = NewTaskQueue("queue2"); | 165 WorkQueue* queue2 = NewTaskQueue("queue2"); |
157 WorkQueue* queue3 = NewTaskQueue("queue3"); | 166 WorkQueue* queue3 = NewTaskQueue("queue3"); |
158 queue1->Push(FakeTaskWithEnqueueOrder(0x7ffffff1)); | 167 queue1->Push(FakeTaskWithEnqueueOrder(0x7ffffff1)); |
159 queue2->Push(FakeTaskWithEnqueueOrder(0x7ffffff0)); | 168 queue2->Push(FakeTaskWithEnqueueOrder(0x7ffffff0)); |
160 queue3->Push(FakeTaskWithEnqueueOrder(-0x7ffffff1)); | 169 queue3->Push(FakeTaskWithEnqueueOrder(-0x7ffffff1)); |
161 size_t set = 0; | 170 size_t set = 1; |
162 work_queue_sets_->AssignQueueToSet(queue1, set); | 171 work_queue_sets_->ChangeSetIndex(queue1, set); |
163 work_queue_sets_->AssignQueueToSet(queue2, set); | 172 work_queue_sets_->ChangeSetIndex(queue2, set); |
164 work_queue_sets_->AssignQueueToSet(queue3, set); | 173 work_queue_sets_->ChangeSetIndex(queue3, set); |
165 | 174 |
166 WorkQueue* selected_work_queue; | 175 WorkQueue* selected_work_queue; |
167 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 176 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
168 EXPECT_EQ(queue2, selected_work_queue); | 177 EXPECT_EQ(queue2, selected_work_queue); |
169 } | 178 } |
170 | 179 |
171 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_MultipleAgesInSet_RemoveQueue) { | 180 TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_MultipleAgesInSet_RemoveQueue) { |
172 WorkQueue* queue1 = NewTaskQueue("queue1"); | 181 WorkQueue* queue1 = NewTaskQueue("queue1"); |
173 WorkQueue* queue2 = NewTaskQueue("queue2"); | 182 WorkQueue* queue2 = NewTaskQueue("queue2"); |
174 WorkQueue* queue3 = NewTaskQueue("queue3"); | 183 WorkQueue* queue3 = NewTaskQueue("queue3"); |
175 queue1->Push(FakeTaskWithEnqueueOrder(6)); | 184 queue1->Push(FakeTaskWithEnqueueOrder(6)); |
176 queue2->Push(FakeTaskWithEnqueueOrder(5)); | 185 queue2->Push(FakeTaskWithEnqueueOrder(5)); |
177 queue3->Push(FakeTaskWithEnqueueOrder(4)); | 186 queue3->Push(FakeTaskWithEnqueueOrder(4)); |
178 size_t set = 1; | 187 size_t set = 1; |
179 work_queue_sets_->AssignQueueToSet(queue1, set); | 188 work_queue_sets_->ChangeSetIndex(queue1, set); |
180 work_queue_sets_->AssignQueueToSet(queue2, set); | 189 work_queue_sets_->ChangeSetIndex(queue2, set); |
181 work_queue_sets_->AssignQueueToSet(queue3, set); | 190 work_queue_sets_->ChangeSetIndex(queue3, set); |
182 work_queue_sets_->RemoveQueue(queue3); | 191 work_queue_sets_->RemoveQueue(queue3); |
183 | 192 |
184 WorkQueue* selected_work_queue; | 193 WorkQueue* selected_work_queue; |
185 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); | 194 EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue)); |
186 EXPECT_EQ(queue2, selected_work_queue); | 195 EXPECT_EQ(queue2, selected_work_queue); |
187 } | 196 } |
188 | 197 |
189 TEST_F(WorkQueueSetsTest, AssignQueueToSet_Complex) { | 198 TEST_F(WorkQueueSetsTest, ChangeSetIndex_Complex) { |
190 WorkQueue* queue1 = NewTaskQueue("queue1"); | 199 WorkQueue* queue1 = NewTaskQueue("queue1"); |
191 WorkQueue* queue2 = NewTaskQueue("queue2"); | 200 WorkQueue* queue2 = NewTaskQueue("queue2"); |
192 WorkQueue* queue3 = NewTaskQueue("queue3"); | 201 WorkQueue* queue3 = NewTaskQueue("queue3"); |
193 WorkQueue* queue4 = NewTaskQueue("queue4"); | 202 WorkQueue* queue4 = NewTaskQueue("queue4"); |
194 queue1->Push(FakeTaskWithEnqueueOrder(6)); | 203 queue1->Push(FakeTaskWithEnqueueOrder(6)); |
195 queue2->Push(FakeTaskWithEnqueueOrder(5)); | 204 queue2->Push(FakeTaskWithEnqueueOrder(5)); |
196 queue3->Push(FakeTaskWithEnqueueOrder(4)); | 205 queue3->Push(FakeTaskWithEnqueueOrder(4)); |
197 queue4->Push(FakeTaskWithEnqueueOrder(3)); | 206 queue4->Push(FakeTaskWithEnqueueOrder(3)); |
198 size_t set1 = 1; | 207 size_t set1 = 1; |
199 size_t set2 = 2; | 208 size_t set2 = 2; |
200 work_queue_sets_->AssignQueueToSet(queue1, set1); | 209 work_queue_sets_->ChangeSetIndex(queue1, set1); |
201 work_queue_sets_->AssignQueueToSet(queue2, set1); | 210 work_queue_sets_->ChangeSetIndex(queue2, set1); |
202 work_queue_sets_->AssignQueueToSet(queue3, set2); | 211 work_queue_sets_->ChangeSetIndex(queue3, set2); |
203 work_queue_sets_->AssignQueueToSet(queue4, set2); | 212 work_queue_sets_->ChangeSetIndex(queue4, set2); |
204 | 213 |
205 WorkQueue* selected_work_queue; | 214 WorkQueue* selected_work_queue; |
206 EXPECT_TRUE( | 215 EXPECT_TRUE( |
207 work_queue_sets_->GetOldestQueueInSet(set1, &selected_work_queue)); | 216 work_queue_sets_->GetOldestQueueInSet(set1, &selected_work_queue)); |
208 EXPECT_EQ(queue2, selected_work_queue); | 217 EXPECT_EQ(queue2, selected_work_queue); |
209 | 218 |
210 EXPECT_TRUE( | 219 EXPECT_TRUE( |
211 work_queue_sets_->GetOldestQueueInSet(set2, &selected_work_queue)); | 220 work_queue_sets_->GetOldestQueueInSet(set2, &selected_work_queue)); |
212 EXPECT_EQ(queue4, selected_work_queue); | 221 EXPECT_EQ(queue4, selected_work_queue); |
213 | 222 |
214 work_queue_sets_->AssignQueueToSet(queue4, set1); | 223 work_queue_sets_->ChangeSetIndex(queue4, set1); |
215 | 224 |
216 EXPECT_TRUE( | 225 EXPECT_TRUE( |
217 work_queue_sets_->GetOldestQueueInSet(set1, &selected_work_queue)); | 226 work_queue_sets_->GetOldestQueueInSet(set1, &selected_work_queue)); |
218 EXPECT_EQ(queue4, selected_work_queue); | 227 EXPECT_EQ(queue4, selected_work_queue); |
219 | 228 |
220 EXPECT_TRUE( | 229 EXPECT_TRUE( |
221 work_queue_sets_->GetOldestQueueInSet(set2, &selected_work_queue)); | 230 work_queue_sets_->GetOldestQueueInSet(set2, &selected_work_queue)); |
222 EXPECT_EQ(queue3, selected_work_queue); | 231 EXPECT_EQ(queue3, selected_work_queue); |
223 } | 232 } |
224 | 233 |
225 TEST_F(WorkQueueSetsTest, IsSetEmpty_NoWork) { | 234 TEST_F(WorkQueueSetsTest, IsSetEmpty_NoWork) { |
226 size_t set = 0; | 235 size_t set = 2; |
227 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); | 236 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); |
228 | 237 |
229 WorkQueue* work_queue = NewTaskQueue("queue"); | 238 WorkQueue* work_queue = NewTaskQueue("queue"); |
230 work_queue_sets_->AssignQueueToSet(work_queue, set); | 239 work_queue_sets_->ChangeSetIndex(work_queue, set); |
231 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); | 240 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); |
232 } | 241 } |
233 | 242 |
234 TEST_F(WorkQueueSetsTest, IsSetEmpty_Work) { | 243 TEST_F(WorkQueueSetsTest, IsSetEmpty_Work) { |
235 size_t set = 0; | 244 size_t set = 2; |
236 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); | 245 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); |
237 | 246 |
238 WorkQueue* work_queue = NewTaskQueue("queue"); | 247 WorkQueue* work_queue = NewTaskQueue("queue"); |
239 work_queue->Push(FakeTaskWithEnqueueOrder(1)); | 248 work_queue->Push(FakeTaskWithEnqueueOrder(1)); |
240 work_queue_sets_->AssignQueueToSet(work_queue, set); | 249 work_queue_sets_->ChangeSetIndex(work_queue, set); |
241 EXPECT_FALSE(work_queue_sets_->IsSetEmpty(set)); | 250 EXPECT_FALSE(work_queue_sets_->IsSetEmpty(set)); |
242 | 251 |
243 work_queue->PopTaskForTest(); | 252 work_queue->PopTaskForTest(); |
244 work_queue_sets_->OnPopQueue(work_queue); | 253 work_queue_sets_->OnPopQueue(work_queue); |
245 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); | 254 EXPECT_TRUE(work_queue_sets_->IsSetEmpty(set)); |
246 } | 255 } |
247 | 256 |
248 } // namespace internal | 257 } // namespace internal |
249 } // namespace scheduler | 258 } // namespace scheduler |
OLD | NEW |