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

Side by Side Diff: components/scheduler/base/work_queue_sets_unittest.cc

Issue 1685093002: Fix bug with TaskQueueSelector and blocked queues (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix UAF 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 unified diff | Download patch
« no previous file with comments | « components/scheduler/base/work_queue_sets.cc ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
OLDNEW
« no previous file with comments | « components/scheduler/base/work_queue_sets.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698