test of other windows timing functions

base/time_win_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <windows.h>
 #include <mmsystem.h>
 #include <process.h>
 
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
@@ skipping 145 matching lines @@
   // Test some basic assumptions that we expect about QPC.
 
   LARGE_INTEGER frequency;
   BOOL rv = QueryPerformanceFrequency(&frequency);
   EXPECT_EQ(TRUE, rv);
   EXPECT_GT(frequency.QuadPart, 1000000);  // Expect at least 1MHz
   printf("QueryPerformanceFrequency is %5.2fMHz\n",
     frequency.QuadPart / 1000000.0);
 }
 
+TimeTicks GetTickCountTest() {
+  return TimeTicks::FromInternalValue(GetTickCount64());
+}
+
+TimeTicks RDTSCTest() {
+  return TimeTicks::FromInternalValue(__rdtsc());
+}
+
+TimeTicks TimeGetTimeTest() {
+  return TimeTicks::FromInternalValue(timeGetTime());
+}
+
+TimeTicks QPCTest() {
+  LARGE_INTEGER out;
+  QueryPerformanceCounter(&out);
+  return TimeTicks::FromInternalValue(out.QuadPart);
+}
+
 TEST(TimeTicks, TimerPerformance) {
   // Verify that various timer mechanisms can always complete quickly.
   // Note:  This is a somewhat arbitrary test.
-  const int kLoops = 10000;
+  const int kLoops = 10000000;
   // Due to the fact that these run on bbots, which are horribly slow,
   // we can't really make any guarantees about minimum runtime.
   // Really, we want these to finish in ~10ms, and that is generous.
   const int kMaxTime = 35;  // Maximum acceptible milliseconds for test.
 
   typedef TimeTicks (*TestFunc)();
   struct TestCase {
     TestFunc func;
     char *description;
   };
   // Cheating a bit here:  assumes sizeof(TimeTicks) == sizeof(Time)
   // in order to create a single test case list.
   COMPILE_ASSERT(sizeof(TimeTicks) == sizeof(Time),
                  test_only_works_with_same_sizes);
   TestCase cases[] = {
     { reinterpret_cast<TestFunc>(Time::Now), "Time::Now" },
+    { GetTickCountTest, "GetTickCount64" },
+    { RDTSCTest, "__rdtsc" },
+    { TimeGetTimeTest, "timeGetTime" },
+    { QPCTest, "QueryPerformanceCounter" },
     { TimeTicks::Now, "TimeTicks::Now" },
     { TimeTicks::HighResNow, "TimeTicks::HighResNow" },
     { NULL, "" }
   };
 
   int test_case = 0;
   while (cases[test_case].func) {
     TimeTicks start = TimeTicks::HighResNow();
     for (int index = 0; index < kLoops; index++)
       cases[test_case].func();
@@ skipping 34 matching lines @@
     total_drift += drift_microseconds;
   }
 
   // Sanity check. We expect some time drift to occur, especially across
   // the number of iterations we do.
   EXPECT_LT(0, total_drift);
 
   printf("average time drift in microseconds: %lld\n",
          total_drift / kIterations);
 }