1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "content/common/inter_process_time_ticks_converter.h"
7 #include "base/time/time.h"
8 #include "testing/gtest/include/gtest/gtest.h"
10 using base::TimeTicks;
17 int64 local_lower_bound;
18 int64 remote_lower_bound;
19 int64 remote_upper_bound;
20 int64 local_upper_bound;
30 TestResults RunTest(const TestParams& params) {
31 TimeTicks local_lower_bound = TimeTicks::FromInternalValue(
32 params.local_lower_bound);
33 TimeTicks local_upper_bound = TimeTicks::FromInternalValue(
34 params.local_upper_bound);
35 TimeTicks remote_lower_bound = TimeTicks::FromInternalValue(
36 params.remote_lower_bound);
37 TimeTicks remote_upper_bound = TimeTicks::FromInternalValue(
38 params.remote_upper_bound);
39 TimeTicks test_time = TimeTicks::FromInternalValue(params.test_time);
41 InterProcessTimeTicksConverter converter(
42 LocalTimeTicks::FromTimeTicks(local_lower_bound),
43 LocalTimeTicks::FromTimeTicks(local_upper_bound),
44 RemoteTimeTicks::FromTimeTicks(remote_lower_bound),
45 RemoteTimeTicks::FromTimeTicks(remote_upper_bound));
48 results.result_time = converter.ToLocalTimeTicks(
49 RemoteTimeTicks::FromTimeTicks(
50 test_time)).ToTimeTicks().ToInternalValue();
51 results.result_delta = converter.ToLocalTimeDelta(
52 RemoteTimeDelta::FromRawDelta(params.test_delta)).ToInt32();
56 TEST(InterProcessTimeTicksConverterTest, NullTime) {
57 // Null / zero times should remain null.
59 p.local_lower_bound = 1;
60 p.remote_lower_bound = 2;
61 p.remote_upper_bound = 5;
62 p.local_upper_bound = 6;
65 TestResults results = RunTest(p);
66 EXPECT_EQ(0, results.result_time);
67 EXPECT_EQ(0, results.result_delta);
70 TEST(InterProcessTimeTicksConverterTest, NoSkew) {
71 // All times are monotonic and centered, so no adjustment should occur.
73 p.local_lower_bound = 1;
74 p.remote_lower_bound = 2;
75 p.remote_upper_bound = 5;
76 p.local_upper_bound = 6;
79 TestResults results = RunTest(p);
80 EXPECT_EQ(3, results.result_time);
81 EXPECT_EQ(1, results.result_delta);
84 TEST(InterProcessTimeTicksConverterTest, OffsetMidpoints) {
85 // All times are monotonic, but not centered. Adjust the |remote_*| times so
86 // they are centered within the |local_*| times.
88 p.local_lower_bound = 1;
89 p.remote_lower_bound = 3;
90 p.remote_upper_bound = 6;
91 p.local_upper_bound = 6;
94 TestResults results = RunTest(p);
95 EXPECT_EQ(3, results.result_time);
96 EXPECT_EQ(1, results.result_delta);
99 TEST(InterProcessTimeTicksConverterTest, DoubleEndedSkew) {
100 // |remote_lower_bound| occurs before |local_lower_bound| and
101 // |remote_upper_bound| occurs after |local_upper_bound|. We must adjust both
102 // bounds and scale down the delta. |test_time| is on the midpoint, so it
103 // doesn't change. The ratio of local time to network time is 1:2, so we scale
104 // |test_delta| to half.
106 p.local_lower_bound = 3;
107 p.remote_lower_bound = 1;
108 p.remote_upper_bound = 9;
109 p.local_upper_bound = 7;
112 TestResults results = RunTest(p);
113 EXPECT_EQ(5, results.result_time);
114 EXPECT_EQ(1, results.result_delta);
117 TEST(InterProcessTimeTicksConverterTest, FrontEndSkew) {
118 // |remote_upper_bound| is coherent, but |remote_lower_bound| is not. So we
119 // adjust the lower bound and move |test_time| out. The scale factor is 2:3,
120 // but since we use integers, the numbers truncate from 3.33 to 3 and 1.33
123 p.local_lower_bound = 3;
124 p.remote_lower_bound = 1;
125 p.remote_upper_bound = 7;
126 p.local_upper_bound = 7;
129 TestResults results = RunTest(p);
130 EXPECT_EQ(4, results.result_time);
131 EXPECT_EQ(1, results.result_delta);
134 TEST(InterProcessTimeTicksConverterTest, BackEndSkew) {
135 // Like the previous test, but |remote_lower_bound| is coherent and
136 // |remote_upper_bound| is skewed.
138 p.local_lower_bound = 1;
139 p.remote_lower_bound = 1;
140 p.remote_upper_bound = 7;
141 p.local_upper_bound = 5;
144 TestResults results = RunTest(p);
145 EXPECT_EQ(2, results.result_time);
146 EXPECT_EQ(1, results.result_delta);
149 TEST(InterProcessTimeTicksConverterTest, Instantaneous) {
150 // The bounds are all okay, but the |remote_lower_bound| and
151 // |remote_upper_bound| have the same value. No adjustments should be made and
152 // no divide-by-zero errors should occur.
154 p.local_lower_bound = 1;
155 p.remote_lower_bound = 2;
156 p.remote_upper_bound = 2;
157 p.local_upper_bound = 3;
160 TestResults results = RunTest(p);
161 EXPECT_EQ(2, results.result_time);
162 EXPECT_EQ(0, results.result_delta);
165 TEST(InterProcessTimeTicksConverterTest, OffsetInstantaneous) {
166 // The bounds are all okay, but the |remote_lower_bound| and
167 // |remote_upper_bound| have the same value and are offset from the midpoint
168 // of |local_lower_bound| and |local_upper_bound|. An offset should be applied
169 // to make the midpoints line up.
171 p.local_lower_bound = 1;
172 p.remote_lower_bound = 3;
173 p.remote_upper_bound = 3;
174 p.local_upper_bound = 3;
177 TestResults results = RunTest(p);
178 EXPECT_EQ(2, results.result_time);
179 EXPECT_EQ(0, results.result_delta);
182 TEST(InterProcessTimeTicksConverterTest, DisjointInstantaneous) {
183 // |local_lower_bound| and |local_upper_bound| are the same. No matter what
184 // the other values are, they must fit within [local_lower_bound,
185 // local_upper_bound]. So, all of the values should be adjusted so they are
186 // exactly that value.
188 p.local_lower_bound = 1;
189 p.remote_lower_bound = 2;
190 p.remote_upper_bound = 2;
191 p.local_upper_bound = 1;
194 TestResults results = RunTest(p);
195 EXPECT_EQ(1, results.result_time);
196 EXPECT_EQ(0, results.result_delta);
199 TEST(InterProcessTimeTicksConverterTest, RoundingNearEdges) {
200 // Verify that rounding never causes a value to appear outside the given
202 const int kMaxRange = 101;
203 for (int i = 1; i < kMaxRange; ++i) {
204 for (int j = 1; j < kMaxRange; ++j) {
206 p.local_lower_bound = 1;
207 p.remote_lower_bound = 1;
208 p.remote_upper_bound = j;
209 p.local_upper_bound = i;
213 TestResults results = RunTest(p);
214 EXPECT_LE(1, results.result_time);
215 EXPECT_EQ(0, results.result_delta);
218 p.test_delta = j - 1;
219 results = RunTest(p);
220 EXPECT_GE(i, results.result_time);
221 EXPECT_GE(i - 1, results.result_delta);
226 TEST(InterProcessTimeTicksConverterTest, DisjointRanges) {
228 p.local_lower_bound = 10;
229 p.remote_lower_bound = 30;
230 p.remote_upper_bound = 41;
231 p.local_upper_bound = 20;
234 TestResults results = RunTest(p);
235 EXPECT_EQ(20, results.result_time);
236 EXPECT_EQ(0, results.result_delta);
239 } // anonymous namespace
241 } // namespace content