Adding the ability to use a simulated clock for unit tests.

webrtc/base/timeutils_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/common.h"
+#include "webrtc/base/event.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
+#include "webrtc/base/simulatedclock.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
 
 TEST(TimeTest, TimeInMs) {
   uint32_t ts_earlier = Time();
   Thread::SleepMs(100);
   uint32_t ts_now = Time();
   // Allow for the thread to wakeup ~20ms early.
@@ skipping 239 matching lines @@
       EXPECT_TRUE(rtc::TmToSeconds(tm) == t);
 #endif
     }
   }
 };
 
 TEST_F(TmToSeconds, TestTmToSeconds) {
   TestTmToSeconds(100000);
 }
 
+// Test that all the time functions exposed by TimeUtils get time from the
+// simulated clock when it's set.
+TEST(SimulatedClockTest, TimeFunctionsUseSimulatedClock) {
+  SimulatedClock clock;
+  SetClock(&clock);
+
+  clock.SetTimeNanos(987654321u);
+  EXPECT_EQ(987u, Time32());
+  EXPECT_EQ(987, Time64());
+  EXPECT_EQ(987u, Time());
+  EXPECT_EQ(987654u, TimeMicros());
+  EXPECT_EQ(987654321u, TimeNanos());
+  EXPECT_EQ(1000u, TimeAfter(13));
+
+  SetClock(nullptr);
+  // After it's unset, we should get a normal time.
+  EXPECT_NE(987u, Time());
+}
+
+TEST(SimulatedClockTest, InitialTime) {
+  SimulatedClock clock;
+  EXPECT_EQ(0u, clock.TimeNanos());
+}
+
+TEST(SimulatedClockTest, SetTimeNanos) {
+  SimulatedClock clock;
+  clock.SetTimeNanos(123u);
+  EXPECT_EQ(123u, clock.TimeNanos());
+  clock.SetTimeNanos(456u);
+  EXPECT_EQ(456u, clock.TimeNanos());
+}
+
+TEST(SimulatedClockTest, AdvanceTime) {
+  SimulatedClock clock;
+  clock.AdvanceTimeNanos(1111u);
+  EXPECT_EQ(1111u, clock.TimeNanos());
+  clock.AdvanceTimeMicros(2222u);
+  EXPECT_EQ(2223111u, clock.TimeNanos());
+  clock.AdvanceTimeMillis(3333u);
+  EXPECT_EQ(3335223111u, clock.TimeNanos());
+  clock.AdvanceTimeSeconds(4444u);
+  EXPECT_EQ(4447335223111u, clock.TimeNanos());
+}
+
+// When the clock is advanced, threads that are waiting in a socket select
+// should wake up and look at the new time. This allows tests using the
+// simulated clock to run much faster, if the test is bound by time constraints
+// (such as a test for a STUN ping timeout).
+TEST(SimulatedClockTest, SettingTimeWakesThreads) {
+  int64_t real_start_time_ms = Time64();
+
+  SimulatedClock clock;
+  SetClock(&clock);
+
+  Thread worker;
+  worker.Start();
+
+  // Post an event that won't be executed for 10 seconds.
+  Event message_handler_dispatched(false, false);
+  auto functor = [&message_handler_dispatched] {
+    message_handler_dispatched.Set();
+  };
+  worker.PostDelayed(
+      10000, new FunctorMessageHandler<void, decltype(functor)>(functor));
+
+  // Wait for a bit for the worker thread to be started and enter its socket
+  // select().
+  Thread::Current()->SleepMs(1000);
+
+  // Advance the simulated clock, expecting the worker thread to wake up
+  // and dispatch the message quickly.
+  clock.AdvanceTimeSeconds(10u);
+  message_handler_dispatched.Wait(Event::kForever);
+
+  SetClock(nullptr);
+
+  // The message should have been dispatched long before the 10 seconds fully
+  // elapsed.
+  int64_t real_end_time_ms = Time64();
+  EXPECT_LT(real_end_time_ms - real_start_time_ms, 2000);
+}
+
 }  // namespace rtc