[Windows] One TimeTicks clock: efficient/reliable high-res, with low-res fallback.

base/time/time_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 "base/time/time.h"
 
 #include <time.h>
 
+#include <limits>
 #include <string>
+#include <type_traits>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
@@ skipping 615 matching lines @@
     // Unfortunately, our InMilliseconds() function truncates
     // rather than rounds.  We should consider fixing this
     // so that our averages come out better.
     EXPECT_GE(delta.InMilliseconds(), 9);
     EXPECT_GE(delta.InMicroseconds(), 9000);
     EXPECT_EQ(delta.InSeconds(), 0);
   }
 }
 
 static void HighResClockTest(TimeTicks (*GetTicks)()) {
-#if defined(OS_WIN)
   // HighResNow doesn't work on some systems.  Since the product still works
   // even if it doesn't work, it makes this entire test questionable.
-  if (!TimeTicks::IsHighResClockWorking())
+  if (!TimeTicks::IsHighResolution())
     return;
-#endif
 
   // Why do we loop here?
   // We're trying to measure that intervals increment in a VERY small amount
   // of time --  less than 15ms.  Unfortunately, if we happen to have a
   // context switch in the middle of our test, the context switch could easily
   // exceed our limit.  So, we iterate on this several times.  As long as we're
   // able to detect the fine-granularity timers at least once, then the test
   // has succeeded.
 
   const int kTargetGranularityUs = 15000;  // 15ms
@@ skipping 124 matching lines @@
 
 // We could define this separately for Time, TimeTicks and TimeDelta but the
 // definitions would be identical anyway.
 template <class Any>
 std::string AnyToString(Any any) {
   std::ostringstream oss;
   oss << any;
   return oss.str();
 }
 
+// Paranoia test: Since std::abs(int64) is new to C++11, make sure incomplete
+// toolchains don't silently pull in an alternate overload when the needed
+// function is missing.
+TEST(TimeDelta, ParanoidAboutAbsFunction) {

[brianderson, 2015/01/07 00:53:44]

Do you plan to remove this test before landing?

[miu, 2015/01/07 05:22:45]

The trybots on PS1 forced me to change tactics.  So, this test was somewhat
rewritten to confirm my inlined abs() implementation.

+  int64 max_int64_minus_one = std::numeric_limits<int64>::max() - 1;
+  int64 min_int64_plus_two = std::numeric_limits<int64>::min() + 2;
+  static_assert(std::is_same<decltype(max_int64_minus_one),
+                             decltype(std::abs(max_int64_minus_one))>::value,
+                "compiler is choosing incorrect std::abs() overload");
+  EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one),
+            TimeDelta::FromMicroseconds(max_int64_minus_one).magnitude());
+  EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one),
+            TimeDelta::FromMicroseconds(min_int64_plus_two).magnitude());
+}
+
 TEST(TimeDeltaLogging, DCheckEqCompiles) {
   DCHECK_EQ(TimeDelta(), TimeDelta());
 }
 
 TEST(TimeDeltaLogging, EmptyIsZero) {
   TimeDelta zero;
   EXPECT_EQ("0s", AnyToString(zero));
 }
 
 TEST(TimeDeltaLogging, FiveHundredMs) {
@@ skipping 67 matching lines @@
 
 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
   std::ostringstream oss;
   oss << TimeTicks();
   EXPECT_TRUE(oss.good());
 }
 
 }  // namespace
 
 }  // namespace base