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 24namespace { 25 26bool ReturnTrue() { 27 return true; 28} 29 30bool ReturnFalse() { 31 return false; 32} 33}; 34 35namespace cc { 36 37TEST(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 56class 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 virtual ~OrderedSimpleTaskRunnerTest() {} 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 146TEST_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 159TEST_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 170TEST_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 184TEST_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 202TEST_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 220TEST_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 230TEST_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 243TEST_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 254TEST_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 268TEST_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 288TEST_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 294TEST_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 317TEST_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 340TEST_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 363TEST_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 373TEST_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 391TEST_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 409TEST_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 422TEST_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 447