From cd97b2b943c643f8432d0924a5d3dc1da2868914 Mon Sep 17 00:00:00 2001
From: skvlad <skvlad@webrtc.org>
Date: Tue, 4 Oct 2016 12:32:53 -0700
Subject: [PATCH] Switched flaky ProfilerTest to use fake clock

The test was heavily dependent on wall clock timing, so it ended up
being disabled in some build configurations. This CL switches it to use
a fake clock instead.

BUG=webrtc:5947

Review-Url: https://codereview.webrtc.org/2392613003
Cr-Commit-Position: refs/heads/master@{#14507}
---
 webrtc/base/profiler_unittest.cc | 42 +++++++++++++++-----------------
 1 file changed, 19 insertions(+), 23 deletions(-)

diff --git a/webrtc/base/profiler_unittest.cc b/webrtc/base/profiler_unittest.cc
index 2448fce2de..6fd4b5925e 100644
--- a/webrtc/base/profiler_unittest.cc
+++ b/webrtc/base/profiler_unittest.cc
@@ -8,19 +8,20 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/profiler.h"
+#include "webrtc/base/timedelta.h"
 #include "webrtc/base/thread.h"
 
 namespace {
 
 const int kWaitMs = 250;
 const double kWaitSec = 0.250;
-const double kTolerance = 0.1;
 
-const char* TestFunc() {
+const char* TestFunc(rtc::FakeClock* clock) {
   PROFILE_F();
-  rtc::Thread::SleepMs(kWaitMs);
+  clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
   return __FUNCTION__;
 }
 
@@ -28,33 +29,29 @@ const char* TestFunc() {
 
 namespace rtc {
 
-// Disable this test due to flakiness; see bug 5947.
-#if defined(WEBRTC_LINUX)
-#define MAYBE_TestFunction DISABLED_TestFunction
-#else
-#define MAYBE_TestFunction TestFunction
-#endif
-TEST(ProfilerTest, MAYBE_TestFunction) {
+TEST(ProfilerTest, TestFunction) {
+  rtc::ScopedFakeClock fake_clock;
   ASSERT_TRUE(Profiler::Instance()->Clear());
 
   // Profile a long-running function.
-  const char* function_name = TestFunc();
+  const char* function_name = TestFunc(&fake_clock);
   const ProfilerEvent* event = Profiler::Instance()->GetEvent(function_name);
   ASSERT_TRUE(event != NULL);
   EXPECT_FALSE(event->is_started());
   EXPECT_EQ(1, event->event_count());
-  EXPECT_NEAR(kWaitSec, event->mean(), kTolerance * 3);
+  EXPECT_EQ(kWaitSec, event->mean());
 
   // Run it a second time.
-  TestFunc();
+  TestFunc(&fake_clock);
   EXPECT_FALSE(event->is_started());
   EXPECT_EQ(2, event->event_count());
-  EXPECT_NEAR(kWaitSec, event->mean(), kTolerance);
-  EXPECT_NEAR(kWaitSec * 2, event->total_time(), kTolerance * 2);
+  EXPECT_EQ(kWaitSec, event->mean());
+  EXPECT_EQ(kWaitSec * 2, event->total_time());
   EXPECT_DOUBLE_EQ(event->mean(), event->total_time() / event->event_count());
 }
 
 TEST(ProfilerTest, TestScopedEvents) {
+  rtc::ScopedFakeClock fake_clock;
   const std::string kEvent1Name = "Event 1";
   const std::string kEvent2Name = "Event 2";
   const int kEvent2WaitMs = 150;
@@ -68,40 +65,39 @@ TEST(ProfilerTest, TestScopedEvents) {
     ASSERT_TRUE(event1 != NULL);
     EXPECT_TRUE(event1->is_started());
     EXPECT_EQ(0, event1->event_count());
-    rtc::Thread::SleepMs(kWaitMs);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
     EXPECT_TRUE(event1->is_started());
   }
   // Check the result.
   EXPECT_FALSE(event1->is_started());
   EXPECT_EQ(1, event1->event_count());
-  EXPECT_NEAR(kWaitSec, event1->mean(), kTolerance);
+  EXPECT_EQ(kWaitSec, event1->mean());
   {  // Profile a second event.
     PROFILE(kEvent2Name);
     event2 = Profiler::Instance()->GetEvent(kEvent2Name);
     ASSERT_TRUE(event2 != NULL);
     EXPECT_FALSE(event1->is_started());
     EXPECT_TRUE(event2->is_started());
-    rtc::Thread::SleepMs(kEvent2WaitMs);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kEvent2WaitMs));
   }
   // Check the result.
   EXPECT_FALSE(event2->is_started());
   EXPECT_EQ(1, event2->event_count());
 
-  // The difference here can be as much as 0.33, so we need high tolerance.
-  EXPECT_NEAR(kEvent2WaitSec, event2->mean(), kTolerance * 4);
+  EXPECT_EQ(kEvent2WaitSec, event2->mean());
   // Make sure event1 is unchanged.
   EXPECT_FALSE(event1->is_started());
   EXPECT_EQ(1, event1->event_count());
   {  // Run another event 1.
     PROFILE(kEvent1Name);
     EXPECT_TRUE(event1->is_started());
-    rtc::Thread::SleepMs(kWaitMs);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
   }
   // Check the result.
   EXPECT_FALSE(event1->is_started());
   EXPECT_EQ(2, event1->event_count());
-  EXPECT_NEAR(kWaitSec, event1->mean(), kTolerance);
-  EXPECT_NEAR(kWaitSec * 2, event1->total_time(), kTolerance * 2);
+  EXPECT_EQ(kWaitSec, event1->mean());
+  EXPECT_EQ(kWaitSec * 2, event1->total_time());
   EXPECT_DOUBLE_EQ(event1->mean(),
                    event1->total_time() / event1->event_count());
 }