| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 <string> | |
| 6 | |
| 7 #include "base/cancelable_callback.h" | |
| 8 #include "base/format_macros.h" | |
| 9 #include "base/memory/scoped_ptr.h" | |
| 10 #include "base/strings/stringprintf.h" | |
| 11 #include "base/test/test_pending_task.h" | |
| 12 #include "cc/test/ordered_simple_task_runner.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 // We pass EXPECT_TRUE / EXPECT_FALSE macros rather than a boolean as on some | |
| 16 // compilers EXPECT_EQ(false, XXXX) fails to compile as gtest tries to convert | |
| 17 // the false value to null causing a -Werror=conversion-null error. | |
| 18 #define RUN_AND_CHECK_RESULT( \ | |
| 19 tasks_remain_expect_macro, run_func, expected_result) \ | |
| 20 tasks_remain_expect_macro(task_runner_->run_func); \ | |
| 21 EXPECT_EQ(expected_result, executed_tasks_); \ | |
| 22 executed_tasks_ = ""; | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 bool ReturnTrue() { | |
| 27 return true; | |
| 28 } | |
| 29 | |
| 30 bool ReturnFalse() { | |
| 31 return false; | |
| 32 } | |
| 33 }; | |
| 34 | |
| 35 namespace cc { | |
| 36 | |
| 37 TEST(TestOrderablePendingTask, Ordering) { | |
| 38 TestOrderablePendingTask a; | |
| 39 TestOrderablePendingTask b; | |
| 40 TestOrderablePendingTask c; | |
| 41 | |
| 42 EXPECT_EQ(a, a); | |
| 43 EXPECT_EQ(b, b); | |
| 44 EXPECT_EQ(c, c); | |
| 45 EXPECT_LT(a, b); | |
| 46 EXPECT_LT(b, c); | |
| 47 EXPECT_LT(a, c); | |
| 48 | |
| 49 TestOrderablePendingTask a2 = a; | |
| 50 EXPECT_EQ(a, a2); | |
| 51 EXPECT_LT(a2, b); | |
| 52 EXPECT_LT(b, c); | |
| 53 EXPECT_LT(a2, c); | |
| 54 } | |
| 55 | |
| 56 class OrderedSimpleTaskRunnerTest : public testing::Test { | |
| 57 public: | |
| 58 OrderedSimpleTaskRunnerTest() | |
| 59 : now_src_(TestNowSource::Create(base::TimeTicks())) { | |
| 60 task_runner_ = new OrderedSimpleTaskRunner(now_src_, true); | |
| 61 } | |
| 62 ~OrderedSimpleTaskRunnerTest() override {} | |
| 63 | |
| 64 protected: | |
| 65 std::string executed_tasks_; | |
| 66 scoped_refptr<TestNowSource> now_src_; | |
| 67 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; | |
| 68 | |
| 69 void PostTask(int task_num, base::TimeDelta delay) { | |
| 70 base::Closure test_task = base::Bind(&OrderedSimpleTaskRunnerTest::Task, | |
| 71 base::Unretained(this), | |
| 72 task_num); | |
| 73 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay); | |
| 74 } | |
| 75 | |
| 76 void PostTaskWhichPostsInstantTask(int task_num, base::TimeDelta delay) { | |
| 77 base::Closure test_task = | |
| 78 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsInstantTask, | |
| 79 base::Unretained(this), | |
| 80 task_num); | |
| 81 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay); | |
| 82 } | |
| 83 | |
| 84 void PostTaskWhichPostsDelayedTask(int task_num, | |
| 85 base::TimeDelta delay1, | |
| 86 base::TimeDelta delay2) { | |
| 87 base::Closure test_task = | |
| 88 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsDelayedTask, | |
| 89 base::Unretained(this), | |
| 90 task_num, | |
| 91 delay2); | |
| 92 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay1); | |
| 93 } | |
| 94 | |
| 95 void PostTaskWhichCallsRun(int task_num, base::TimeDelta delay) { | |
| 96 base::Closure test_task = | |
| 97 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichCallsRun, | |
| 98 base::Unretained(this), | |
| 99 task_num); | |
| 100 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay); | |
| 101 } | |
| 102 | |
| 103 void PostTaskWhichPostsTaskAgain(int task_num, base::TimeDelta delay) { | |
| 104 base::Closure test_task = | |
| 105 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsAgain, | |
| 106 base::Unretained(this), | |
| 107 task_num, | |
| 108 delay); | |
| 109 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay); | |
| 110 } | |
| 111 | |
| 112 private: | |
| 113 void Task(int task_num) { | |
| 114 if (!executed_tasks_.empty()) | |
| 115 executed_tasks_ += " "; | |
| 116 executed_tasks_ += | |
| 117 base::StringPrintf("%d(%" PRId64 "ms)", | |
| 118 task_num, | |
| 119 now_src_->Now().ToInternalValue() / | |
| 120 base::Time::kMicrosecondsPerMillisecond); | |
| 121 } | |
| 122 | |
| 123 void TaskWhichPostsInstantTask(int task_num) { | |
| 124 Task(task_num); | |
| 125 PostTask(-task_num, base::TimeDelta()); | |
| 126 } | |
| 127 | |
| 128 void TaskWhichPostsDelayedTask(int task_num, base::TimeDelta delay) { | |
| 129 Task(task_num); | |
| 130 PostTask(-task_num, delay); | |
| 131 } | |
| 132 | |
| 133 void TaskWhichCallsRun(int task_num) { | |
| 134 Task(task_num); | |
| 135 task_runner_->RunPendingTasks(); | |
| 136 } | |
| 137 | |
| 138 void TaskWhichPostsAgain(int task_num, base::TimeDelta delay) { | |
| 139 Task(task_num); | |
| 140 PostTaskWhichPostsTaskAgain(task_num, delay); | |
| 141 } | |
| 142 | |
| 143 DISALLOW_COPY_AND_ASSIGN(OrderedSimpleTaskRunnerTest); | |
| 144 }; | |
| 145 | |
| 146 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTest) { | |
| 147 PostTask(1, base::TimeDelta()); | |
| 148 PostTask(2, base::TimeDelta()); | |
| 149 PostTask(3, base::TimeDelta()); | |
| 150 | |
| 151 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)"); | |
| 152 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 153 | |
| 154 PostTask(4, base::TimeDelta()); | |
| 155 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "4(0ms)"); | |
| 156 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 157 } | |
| 158 | |
| 159 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingTasks) { | |
| 160 PostTaskWhichPostsInstantTask(1, base::TimeDelta()); | |
| 161 PostTaskWhichPostsInstantTask(2, base::TimeDelta()); | |
| 162 PostTaskWhichPostsInstantTask(3, base::TimeDelta()); | |
| 163 | |
| 164 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)"); | |
| 165 RUN_AND_CHECK_RESULT( | |
| 166 EXPECT_FALSE, RunPendingTasks(), "-1(0ms) -2(0ms) -3(0ms)"); | |
| 167 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 168 } | |
| 169 | |
| 170 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingDelayedTasks) { | |
| 171 PostTaskWhichPostsDelayedTask( | |
| 172 1, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1)); | |
| 173 PostTaskWhichPostsDelayedTask( | |
| 174 2, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1)); | |
| 175 PostTaskWhichPostsDelayedTask( | |
| 176 3, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1)); | |
| 177 | |
| 178 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)"); | |
| 179 RUN_AND_CHECK_RESULT( | |
| 180 EXPECT_FALSE, RunPendingTasks(), "-1(1ms) -2(1ms) -3(1ms)"); | |
| 181 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 182 } | |
| 183 | |
| 184 TEST_F(OrderedSimpleTaskRunnerTest, | |
| 185 SimpleOrderingTestPostingReordingDelayedTasks) { | |
| 186 PostTaskWhichPostsDelayedTask(1, | |
| 187 base::TimeDelta::FromMilliseconds(1), | |
| 188 base::TimeDelta::FromMilliseconds(20)); | |
| 189 PostTaskWhichPostsDelayedTask(2, | |
| 190 base::TimeDelta::FromMilliseconds(2), | |
| 191 base::TimeDelta::FromMilliseconds(5)); | |
| 192 PostTaskWhichPostsDelayedTask(3, | |
| 193 base::TimeDelta::FromMilliseconds(3), | |
| 194 base::TimeDelta::FromMilliseconds(5)); | |
| 195 | |
| 196 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(1ms) 2(2ms) 3(3ms)"); | |
| 197 RUN_AND_CHECK_RESULT( | |
| 198 EXPECT_FALSE, RunPendingTasks(), "-2(7ms) -3(8ms) -1(21ms)"); | |
| 199 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 200 } | |
| 201 | |
| 202 TEST_F(OrderedSimpleTaskRunnerTest, | |
| 203 SimpleOrderingTestPostingReordingDelayedTasksOverlap) { | |
| 204 PostTaskWhichPostsDelayedTask(1, | |
| 205 base::TimeDelta::FromMilliseconds(1), | |
| 206 base::TimeDelta::FromMilliseconds(5)); | |
| 207 PostTaskWhichPostsDelayedTask(2, | |
| 208 base::TimeDelta::FromMilliseconds(5), | |
| 209 base::TimeDelta::FromMilliseconds(10)); | |
| 210 PostTaskWhichPostsDelayedTask(3, | |
| 211 base::TimeDelta::FromMilliseconds(10), | |
| 212 base::TimeDelta::FromMilliseconds(1)); | |
| 213 | |
| 214 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(1ms) 2(5ms)"); | |
| 215 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "-1(6ms) 3(10ms)"); | |
| 216 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-3(11ms) -2(15ms)"); | |
| 217 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 218 } | |
| 219 | |
| 220 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingAndRentrantTasks) { | |
| 221 PostTaskWhichPostsInstantTask(1, base::TimeDelta()); | |
| 222 PostTaskWhichCallsRun(2, base::TimeDelta()); | |
| 223 PostTaskWhichPostsInstantTask(3, base::TimeDelta()); | |
| 224 | |
| 225 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)"); | |
| 226 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-1(0ms) -3(0ms)"); | |
| 227 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 228 } | |
| 229 | |
| 230 TEST_F(OrderedSimpleTaskRunnerTest, | |
| 231 SimpleOrderingTestPostingDelayedAndRentrantTasks) { | |
| 232 PostTaskWhichPostsDelayedTask( | |
| 233 1, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1)); | |
| 234 PostTaskWhichCallsRun(2, base::TimeDelta()); | |
| 235 PostTaskWhichPostsDelayedTask( | |
| 236 3, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1)); | |
| 237 | |
| 238 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)"); | |
| 239 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-1(1ms) -3(1ms)"); | |
| 240 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 241 } | |
| 242 | |
| 243 TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasks) { | |
| 244 PostTask(1, base::TimeDelta()); | |
| 245 PostTask(2, base::TimeDelta::FromMilliseconds(15)); | |
| 246 PostTask(3, base::TimeDelta()); | |
| 247 PostTask(4, base::TimeDelta::FromMilliseconds(8)); | |
| 248 | |
| 249 RUN_AND_CHECK_RESULT( | |
| 250 EXPECT_FALSE, RunPendingTasks(), "1(0ms) 3(0ms) 4(8ms) 2(15ms)"); | |
| 251 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 252 } | |
| 253 | |
| 254 TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedPostingTasks) { | |
| 255 PostTaskWhichPostsInstantTask(1, base::TimeDelta()); | |
| 256 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(15)); | |
| 257 PostTaskWhichPostsInstantTask(3, base::TimeDelta()); | |
| 258 PostTaskWhichPostsInstantTask(4, base::TimeDelta::FromMilliseconds(8)); | |
| 259 | |
| 260 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 3(0ms)"); | |
| 261 RUN_AND_CHECK_RESULT( | |
| 262 EXPECT_TRUE, RunPendingTasks(), "-1(0ms) -3(0ms) 4(8ms)"); | |
| 263 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "-4(8ms) 2(15ms)"); | |
| 264 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-2(15ms)"); | |
| 265 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 266 } | |
| 267 | |
| 268 TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasksManualNow) { | |
| 269 task_runner_->SetAutoAdvanceNowToPendingTasks(false); | |
| 270 PostTask(1, base::TimeDelta()); | |
| 271 PostTask(2, base::TimeDelta::FromMilliseconds(15)); | |
| 272 PostTask(3, base::TimeDelta()); | |
| 273 PostTask(4, base::TimeDelta::FromMilliseconds(8)); | |
| 274 | |
| 275 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 3(0ms)"); | |
| 276 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), ""); | |
| 277 EXPECT_EQ(task_runner_->DelayToNextTaskTime(), | |
| 278 base::TimeDelta::FromMilliseconds(8)); | |
| 279 now_src_->SetNow(base::TimeTicks::FromInternalValue(5000)); | |
| 280 EXPECT_EQ(task_runner_->DelayToNextTaskTime(), | |
| 281 base::TimeDelta::FromMilliseconds(3)); | |
| 282 now_src_->SetNow(base::TimeTicks::FromInternalValue(25000)); | |
| 283 EXPECT_EQ(task_runner_->DelayToNextTaskTime(), base::TimeDelta()); | |
| 284 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "4(25ms) 2(25ms)"); | |
| 285 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 286 } | |
| 287 | |
| 288 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdle) { | |
| 289 PostTaskWhichPostsInstantTask(1, base::TimeDelta()); | |
| 290 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "1(0ms) -1(0ms)"); | |
| 291 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), ""); | |
| 292 } | |
| 293 | |
| 294 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeAutoNow) { | |
| 295 PostTaskWhichPostsInstantTask(1, base::TimeDelta()); | |
| 296 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2)); | |
| 297 PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3)); | |
| 298 | |
| 299 task_runner_->SetAutoAdvanceNowToPendingTasks(true); | |
| 300 | |
| 301 base::TimeTicks run_at = base::TimeTicks(); | |
| 302 | |
| 303 run_at += base::TimeDelta::FromMilliseconds(2); | |
| 304 RUN_AND_CHECK_RESULT( | |
| 305 EXPECT_TRUE, RunUntilTime(run_at), "1(0ms) -1(0ms) 2(2ms) -2(2ms)"); | |
| 306 EXPECT_EQ(run_at, now_src_->Now()); | |
| 307 | |
| 308 run_at += base::TimeDelta::FromMilliseconds(1); | |
| 309 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)"); | |
| 310 EXPECT_EQ(run_at, now_src_->Now()); | |
| 311 | |
| 312 run_at += base::TimeDelta::FromMilliseconds(1); | |
| 313 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), ""); | |
| 314 EXPECT_EQ(run_at, now_src_->Now()); | |
| 315 } | |
| 316 | |
| 317 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeManualNow) { | |
| 318 PostTaskWhichPostsInstantTask(1, base::TimeDelta()); | |
| 319 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2)); | |
| 320 PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3)); | |
| 321 | |
| 322 task_runner_->SetAutoAdvanceNowToPendingTasks(false); | |
| 323 | |
| 324 base::TimeTicks run_at = base::TimeTicks(); | |
| 325 | |
| 326 run_at += base::TimeDelta::FromMilliseconds(2); | |
| 327 RUN_AND_CHECK_RESULT( | |
| 328 EXPECT_TRUE, RunUntilTime(run_at), "1(2ms) 2(2ms) -1(2ms) -2(2ms)"); | |
| 329 EXPECT_EQ(run_at, now_src_->Now()); | |
| 330 | |
| 331 run_at += base::TimeDelta::FromMilliseconds(1); | |
| 332 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)"); | |
| 333 EXPECT_EQ(run_at, now_src_->Now()); | |
| 334 | |
| 335 run_at += base::TimeDelta::FromMilliseconds(1); | |
| 336 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), ""); | |
| 337 EXPECT_EQ(run_at, now_src_->Now()); | |
| 338 } | |
| 339 | |
| 340 TEST_F(OrderedSimpleTaskRunnerTest, RunForPeriod) { | |
| 341 PostTaskWhichPostsInstantTask(1, base::TimeDelta()); | |
| 342 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2)); | |
| 343 PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3)); | |
| 344 | |
| 345 RUN_AND_CHECK_RESULT(EXPECT_TRUE, | |
| 346 RunForPeriod(base::TimeDelta::FromMilliseconds(2)), | |
| 347 "1(0ms) -1(0ms) 2(2ms) -2(2ms)"); | |
| 348 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2), | |
| 349 now_src_->Now()); | |
| 350 | |
| 351 RUN_AND_CHECK_RESULT(EXPECT_FALSE, | |
| 352 RunForPeriod(base::TimeDelta::FromMilliseconds(1)), | |
| 353 "3(3ms) -3(3ms)"); | |
| 354 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3), | |
| 355 now_src_->Now()); | |
| 356 | |
| 357 RUN_AND_CHECK_RESULT( | |
| 358 EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromMilliseconds(1)), ""); | |
| 359 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(4), | |
| 360 now_src_->Now()); | |
| 361 } | |
| 362 | |
| 363 TEST_F(OrderedSimpleTaskRunnerTest, RunTasksWhileWithCallback) { | |
| 364 base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue); | |
| 365 base::Callback<bool(void)> return_false = base::Bind(&ReturnFalse); | |
| 366 | |
| 367 PostTask(1, base::TimeDelta()); | |
| 368 | |
| 369 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunTasksWhile(return_false), ""); | |
| 370 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(return_true), "1(0ms)"); | |
| 371 } | |
| 372 | |
| 373 TEST_F(OrderedSimpleTaskRunnerTest, EmptyTaskList) { | |
| 374 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), ""); | |
| 375 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), ""); | |
| 376 | |
| 377 ASSERT_EQ(base::TimeTicks(), now_src_->Now()); | |
| 378 | |
| 379 RUN_AND_CHECK_RESULT( | |
| 380 EXPECT_FALSE, RunUntilTime(base::TimeTicks::FromInternalValue(100)), ""); | |
| 381 EXPECT_EQ(base::TimeTicks::FromInternalValue(100), now_src_->Now()); | |
| 382 | |
| 383 RUN_AND_CHECK_RESULT( | |
| 384 EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromInternalValue(100)), ""); | |
| 385 EXPECT_EQ(base::TimeTicks::FromInternalValue(200), now_src_->Now()); | |
| 386 | |
| 387 base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue); | |
| 388 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(return_true), ""); | |
| 389 } | |
| 390 | |
| 391 TEST_F(OrderedSimpleTaskRunnerTest, RunPendingTasksTimeout) { | |
| 392 PostTask(1, base::TimeDelta()); | |
| 393 PostTask(2, base::TimeDelta()); | |
| 394 PostTask(3, base::TimeDelta()); | |
| 395 PostTask(4, base::TimeDelta()); | |
| 396 PostTask(5, base::TimeDelta()); | |
| 397 PostTask(6, base::TimeDelta()); | |
| 398 | |
| 399 task_runner_->SetRunTaskLimit(3); | |
| 400 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)"); | |
| 401 | |
| 402 task_runner_->SetRunTaskLimit(2); | |
| 403 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "4(0ms) 5(0ms)"); | |
| 404 | |
| 405 task_runner_->SetRunTaskLimit(0); | |
| 406 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), ""); | |
| 407 } | |
| 408 | |
| 409 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdleTimeout) { | |
| 410 PostTaskWhichPostsTaskAgain(1, base::TimeDelta::FromMilliseconds(3)); | |
| 411 | |
| 412 task_runner_->SetRunTaskLimit(3); | |
| 413 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), "1(3ms) 1(6ms) 1(9ms)"); | |
| 414 | |
| 415 task_runner_->SetRunTaskLimit(2); | |
| 416 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), "1(12ms) 1(15ms)"); | |
| 417 | |
| 418 task_runner_->SetRunTaskLimit(0); | |
| 419 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), ""); | |
| 420 } | |
| 421 | |
| 422 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeout) { | |
| 423 base::TimeTicks run_to = base::TimeTicks() + base::TimeDelta::FromSeconds(1); | |
| 424 | |
| 425 PostTask(1, base::TimeDelta::FromMilliseconds(1)); | |
| 426 PostTask(2, base::TimeDelta::FromMilliseconds(2)); | |
| 427 PostTask(3, base::TimeDelta::FromMilliseconds(3)); | |
| 428 PostTask(4, base::TimeDelta::FromMilliseconds(4)); | |
| 429 PostTask(5, base::TimeDelta::FromMilliseconds(5)); | |
| 430 | |
| 431 EXPECT_EQ(base::TimeTicks(), now_src_->Now()); | |
| 432 task_runner_->SetRunTaskLimit(3); | |
| 433 RUN_AND_CHECK_RESULT( | |
| 434 EXPECT_TRUE, RunUntilTime(run_to), "1(1ms) 2(2ms) 3(3ms)"); | |
| 435 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3), | |
| 436 now_src_->Now()); | |
| 437 | |
| 438 task_runner_->SetRunTaskLimit(0); | |
| 439 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilTime(run_to), ""); | |
| 440 | |
| 441 task_runner_->SetRunTaskLimit(100); | |
| 442 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_to), "4(4ms) 5(5ms)"); | |
| 443 EXPECT_EQ(run_to, now_src_->Now()); | |
| 444 } | |
| 445 | |
| 446 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
