third_party/WebKit/Source/platform/TimerTest.cpp

   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
   3 // found in the LICENSE file.
   4
   5 #include "config.h"
   6 #include "platform/Timer.h"
   7
   8 #include "public/platform/Platform.h"
   9 #include "public/platform/WebScheduler.h"
  10 #include "public/platform/WebThread.h"
  11 #include <gmock/gmock.h>
  12 #include <gtest/gtest.h>
  13 #include <queue>
  14
  15 using testing::ElementsAre;
  16
  17 namespace blink {
  18 namespace {
  19 double gCurrentTimeSecs = 0.0;
  20
  21 double currentTime()
  22 {
  23     return gCurrentTimeSecs;
  24 }
  25
  26 // This class exists because gcc doesn't know how to move an OwnPtr.
  27 class RefCountedTaskContainer : public RefCounted<RefCountedTaskContainer> {
  28 public:
  29     explicit RefCountedTaskContainer(WebTaskRunner::Task* task) : m_task(adoptPtr(task)) { }
  30
  31     ~RefCountedTaskContainer() { }
  32
  33     void run()
  34     {
  35         m_task->run();
  36     }
  37
  38 private:
  39     OwnPtr<WebTaskRunner::Task> m_task;
  40 };
  41
  42 class DelayedTask {
  43 public:
  44     DelayedTask(WebTaskRunner::Task* task, long long delayMs)
  45         : m_task(adoptRef(new RefCountedTaskContainer(task)))
  46         , m_runTimeSecs(monotonicallyIncreasingTime() + 0.001 * static_cast<double>(delayMs))
  47         , m_delayMs(delayMs) { }
  48
  49     bool operator<(const DelayedTask& other) const
  50     {
  51         return m_runTimeSecs > other.m_runTimeSecs;
  52     }
  53
  54     void run() const
  55     {
  56         m_task->run();
  57     }
  58
  59     double runTimeSecs() const
  60     {
  61         return m_runTimeSecs;
  62     }
  63
  64     long long delayMs() const
  65     {
  66         return m_delayMs;
  67     }
  68
  69 private:
  70     RefPtr<RefCountedTaskContainer> m_task;
  71     double m_runTimeSecs;
  72     long long m_delayMs;
  73 };
  74
  75 class MockWebTaskRunner : public WebTaskRunner {
  76 public:
  77     explicit MockWebTaskRunner(std::priority_queue<DelayedTask>* timerTasks) : m_timerTasks(timerTasks) { }
  78     ~MockWebTaskRunner() override { }
  79
  80     virtual void postTask(const WebTraceLocation&, Task* task)
  81     {
  82         m_timerTasks->push(DelayedTask(task, 0));
  83     }
  84
  85     void postDelayedTask(const WebTraceLocation&, Task* task, long long delayMs) override
  86     {
  87         m_timerTasks->push(DelayedTask(task, delayMs));
  88     }
  89
  90     std::priority_queue<DelayedTask>* m_timerTasks; // NOT OWNED
  91 };
  92
  93 class MockWebScheduler : public WebScheduler {
  94 public:
  95     MockWebScheduler() : m_timerWebTaskRunner(&m_timerTasks) { }
  96     ~MockWebScheduler() override { }
  97
  98     bool shouldYieldForHighPriorityWork() override
  99     {
 100         return false;
 101     }
 102
 103     bool canExceedIdleDeadlineIfRequired() override
 104     {
 105         return false;
 106     }
 107
 108     void postIdleTask(const WebTraceLocation&, WebThread::IdleTask*) override
 109     {
 110     }
 111
 112     void postNonNestableIdleTask(const WebTraceLocation&, WebThread::IdleTask*) override
 113     {
 114     }
 115
 116     void postIdleTaskAfterWakeup(const WebTraceLocation&, WebThread::IdleTask*) override
 117     {
 118     }
 119
 120     WebTaskRunner* timerTaskRunner() override
 121     {
 122         return &m_timerWebTaskRunner;
 123     }
 124
 125     WebTaskRunner* loadingTaskRunner() override
 126     {
 127         ASSERT_NOT_REACHED();
 128         return nullptr;
 129     }
 130
 131     void postTimerTaskAt(const WebTraceLocation&, WebTaskRunner::Task* task, double monotonicTime) override
 132     {
 133         m_timerTasks.push(DelayedTask(task, (monotonicTime - monotonicallyIncreasingTime()) * 1000));
 134     }
 135
 136     void runUntilIdle()
 137     {
 138         while (!m_timerTasks.empty()) {
 139             gCurrentTimeSecs = m_timerTasks.top().runTimeSecs();
 140             m_timerTasks.top().run();
 141             m_timerTasks.pop();
 142         }
 143     }
 144
 145     void runUntilIdleOrDeadlinePassed(double deadline)
 146     {
 147         while (!m_timerTasks.empty()) {
 148             if (m_timerTasks.top().runTimeSecs() > deadline) {
 149                 gCurrentTimeSecs = deadline;
 150                 break;
 151             }
 152             gCurrentTimeSecs = m_timerTasks.top().runTimeSecs();
 153             m_timerTasks.top().run();
 154             m_timerTasks.pop();
 155         }
 156     }
 157
 158     bool hasOneTimerTask() const
 159     {
 160         return m_timerTasks.size() == 1;
 161     }
 162
 163     long nextTimerTaskDelayMillis() const
 164     {
 165         ASSERT(hasOneTimerTask());
 166         return m_timerTasks.top().delayMs();
 167     }
 168
 169 private:
 170     std::priority_queue<DelayedTask> m_timerTasks;
 171     MockWebTaskRunner m_timerWebTaskRunner;
 172 };
 173
 174 class FakeWebThread : public WebThread {
 175 public:
 176     FakeWebThread() : m_webScheduler(adoptPtr(new MockWebScheduler())) { }
 177     ~FakeWebThread() override { }
 178
 179     virtual bool isCurrentThread() const
 180     {
 181         ASSERT_NOT_REACHED();
 182         return true;
 183     }
 184
 185     virtual PlatformThreadId threadId() const
 186     {
 187         ASSERT_NOT_REACHED();
 188         return 0;
 189     }
 190
 191     WebTaskRunner* taskRunner() override
 192     {
 193         ASSERT_NOT_REACHED();
 194         return nullptr;
 195     }
 196
 197     WebScheduler* scheduler() const override
 198     {
 199         return m_webScheduler.get();
 200     }
 201
 202     virtual void enterRunLoop()
 203     {
 204         ASSERT_NOT_REACHED();
 205     }
 206
 207     virtual void exitRunLoop()
 208     {
 209         ASSERT_NOT_REACHED();
 210     }
 211
 212 private:
 213     OwnPtr<MockWebScheduler> m_webScheduler;
 214 };
 215
 216 class TimerTestPlatform : public Platform {
 217 public:
 218     TimerTestPlatform()
 219         : m_webThread(adoptPtr(new FakeWebThread())) { }
 220     ~TimerTestPlatform() override { }
 221
 222     WebThread* currentThread() override
 223     {
 224         return m_webThread.get();
 225     }
 226
 227     void cryptographicallyRandomValues(unsigned char*, size_t) override
 228     {
 229         ASSERT_NOT_REACHED();
 230     }
 231
 232     const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) override
 233     {
 234         static const unsigned char enabled[] = {0};
 235         return enabled;
 236     }
 237
 238     void runUntilIdle()
 239     {
 240         mockScheduler()->runUntilIdle();
 241     }
 242
 243     void runUntilIdleOrDeadlinePassed(double deadline)
 244     {
 245         mockScheduler()->runUntilIdleOrDeadlinePassed(deadline);
 246     }
 247
 248     bool hasOneTimerTask() const
 249     {
 250         return mockScheduler()->hasOneTimerTask();
 251     }
 252
 253     long nextTimerTaskDelayMillis() const
 254     {
 255         return mockScheduler()->nextTimerTaskDelayMillis();
 256     }
 257
 258 private:
 259     MockWebScheduler* mockScheduler() const
 260     {
 261         return static_cast<MockWebScheduler*>(m_webThread->scheduler());
 262     }
 263
 264     OwnPtr<FakeWebThread> m_webThread;
 265 };
 266
 267 class TimerTest : public testing::Test {
 268 public:
 269     void SetUp() override
 270     {
 271         m_platform = adoptPtr(new TimerTestPlatform());
 272         m_oldPlatform = Platform::current();
 273         Platform::initialize(m_platform.get());
 274         WTF::setMonotonicallyIncreasingTimeFunction(currentTime);
 275
 276         m_runTimes.clear();
 277         gCurrentTimeSecs = 10.0;
 278         m_startTime = gCurrentTimeSecs;
 279     }
 280
 281     void TearDown() override
 282     {
 283         Platform::initialize(m_oldPlatform);
 284     }
 285
 286     void countingTask(Timer<TimerTest>*)
 287     {
 288         m_runTimes.push_back(monotonicallyIncreasingTime());
 289     }
 290
 291     void advanceTimeBy(double timeSecs)
 292     {
 293         gCurrentTimeSecs += timeSecs;
 294     }
 295
 296     void runUntilIdle()
 297     {
 298         m_platform->runUntilIdle();
 299     }
 300
 301     void runUntilIdleOrDeadlinePassed(double deadline)
 302     {
 303         m_platform->runUntilIdleOrDeadlinePassed(deadline);
 304     }
 305
 306     bool hasOneTimerTask() const
 307     {
 308         return m_platform->hasOneTimerTask();
 309     }
 310
 311     long nextTimerTaskDelayMillis() const
 312     {
 313         return m_platform->nextTimerTaskDelayMillis();
 314     }
 315
 316 protected:
 317     double m_startTime;
 318     std::vector<double> m_runTimes;
 319
 320 private:
 321     OwnPtr<TimerTestPlatform> m_platform;
 322     Platform* m_oldPlatform;
 323 };
 324
 325 TEST_F(TimerTest, StartOneShot_Zero)
 326 {
 327     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 328     timer.startOneShot(0, FROM_HERE);
 329
 330     ASSERT(hasOneTimerTask());
 331     EXPECT_EQ(0ll, nextTimerTaskDelayMillis());
 332
 333     runUntilIdle();
 334     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));
 335 }
 336
 337 TEST_F(TimerTest, StartOneShot_ZeroAndCancel)
 338 {
 339     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 340     timer.startOneShot(0, FROM_HERE);
 341
 342     ASSERT(hasOneTimerTask());
 343     EXPECT_EQ(0ll, nextTimerTaskDelayMillis());
 344
 345     timer.stop();
 346
 347     runUntilIdle();
 348     EXPECT_TRUE(m_runTimes.empty());
 349 }
 350
 351 TEST_F(TimerTest, StartOneShot_ZeroAndCancelThenRepost)
 352 {
 353     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 354     timer.startOneShot(0, FROM_HERE);
 355
 356     ASSERT(hasOneTimerTask());
 357     EXPECT_EQ(0ll, nextTimerTaskDelayMillis());
 358
 359     timer.stop();
 360
 361     runUntilIdle();
 362     EXPECT_TRUE(m_runTimes.empty());
 363
 364     timer.startOneShot(0, FROM_HERE);
 365
 366     ASSERT(hasOneTimerTask());
 367     EXPECT_EQ(0ll, nextTimerTaskDelayMillis());
 368
 369     runUntilIdle();
 370     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));
 371 }
 372
 373 TEST_F(TimerTest, StartOneShot_Zero_RepostingAfterRunning)
 374 {
 375     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 376     timer.startOneShot(0, FROM_HERE);
 377
 378     ASSERT(hasOneTimerTask());
 379     EXPECT_EQ(0ll, nextTimerTaskDelayMillis());
 380
 381     runUntilIdle();
 382     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));
 383
 384     timer.startOneShot(0, FROM_HERE);
 385
 386     ASSERT(hasOneTimerTask());
 387     EXPECT_EQ(0ll, nextTimerTaskDelayMillis());
 388
 389     runUntilIdle();
 390     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime, m_startTime));
 391 }
 392
 393 TEST_F(TimerTest, StartOneShot_NonZero)
 394 {
 395     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 396     timer.startOneShot(10.0, FROM_HERE);
 397
 398     ASSERT(hasOneTimerTask());
 399     EXPECT_EQ(10000ll, nextTimerTaskDelayMillis());
 400
 401     runUntilIdle();
 402     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 403 }
 404
 405 TEST_F(TimerTest, StartOneShot_NonZeroAndCancel)
 406 {
 407     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 408     timer.startOneShot(10, FROM_HERE);
 409
 410     ASSERT(hasOneTimerTask());
 411     EXPECT_EQ(10000ll, nextTimerTaskDelayMillis());
 412
 413     timer.stop();
 414
 415     runUntilIdle();
 416     EXPECT_TRUE(m_runTimes.empty());
 417 }
 418
 419 TEST_F(TimerTest, StartOneShot_NonZeroAndCancelThenRepost)
 420 {
 421     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 422     timer.startOneShot(10, FROM_HERE);
 423
 424     ASSERT(hasOneTimerTask());
 425     EXPECT_EQ(10000ll, nextTimerTaskDelayMillis());
 426
 427     timer.stop();
 428
 429     runUntilIdle();
 430     EXPECT_TRUE(m_runTimes.empty());
 431
 432     double secondPostTime = monotonicallyIncreasingTime();
 433     timer.startOneShot(10, FROM_HERE);
 434
 435     ASSERT(hasOneTimerTask());
 436     EXPECT_EQ(10000ll, nextTimerTaskDelayMillis());
 437
 438     runUntilIdle();
 439     EXPECT_THAT(m_runTimes, ElementsAre(secondPostTime + 10.0));
 440 }
 441
 442 TEST_F(TimerTest, StartOneShot_NonZero_RepostingAfterRunning)
 443 {
 444     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 445     timer.startOneShot(10, FROM_HERE);
 446
 447     ASSERT(hasOneTimerTask());
 448     EXPECT_EQ(10000ll, nextTimerTaskDelayMillis());
 449
 450     runUntilIdle();
 451     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 452
 453     timer.startOneShot(20, FROM_HERE);
 454
 455     ASSERT(hasOneTimerTask());
 456     EXPECT_EQ(20000ll, nextTimerTaskDelayMillis());
 457
 458     runUntilIdle();
 459     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0, m_startTime + 30.0));
 460 }
 461
 462 TEST_F(TimerTest, PostingTimerTwiceWithSameRunTimeDoesNothing)
 463 {
 464     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 465     timer.startOneShot(10, FROM_HERE);
 466     timer.startOneShot(10, FROM_HERE);
 467
 468     ASSERT(hasOneTimerTask());
 469     EXPECT_EQ(10000ll, nextTimerTaskDelayMillis());
 470
 471     runUntilIdle();
 472     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 473 }
 474
 475 TEST_F(TimerTest, PostingTimerTwiceWithNewerRunTimeCancelsOriginalTask)
 476 {
 477     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 478     timer.startOneShot(10, FROM_HERE);
 479     timer.startOneShot(0, FROM_HERE);
 480
 481     runUntilIdle();
 482     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 0.0));
 483 }
 484
 485 TEST_F(TimerTest, PostingTimerTwiceWithLaterRunTimeCancelsOriginalTask)
 486 {
 487     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 488     timer.startOneShot(0, FROM_HERE);
 489     timer.startOneShot(10, FROM_HERE);
 490
 491     runUntilIdle();
 492     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 493 }
 494
 495 TEST_F(TimerTest, StartRepeatingTask)
 496 {
 497     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 498     timer.startRepeating(1.0, FROM_HERE);
 499
 500     ASSERT(hasOneTimerTask());
 501     EXPECT_EQ(1000ll, nextTimerTaskDelayMillis());
 502
 503     runUntilIdleOrDeadlinePassed(m_startTime + 5.5);
 504     EXPECT_THAT(m_runTimes, ElementsAre(
 505         m_startTime + 1.0, m_startTime + 2.0, m_startTime + 3.0, m_startTime + 4.0, m_startTime + 5.0));
 506 }
 507
 508 TEST_F(TimerTest, StartRepeatingTask_ThenCancel)
 509 {
 510     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 511     timer.startRepeating(1.0, FROM_HERE);
 512
 513     ASSERT(hasOneTimerTask());
 514     EXPECT_EQ(1000ll, nextTimerTaskDelayMillis());
 515
 516     runUntilIdleOrDeadlinePassed(m_startTime + 2.5);
 517     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));
 518
 519     timer.stop();
 520     runUntilIdle();
 521
 522     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));
 523 }
 524
 525 TEST_F(TimerTest, StartRepeatingTask_ThenPostOneShot)
 526 {
 527     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 528     timer.startRepeating(1.0, FROM_HERE);
 529
 530     ASSERT(hasOneTimerTask());
 531     EXPECT_EQ(1000ll, nextTimerTaskDelayMillis());
 532
 533     runUntilIdleOrDeadlinePassed(m_startTime + 2.5);
 534     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));
 535
 536     timer.startOneShot(0, FROM_HERE);
 537     runUntilIdle();
 538
 539     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0, m_startTime + 2.5));
 540 }
 541
 542 TEST_F(TimerTest, IsActive_NeverPosted)
 543 {
 544     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 545
 546     EXPECT_FALSE(timer.isActive());
 547 }
 548
 549 TEST_F(TimerTest, IsActive_AfterPosting_OneShotZero)
 550 {
 551     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 552     timer.startOneShot(0, FROM_HERE);
 553
 554     EXPECT_TRUE(timer.isActive());
 555 }
 556
 557 TEST_F(TimerTest, IsActive_AfterPosting_OneShotNonZero)
 558 {
 559     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 560     timer.startOneShot(10, FROM_HERE);
 561
 562     EXPECT_TRUE(timer.isActive());
 563 }
 564
 565 TEST_F(TimerTest, IsActive_AfterPosting_Repeating)
 566 {
 567     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 568     timer.startRepeating(1.0, FROM_HERE);
 569
 570     EXPECT_TRUE(timer.isActive());
 571 }
 572
 573 TEST_F(TimerTest, IsActive_AfterRunning_OneShotZero)
 574 {
 575     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 576     timer.startOneShot(0, FROM_HERE);
 577
 578     runUntilIdle();
 579     EXPECT_FALSE(timer.isActive());
 580 }
 581
 582 TEST_F(TimerTest, IsActive_AfterRunning_OneShotNonZero)
 583 {
 584     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 585     timer.startOneShot(10, FROM_HERE);
 586
 587     runUntilIdle();
 588     EXPECT_FALSE(timer.isActive());
 589 }
 590
 591 TEST_F(TimerTest, IsActive_AfterRunning_Repeating)
 592 {
 593     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 594     timer.startRepeating(1.0, FROM_HERE);
 595
 596     runUntilIdleOrDeadlinePassed(m_startTime + 10);
 597     EXPECT_TRUE(timer.isActive()); // It should run until cancelled.
 598 }
 599
 600 TEST_F(TimerTest, NextFireInterval_OneShotZero)
 601 {
 602     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 603     timer.startOneShot(0, FROM_HERE);
 604
 605     EXPECT_FLOAT_EQ(0.0, timer.nextFireInterval());
 606 }
 607
 608 TEST_F(TimerTest, NextFireInterval_OneShotNonZero)
 609 {
 610     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 611     timer.startOneShot(10, FROM_HERE);
 612
 613     EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());
 614 }
 615
 616 TEST_F(TimerTest, NextFireInterval_OneShotNonZero_AfterAFewSeconds)
 617 {
 618     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 619     timer.startOneShot(10, FROM_HERE);
 620
 621     advanceTimeBy(2.0);
 622     EXPECT_FLOAT_EQ(8.0, timer.nextFireInterval());
 623 }
 624
 625 TEST_F(TimerTest, NextFireInterval_Repeating)
 626 {
 627     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 628     timer.startRepeating(20, FROM_HERE);
 629
 630     EXPECT_FLOAT_EQ(20.0, timer.nextFireInterval());
 631 }
 632
 633 TEST_F(TimerTest, RepeatInterval_NeverStarted)
 634 {
 635     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 636
 637     EXPECT_FLOAT_EQ(0.0, timer.repeatInterval());
 638 }
 639
 640 TEST_F(TimerTest, RepeatInterval_OneShotZero)
 641 {
 642     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 643     timer.startOneShot(0, FROM_HERE);
 644
 645     EXPECT_FLOAT_EQ(0.0, timer.repeatInterval());
 646 }
 647
 648 TEST_F(TimerTest, RepeatInterval_OneShotNonZero)
 649 {
 650     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 651     timer.startOneShot(10, FROM_HERE);
 652
 653     EXPECT_FLOAT_EQ(0.0, timer.repeatInterval());
 654 }
 655
 656 TEST_F(TimerTest, RepeatInterval_Repeating)
 657 {
 658     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 659     timer.startRepeating(20, FROM_HERE);
 660
 661     EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());
 662 }
 663
 664 TEST_F(TimerTest, AugmentRepeatInterval)
 665 {
 666     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 667     timer.startRepeating(10, FROM_HERE);
 668     EXPECT_FLOAT_EQ(10.0, timer.repeatInterval());
 669     EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());
 670
 671     advanceTimeBy(2.0);
 672     timer.augmentRepeatInterval(10);
 673
 674     EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());
 675     EXPECT_FLOAT_EQ(18.0, timer.nextFireInterval());
 676
 677     runUntilIdleOrDeadlinePassed(m_startTime + 50.0);
 678     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 20.0, m_startTime + 40.0));
 679 }
 680
 681 class MockTimerWithAlignment : public TimerBase {
 682 public:
 683     MockTimerWithAlignment() : m_lastFireTime(0.0), m_alignedFireTime(0.0) { }
 684
 685     void fired() override
 686     {
 687     }
 688
 689     double alignedFireTime(double fireTime) const override
 690     {
 691         m_lastFireTime = fireTime;
 692         return m_alignedFireTime;
 693     }
 694
 695     void setAlignedFireTime(double alignedFireTime)
 696     {
 697         m_alignedFireTime = alignedFireTime;
 698     }
 699
 700     double lastFireTime() const
 701     {
 702         return m_lastFireTime;
 703     }
 704
 705 private:
 706     mutable double m_lastFireTime;
 707     double m_alignedFireTime;
 708 };
 709
 710 TEST_F(TimerTest, TimerAlignment_OneShotZero)
 711 {
 712     MockTimerWithAlignment timer;
 713     timer.setAlignedFireTime(m_startTime + 1.0);
 714
 715     timer.start(0.0, 0.0, FROM_HERE);
 716
 717     // The nextFireInterval gets overrriden.
 718     EXPECT_FLOAT_EQ(1.0, timer.nextFireInterval());
 719     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
 720     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 721 }
 722
 723 TEST_F(TimerTest, TimerAlignment_OneShotNonZero)
 724 {
 725     MockTimerWithAlignment timer;
 726     timer.setAlignedFireTime(m_startTime + 1.0);
 727
 728     timer.start(0.5, 0.0, FROM_HERE);
 729
 730     // The nextFireInterval gets overrriden.
 731     EXPECT_FLOAT_EQ(1.0, timer.nextFireInterval());
 732     EXPECT_FLOAT_EQ(0.5, timer.nextUnalignedFireInterval());
 733     EXPECT_FLOAT_EQ(m_startTime + 0.5, timer.lastFireTime());
 734 }
 735
 736 TEST_F(TimerTest, DidChangeAlignmentInterval)
 737 {
 738     MockTimerWithAlignment timer;
 739     timer.setAlignedFireTime(m_startTime + 1.0);
 740
 741     timer.start(0.0, 0.0, FROM_HERE);
 742
 743     EXPECT_FLOAT_EQ(1.0, timer.nextFireInterval());
 744     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
 745     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 746
 747     timer.setAlignedFireTime(m_startTime);
 748     timer.didChangeAlignmentInterval(monotonicallyIncreasingTime());
 749
 750     EXPECT_FLOAT_EQ(0.0, timer.nextFireInterval());
 751     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
 752     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 753 }
 754
 755
 756 } // namespace
 757 } // namespace blink