Line data    Source code

       1             : // Copyright 2014 the V8 project 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 "src/libplatform/default-platform.h"
       6             : #include "src/base/platform/time.h"
       7             : #include "testing/gmock/include/gmock/gmock.h"
       8             : 
       9             : using testing::InSequence;
      10             : using testing::StrictMock;
      11             : 
      12             : namespace v8 {
      13             : namespace platform {
      14             : namespace default_platform_unittest {
      15             : 
      16             : namespace {
      17             : 
      18          21 : struct MockTask : public Task {
      19          14 :   virtual ~MockTask() { Die(); }
      20          18 :   MOCK_METHOD0(Run, void());
      21          21 :   MOCK_METHOD0(Die, void());
      22             : };
      23             : 
      24           6 : struct MockIdleTask : public IdleTask {
      25           4 :   virtual ~MockIdleTask() { Die(); }
      26           3 :   MOCK_METHOD1(Run, void(double deadline_in_seconds));
      27           6 :   MOCK_METHOD0(Die, void());
      28             : };
      29             : 
      30           5 : class DefaultPlatformWithMockTime : public DefaultPlatform {
      31             :  public:
      32             :   DefaultPlatformWithMockTime()
      33           5 :       : DefaultPlatform(IdleTaskSupport::kEnabled), time_(0) {}
      34          13 :   double MonotonicallyIncreasingTime() override { return time_; }
      35           0 :   double CurrentClockTimeMillis() override {
      36           0 :     return time_ * base::Time::kMillisecondsPerSecond;
      37             :   }
      38           4 :   void IncreaseTime(double seconds) { time_ += seconds; }
      39             : 
      40             :  private:
      41             :   double time_;
      42             : };
      43             : 
      44             : }  // namespace
      45             : 
      46             : 
      47       13158 : TEST(DefaultPlatformTest, PumpMessageLoop) {
      48           1 :   InSequence s;
      49             : 
      50             :   int dummy;
      51             :   Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
      52             : 
      53           2 :   DefaultPlatform platform;
      54           2 :   EXPECT_FALSE(platform.PumpMessageLoop(isolate));
      55             : 
      56           1 :   StrictMock<MockTask>* task = new StrictMock<MockTask>;
      57           1 :   platform.CallOnForegroundThread(isolate, task);
      58           1 :   EXPECT_CALL(*task, Run());
      59           1 :   EXPECT_CALL(*task, Die());
      60           2 :   EXPECT_TRUE(platform.PumpMessageLoop(isolate));
      61           3 :   EXPECT_FALSE(platform.PumpMessageLoop(isolate));
      62           1 : }
      63             : 
      64             : 
      65       13158 : TEST(DefaultPlatformTest, PumpMessageLoopDelayed) {
      66           1 :   InSequence s;
      67             : 
      68             :   int dummy;
      69             :   Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
      70             : 
      71             :   DefaultPlatformWithMockTime platform;
      72           2 :   EXPECT_FALSE(platform.PumpMessageLoop(isolate));
      73             : 
      74           1 :   StrictMock<MockTask>* task1 = new StrictMock<MockTask>;
      75           1 :   StrictMock<MockTask>* task2 = new StrictMock<MockTask>;
      76           1 :   platform.CallDelayedOnForegroundThread(isolate, task2, 100);
      77           1 :   platform.CallDelayedOnForegroundThread(isolate, task1, 10);
      78             : 
      79           2 :   EXPECT_FALSE(platform.PumpMessageLoop(isolate));
      80             : 
      81             :   platform.IncreaseTime(11);
      82           1 :   EXPECT_CALL(*task1, Run());
      83           1 :   EXPECT_CALL(*task1, Die());
      84           2 :   EXPECT_TRUE(platform.PumpMessageLoop(isolate));
      85             : 
      86           2 :   EXPECT_FALSE(platform.PumpMessageLoop(isolate));
      87             : 
      88             :   platform.IncreaseTime(90);
      89           1 :   EXPECT_CALL(*task2, Run());
      90           1 :   EXPECT_CALL(*task2, Die());
      91           3 :   EXPECT_TRUE(platform.PumpMessageLoop(isolate));
      92           1 : }
      93             : 
      94             : 
      95       13158 : TEST(DefaultPlatformTest, PumpMessageLoopNoStarvation) {
      96           1 :   InSequence s;
      97             : 
      98             :   int dummy;
      99             :   Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
     100             : 
     101             :   DefaultPlatformWithMockTime platform;
     102           2 :   EXPECT_FALSE(platform.PumpMessageLoop(isolate));
     103             : 
     104           1 :   StrictMock<MockTask>* task1 = new StrictMock<MockTask>;
     105           1 :   StrictMock<MockTask>* task2 = new StrictMock<MockTask>;
     106           1 :   StrictMock<MockTask>* task3 = new StrictMock<MockTask>;
     107           1 :   platform.CallOnForegroundThread(isolate, task1);
     108           1 :   platform.CallDelayedOnForegroundThread(isolate, task2, 10);
     109             :   platform.IncreaseTime(11);
     110             : 
     111           1 :   EXPECT_CALL(*task1, Run());
     112           1 :   EXPECT_CALL(*task1, Die());
     113           2 :   EXPECT_TRUE(platform.PumpMessageLoop(isolate));
     114             : 
     115           1 :   platform.CallOnForegroundThread(isolate, task3);
     116             : 
     117           1 :   EXPECT_CALL(*task2, Run());
     118           1 :   EXPECT_CALL(*task2, Die());
     119           2 :   EXPECT_TRUE(platform.PumpMessageLoop(isolate));
     120           1 :   EXPECT_CALL(*task3, Run());
     121           1 :   EXPECT_CALL(*task3, Die());
     122           3 :   EXPECT_TRUE(platform.PumpMessageLoop(isolate));
     123           1 : }
     124             : 
     125             : 
     126       13158 : TEST(DefaultPlatformTest, PendingDelayedTasksAreDestroyedOnShutdown) {
     127           1 :   InSequence s;
     128             : 
     129             :   int dummy;
     130             :   Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
     131             : 
     132             :   {
     133             :     DefaultPlatformWithMockTime platform;
     134           1 :     StrictMock<MockTask>* task = new StrictMock<MockTask>;
     135           1 :     platform.CallDelayedOnForegroundThread(isolate, task, 10);
     136           1 :     EXPECT_CALL(*task, Die());
     137           1 :   }
     138           1 : }
     139             : 
     140       13158 : TEST(DefaultPlatformTest, RunIdleTasks) {
     141           1 :   InSequence s;
     142             : 
     143             :   int dummy;
     144             :   Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
     145             : 
     146             :   DefaultPlatformWithMockTime platform;
     147             : 
     148           1 :   StrictMock<MockIdleTask>* task = new StrictMock<MockIdleTask>;
     149           1 :   platform.CallIdleOnForegroundThread(isolate, task);
     150           3 :   EXPECT_CALL(*task, Run(42.0 + 23.0));
     151           1 :   EXPECT_CALL(*task, Die());
     152             :   platform.IncreaseTime(23.0);
     153           2 :   platform.RunIdleTasks(isolate, 42.0);
     154           1 : }
     155             : 
     156       13158 : TEST(DefaultPlatformTest, PendingIdleTasksAreDestroyedOnShutdown) {
     157           1 :   InSequence s;
     158             : 
     159             :   int dummy;
     160             :   Isolate* isolate = reinterpret_cast<Isolate*>(&dummy);
     161             : 
     162             :   {
     163             :     DefaultPlatformWithMockTime platform;
     164           1 :     StrictMock<MockIdleTask>* task = new StrictMock<MockIdleTask>;
     165           1 :     platform.CallIdleOnForegroundThread(isolate, task);
     166           1 :     EXPECT_CALL(*task, Die());
     167           1 :   }
     168           1 : }
     169             : 
     170             : }  // namespace default_platform_unittest
     171             : }  // namespace platform
     172        7893 : }  // namespace v8