Index: base/time/time_win_unittest.cc |
diff --git a/base/time/time_win_unittest.cc b/base/time/time_win_unittest.cc |
index 058dfd79d147d6f6092bfc17680b1fc75a0583ff..4069208d75911f27caf7d8d858af246624410c86 100644 |
--- a/base/time/time_win_unittest.cc |
+++ b/base/time/time_win_unittest.cc |
@@ -114,7 +114,7 @@ TEST(TimeTicks, WinRollover) { |
TEST(TimeTicks, SubMillisecondTimers) { |
// 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; |
const int kRetries = 1000; |
@@ -183,7 +183,7 @@ TEST(TimeTicks, TimerPerformance) { |
TestCase cases[] = { |
{ reinterpret_cast<TestFunc>(Time::Now), "Time::Now" }, |
{ TimeTicks::Now, "TimeTicks::Now" }, |
- { TimeTicks::HighResNow, "TimeTicks::HighResNow" }, |
+ { TimeTicks::NowFromSystemTraceTime, "TimeTicks::NowFromSystemTraceTime" }, |
{ NULL, "" } |
}; |
@@ -207,65 +207,32 @@ TEST(TimeTicks, TimerPerformance) { |
} |
} |
-// http://crbug.com/396384 |
-TEST(TimeTicks, DISABLED_Drift) { |
- // If QPC is disabled, this isn't measuring anything. |
- if (!TimeTicks::IsHighResClockWorking()) |
+TEST(TimeTicks, FromQPCValue) { |
+ if (!TimeTicks::IsHighResolution()) |
return; |
const int kIterations = 100; |
- int64 total_drift = 0; |
- |
- for (int i = 0; i < kIterations; ++i) { |
- int64 drift_microseconds = TimeTicks::GetQPCDriftMicroseconds(); |
- // Make sure the drift never exceeds our limit. |
- EXPECT_LT(drift_microseconds, 50000); |
+ LARGE_INTEGER frequency; |
+ ASSERT_TRUE(QueryPerformanceFrequency(&frequency)); |
+ const int64 ticks_per_second = frequency.QuadPart; |
- // Sleep for a few milliseconds (note that it means 1000 microseconds). |
- // If we check the drift too frequently, it's going to increase |
- // monotonically, making our measurement less realistic. |
- base::PlatformThread::Sleep( |
- base::TimeDelta::FromMilliseconds((i % 2 == 0) ? 1 : 2)); |
+ TimeTicks start_time = TimeTicks::Now(); |
+ LARGE_INTEGER start_ticks; |
+ ASSERT_TRUE(QueryPerformanceCounter(&start_ticks)); |
+ LARGE_INTEGER ticks = start_ticks; |
+ int64 ticks_increment = 10; |
- total_drift += drift_microseconds; |
+ for (int i = 0; i < kIterations; ++i) { |
+ ticks.QuadPart += ticks_increment; |
+ ticks_increment = ticks_increment * 6 / 5; |
+ |
+ const int64 ticks_advanced = ticks.QuadPart - start_ticks.QuadPart; |
+ const TimeTicks expected_value = start_time + |
+ TimeDelta::FromMicroseconds( |
+ ticks_advanced * Time::kMicrosecondsPerSecond / ticks_per_second); |
+ const TimeTicks value = TimeTicks::FromQPCValue(ticks.QuadPart); |
+ EXPECT_GT(1.0, (value - expected_value).magnitude().InMillisecondsF()) |
+ << "iteration: " << i; |
} |
- |
- // 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); |
-} |
- |
-int64 QPCValueToMicrosecondsSafely(LONGLONG qpc_value, |
- int64 ticks_per_second) { |
- int64 whole_seconds = qpc_value / ticks_per_second; |
- int64 leftover_ticks = qpc_value % ticks_per_second; |
- int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) + |
- ((leftover_ticks * Time::kMicrosecondsPerSecond) / |
- ticks_per_second); |
- return microseconds; |
-} |
- |
-TEST(TimeTicks, FromQPCValue) { |
brianderson
2015/01/08 21:10:36
Please keep this test. It verifies the (qpc_value
miu
2015/01/08 22:16:01
It's still there (the TimeTicks.Drift test is what
|
- if (!TimeTicks::IsHighResClockWorking()) |
- return; |
- LARGE_INTEGER frequency; |
- QueryPerformanceFrequency(&frequency); |
- int64 ticks_per_second = frequency.QuadPart; |
- LONGLONG qpc_value = Time::kQPCOverflowThreshold; |
- TimeTicks expected_value = TimeTicks::FromInternalValue( |
- QPCValueToMicrosecondsSafely(qpc_value + 1, ticks_per_second)); |
- EXPECT_EQ(expected_value, |
- TimeTicks::FromQPCValue(qpc_value + 1)); |
- expected_value = TimeTicks::FromInternalValue( |
- QPCValueToMicrosecondsSafely(qpc_value, ticks_per_second)); |
- EXPECT_EQ(expected_value, |
- TimeTicks::FromQPCValue(qpc_value)); |
- expected_value = TimeTicks::FromInternalValue( |
- QPCValueToMicrosecondsSafely(qpc_value - 1, ticks_per_second)); |
- EXPECT_EQ(expected_value, |
- TimeTicks::FromQPCValue(qpc_value - 1)); |
} |