base/timer_unittest.cc

   1 // Copyright (c) 2012 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/memory/scoped_ptr.h"
   6 #include "base/message_loop.h"
   7 #include "base/timer.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 using base::TimeDelta;
  11
  12 namespace {
  13
  14 class OneShotTimerTester {
  15  public:
  16   OneShotTimerTester(bool* did_run, unsigned milliseconds = 10)
  17       : did_run_(did_run),
  18         delay_ms_(milliseconds) {
  19   }
  20   void Start() {
  21     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(delay_ms_), this,
  22                  &OneShotTimerTester::Run);
  23   }
  24  private:
  25   void Run() {
  26     *did_run_ = true;
  27     MessageLoop::current()->Quit();
  28   }
  29   bool* did_run_;
  30   base::OneShotTimer<OneShotTimerTester> timer_;
  31   const unsigned delay_ms_;
  32 };
  33
  34 class OneShotSelfDeletingTimerTester {
  35  public:
  36   explicit OneShotSelfDeletingTimerTester(bool* did_run) :
  37       did_run_(did_run),
  38       timer_(new base::OneShotTimer<OneShotSelfDeletingTimerTester>()) {
  39   }
  40   void Start() {
  41     timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
  42                   &OneShotSelfDeletingTimerTester::Run);
  43   }
  44  private:
  45   void Run() {
  46     *did_run_ = true;
  47     timer_.reset();
  48     MessageLoop::current()->Quit();
  49   }
  50   bool* did_run_;
  51   scoped_ptr<base::OneShotTimer<OneShotSelfDeletingTimerTester> > timer_;
  52 };
  53
  54 class RepeatingTimerTester {
  55  public:
  56   explicit RepeatingTimerTester(bool* did_run)
  57       : did_run_(did_run), counter_(10) {
  58   }
  59
  60   void Start() {
  61     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
  62                  &RepeatingTimerTester::Run);
  63   }
  64  private:
  65   void Run() {
  66     if (--counter_ == 0) {
  67       *did_run_ = true;
  68       MessageLoop::current()->Quit();
  69     }
  70   }
  71   bool* did_run_;
  72   int counter_;
  73   base::RepeatingTimer<RepeatingTimerTester> timer_;
  74 };
  75
  76 void RunTest_OneShotTimer(MessageLoop::Type message_loop_type) {
  77   MessageLoop loop(message_loop_type);
  78
  79   bool did_run = false;
  80   OneShotTimerTester f(&did_run);
  81   f.Start();
  82
  83   MessageLoop::current()->Run();
  84
  85   EXPECT_TRUE(did_run);
  86 }
  87
  88 void RunTest_OneShotTimer_Cancel(MessageLoop::Type message_loop_type) {
  89   MessageLoop loop(message_loop_type);
  90
  91   bool did_run_a = false;
  92   OneShotTimerTester* a = new OneShotTimerTester(&did_run_a);
  93
  94   // This should run before the timer expires.
  95   MessageLoop::current()->DeleteSoon(FROM_HERE, a);
  96
  97   // Now start the timer.
  98   a->Start();
  99
 100   bool did_run_b = false;
 101   OneShotTimerTester b(&did_run_b);
 102   b.Start();
 103
 104   MessageLoop::current()->Run();
 105
 106   EXPECT_FALSE(did_run_a);
 107   EXPECT_TRUE(did_run_b);
 108 }
 109
 110 void RunTest_OneShotSelfDeletingTimer(MessageLoop::Type message_loop_type) {
 111   MessageLoop loop(message_loop_type);
 112
 113   bool did_run = false;
 114   OneShotSelfDeletingTimerTester f(&did_run);
 115   f.Start();
 116
 117   MessageLoop::current()->Run();
 118
 119   EXPECT_TRUE(did_run);
 120 }
 121
 122 void RunTest_RepeatingTimer(MessageLoop::Type message_loop_type) {
 123   MessageLoop loop(message_loop_type);
 124
 125   bool did_run = false;
 126   RepeatingTimerTester f(&did_run);
 127   f.Start();
 128
 129   MessageLoop::current()->Run();
 130
 131   EXPECT_TRUE(did_run);
 132 }
 133
 134 void RunTest_RepeatingTimer_Cancel(MessageLoop::Type message_loop_type) {
 135   MessageLoop loop(message_loop_type);
 136
 137   bool did_run_a = false;
 138   RepeatingTimerTester* a = new RepeatingTimerTester(&did_run_a);
 139
 140   // This should run before the timer expires.
 141   MessageLoop::current()->DeleteSoon(FROM_HERE, a);
 142
 143   // Now start the timer.
 144   a->Start();
 145
 146   bool did_run_b = false;
 147   RepeatingTimerTester b(&did_run_b);
 148   b.Start();
 149
 150   MessageLoop::current()->Run();
 151
 152   EXPECT_FALSE(did_run_a);
 153   EXPECT_TRUE(did_run_b);
 154 }
 155
 156 class DelayTimerTarget {
 157  public:
 158   DelayTimerTarget()
 159       : signaled_(false) {
 160   }
 161
 162   bool signaled() const { return signaled_; }
 163
 164   void Signal() {
 165     ASSERT_FALSE(signaled_);
 166     signaled_ = true;
 167   }
 168
 169  private:
 170   bool signaled_;
 171 };
 172
 173 void RunTest_DelayTimer_NoCall(MessageLoop::Type message_loop_type) {
 174   MessageLoop loop(message_loop_type);
 175
 176   // If Delay is never called, the timer shouldn't go off.
 177   DelayTimerTarget target;
 178   base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
 179       TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
 180
 181   bool did_run = false;
 182   OneShotTimerTester tester(&did_run);
 183   tester.Start();
 184   MessageLoop::current()->Run();
 185
 186   ASSERT_FALSE(target.signaled());
 187 }
 188
 189 void RunTest_DelayTimer_OneCall(MessageLoop::Type message_loop_type) {
 190   MessageLoop loop(message_loop_type);
 191
 192   DelayTimerTarget target;
 193   base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
 194       TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
 195   timer.Reset();
 196
 197   bool did_run = false;
 198   OneShotTimerTester tester(&did_run, 100 /* milliseconds */);
 199   tester.Start();
 200   MessageLoop::current()->Run();
 201
 202   ASSERT_TRUE(target.signaled());
 203 }
 204
 205 struct ResetHelper {
 206   ResetHelper(base::DelayTimer<DelayTimerTarget>* timer,
 207               DelayTimerTarget* target)
 208       : timer_(timer),
 209         target_(target) {
 210   }
 211
 212   void Reset() {
 213     ASSERT_FALSE(target_->signaled());
 214     timer_->Reset();
 215   }
 216
 217  private:
 218   base::DelayTimer<DelayTimerTarget> *const timer_;
 219   DelayTimerTarget *const target_;
 220 };
 221
 222 void RunTest_DelayTimer_Reset(MessageLoop::Type message_loop_type) {
 223   MessageLoop loop(message_loop_type);
 224
 225   // If Delay is never called, the timer shouldn't go off.
 226   DelayTimerTarget target;
 227   base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
 228       TimeDelta::FromMilliseconds(50), &target, &DelayTimerTarget::Signal);
 229   timer.Reset();
 230
 231   ResetHelper reset_helper(&timer, &target);
 232
 233   base::OneShotTimer<ResetHelper> timers[20];
 234   for (size_t i = 0; i < arraysize(timers); ++i) {
 235     timers[i].Start(FROM_HERE, TimeDelta::FromMilliseconds(i * 10),
 236                     &reset_helper, &ResetHelper::Reset);
 237   }
 238
 239   bool did_run = false;
 240   OneShotTimerTester tester(&did_run, 300);
 241   tester.Start();
 242   MessageLoop::current()->Run();
 243
 244   ASSERT_TRUE(target.signaled());
 245 }
 246
 247 class DelayTimerFatalTarget {
 248  public:
 249   void Signal() {
 250     ASSERT_TRUE(false);
 251   }
 252 };
 253
 254
 255 void RunTest_DelayTimer_Deleted(MessageLoop::Type message_loop_type) {
 256   MessageLoop loop(message_loop_type);
 257
 258   DelayTimerFatalTarget target;
 259
 260   {
 261     base::DelayTimer<DelayTimerFatalTarget> timer(
 262         FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
 263         &DelayTimerFatalTarget::Signal);
 264     timer.Reset();
 265   }
 266
 267   // When the timer is deleted, the DelayTimerFatalTarget should never be
 268   // called.
 269   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 270 }
 271
 272 }  // namespace
 273
 274 //-----------------------------------------------------------------------------
 275 // Each test is run against each type of MessageLoop.  That way we are sure
 276 // that timers work properly in all configurations.
 277
 278 TEST(TimerTest, OneShotTimer) {
 279   RunTest_OneShotTimer(MessageLoop::TYPE_DEFAULT);
 280   RunTest_OneShotTimer(MessageLoop::TYPE_UI);
 281   RunTest_OneShotTimer(MessageLoop::TYPE_IO);
 282 }
 283
 284 TEST(TimerTest, OneShotTimer_Cancel) {
 285   RunTest_OneShotTimer_Cancel(MessageLoop::TYPE_DEFAULT);
 286   RunTest_OneShotTimer_Cancel(MessageLoop::TYPE_UI);
 287   RunTest_OneShotTimer_Cancel(MessageLoop::TYPE_IO);
 288 }
 289
 290 // If underline timer does not handle properly, we will crash or fail
 291 // in full page heap environment.
 292 TEST(TimerTest, OneShotSelfDeletingTimer) {
 293   RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_DEFAULT);
 294   RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_UI);
 295   RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_IO);
 296 }
 297
 298 TEST(TimerTest, RepeatingTimer) {
 299   RunTest_RepeatingTimer(MessageLoop::TYPE_DEFAULT);
 300   RunTest_RepeatingTimer(MessageLoop::TYPE_UI);
 301   RunTest_RepeatingTimer(MessageLoop::TYPE_IO);
 302 }
 303
 304 TEST(TimerTest, RepeatingTimer_Cancel) {
 305   RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_DEFAULT);
 306   RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_UI);
 307   RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_IO);
 308 }
 309
 310 TEST(TimerTest, DelayTimer_NoCall) {
 311   RunTest_DelayTimer_NoCall(MessageLoop::TYPE_DEFAULT);
 312   RunTest_DelayTimer_NoCall(MessageLoop::TYPE_UI);
 313   RunTest_DelayTimer_NoCall(MessageLoop::TYPE_IO);
 314 }
 315
 316 TEST(TimerTest, DelayTimer_OneCall) {
 317   RunTest_DelayTimer_OneCall(MessageLoop::TYPE_DEFAULT);
 318   RunTest_DelayTimer_OneCall(MessageLoop::TYPE_UI);
 319   RunTest_DelayTimer_OneCall(MessageLoop::TYPE_IO);
 320 }
 321
 322 // It's flaky on the buildbot, http://crbug.com/25038.
 323 TEST(TimerTest, DISABLED_DelayTimer_Reset) {
 324   RunTest_DelayTimer_Reset(MessageLoop::TYPE_DEFAULT);
 325   RunTest_DelayTimer_Reset(MessageLoop::TYPE_UI);
 326   RunTest_DelayTimer_Reset(MessageLoop::TYPE_IO);
 327 }
 328
 329 TEST(TimerTest, DelayTimer_Deleted) {
 330   RunTest_DelayTimer_Deleted(MessageLoop::TYPE_DEFAULT);
 331   RunTest_DelayTimer_Deleted(MessageLoop::TYPE_UI);
 332   RunTest_DelayTimer_Deleted(MessageLoop::TYPE_IO);
 333 }
 334
 335 TEST(TimerTest, MessageLoopShutdown) {
 336   // This test is designed to verify that shutdown of the
 337   // message loop does not cause crashes if there were pending
 338   // timers not yet fired.  It may only trigger exceptions
 339   // if debug heap checking is enabled.
 340   bool did_run = false;
 341   {
 342     OneShotTimerTester a(&did_run);
 343     OneShotTimerTester b(&did_run);
 344     OneShotTimerTester c(&did_run);
 345     OneShotTimerTester d(&did_run);
 346     {
 347       MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 348       a.Start();
 349       b.Start();
 350     }  // MessageLoop destructs by falling out of scope.
 351   }  // OneShotTimers destruct.  SHOULD NOT CRASH, of course.
 352
 353   EXPECT_FALSE(did_run);
 354 }
 355
 356 void TimerTestCallback() {
 357 }
 358
 359 TEST(TimerTest, NonRepeatIsRunning) {
 360   {
 361     MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 362     base::Timer timer(false, false);
 363     EXPECT_FALSE(timer.IsRunning());
 364     timer.Start(FROM_HERE, TimeDelta::FromDays(1),
 365                 base::Bind(&TimerTestCallback));
 366     EXPECT_TRUE(timer.IsRunning());
 367     timer.Stop();
 368     EXPECT_FALSE(timer.IsRunning());
 369     EXPECT_TRUE(timer.user_task().is_null());
 370   }
 371
 372   {
 373     base::Timer timer(true, false);
 374     MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 375     EXPECT_FALSE(timer.IsRunning());
 376     timer.Start(FROM_HERE, TimeDelta::FromDays(1),
 377                 base::Bind(&TimerTestCallback));
 378     EXPECT_TRUE(timer.IsRunning());
 379     timer.Stop();
 380     EXPECT_FALSE(timer.IsRunning());
 381     ASSERT_FALSE(timer.user_task().is_null());
 382     timer.Reset();
 383     EXPECT_TRUE(timer.IsRunning());
 384   }
 385 }
 386
 387 TEST(TimerTest, NonRepeatMessageLoopDeath) {
 388   base::Timer timer(false, false);
 389   {
 390     MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 391     EXPECT_FALSE(timer.IsRunning());
 392     timer.Start(FROM_HERE, TimeDelta::FromDays(1),
 393                 base::Bind(&TimerTestCallback));
 394     EXPECT_TRUE(timer.IsRunning());
 395   }
 396   EXPECT_FALSE(timer.IsRunning());
 397   EXPECT_TRUE(timer.user_task().is_null());
 398 }
 399
 400 TEST(TimerTest, RetainRepeatIsRunning) {
 401   MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 402   base::Timer timer(FROM_HERE, TimeDelta::FromDays(1),
 403                     base::Bind(&TimerTestCallback), true);
 404   EXPECT_FALSE(timer.IsRunning());
 405   timer.Reset();
 406   EXPECT_TRUE(timer.IsRunning());
 407   timer.Stop();
 408   EXPECT_FALSE(timer.IsRunning());
 409   timer.Reset();
 410   EXPECT_TRUE(timer.IsRunning());
 411 }
 412
 413 TEST(TimerTest, RetainNonRepeatIsRunning) {
 414   MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 415   base::Timer timer(FROM_HERE, TimeDelta::FromDays(1),
 416                     base::Bind(&TimerTestCallback), false);
 417   EXPECT_FALSE(timer.IsRunning());
 418   timer.Reset();
 419   EXPECT_TRUE(timer.IsRunning());
 420   timer.Stop();
 421   EXPECT_FALSE(timer.IsRunning());
 422   timer.Reset();
 423   EXPECT_TRUE(timer.IsRunning());
 424 }
 425
 426 namespace {
 427
 428 bool g_callback_happened1 = false;
 429 bool g_callback_happened2 = false;
 430
 431 void ClearAllCallbackHappened() {
 432   g_callback_happened1 = false;
 433   g_callback_happened2 = false;
 434 }
 435
 436 void SetCallbackHappened1() {
 437   g_callback_happened1 = true;
 438   MessageLoop::current()->Quit();
 439 }
 440
 441 void SetCallbackHappened2() {
 442   g_callback_happened2 = true;
 443   MessageLoop::current()->Quit();
 444 }
 445
 446 TEST(TimerTest, ContinuationStopStart) {
 447   {
 448     ClearAllCallbackHappened();
 449     MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 450     base::Timer timer(false, false);
 451     timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10),
 452                 base::Bind(&SetCallbackHappened1));
 453     timer.Stop();
 454     timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(40),
 455                 base::Bind(&SetCallbackHappened2));
 456     MessageLoop::current()->Run();
 457     EXPECT_FALSE(g_callback_happened1);
 458     EXPECT_TRUE(g_callback_happened2);
 459   }
 460 }
 461
 462 TEST(TimerTest, ContinuationReset) {
 463   {
 464     ClearAllCallbackHappened();
 465     MessageLoop loop(MessageLoop::TYPE_DEFAULT);
 466     base::Timer timer(false, false);
 467     timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10),
 468                 base::Bind(&SetCallbackHappened1));
 469     timer.Reset();
 470     // Since Reset happened before task ran, the user_task must not be cleared:
 471     ASSERT_FALSE(timer.user_task().is_null());
 472     MessageLoop::current()->Run();
 473     EXPECT_TRUE(g_callback_happened1);
 474   }
 475 }
 476
 477 }  // namespace