1/*
2 * Copyright 2017-present Facebook, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16#include <folly/chrono/Conv.h>
17
18#include <folly/portability/GTest.h>
19
20using namespace folly;
21using namespace std::chrono;
22using namespace std::chrono_literals;
23
24namespace {
25/**
26 * A helper function to create a time_point even if the input duration type has
27 * finer resolution than the clock duration type.
28 */
29template <typename Clock, typename Duration>
30typename Clock::time_point createTimePoint(const Duration& d) {
31 return typename Clock::time_point(
32 std::chrono::duration_cast<typename Clock::duration>(d));
33}
34} // namespace
35
36TEST(Conv, timespecToStdChrono) {
37 struct timespec ts;
38
39 ts.tv_sec = 0;
40 ts.tv_nsec = 10;
41 EXPECT_EQ(10ns, to<nanoseconds>(ts));
42 EXPECT_EQ(0us, to<microseconds>(ts));
43 EXPECT_EQ(0ms, to<milliseconds>(ts));
44 EXPECT_EQ(0s, to<seconds>(ts));
45
46 ts.tv_sec = 1;
47 ts.tv_nsec = 10;
48 EXPECT_EQ(1000000010ns, to<nanoseconds>(ts));
49 EXPECT_EQ(1000000us, to<microseconds>(ts));
50 EXPECT_EQ(1000ms, to<milliseconds>(ts));
51 EXPECT_EQ(1s, to<seconds>(ts));
52 EXPECT_EQ(
53 createTimePoint<system_clock>(1000000010ns),
54 to<system_clock::time_point>(ts));
55 EXPECT_EQ(
56 createTimePoint<steady_clock>(1000000010ns),
57 to<steady_clock::time_point>(ts));
58
59 // Test a non-canonical value with tv_nsec larger than 1 second
60 ts.tv_sec = 5;
61 ts.tv_nsec = 3219876543;
62 // Beware about using std::chrono_literals suffixes with very literals:
63 // older versions of GCC are buggy and would truncate these to 32-bits.
64 EXPECT_EQ(8219876543LL, to<nanoseconds>(ts).count());
65 EXPECT_EQ(8219876us, to<microseconds>(ts));
66 EXPECT_EQ(8219ms, to<milliseconds>(ts));
67 EXPECT_EQ(8s, to<seconds>(ts));
68 EXPECT_EQ(
69 createTimePoint<system_clock>(nanoseconds(8219876543LL)),
70 to<system_clock::time_point>(ts));
71 EXPECT_EQ(
72 createTimePoint<steady_clock>(nanoseconds(8219876543LL)),
73 to<steady_clock::time_point>(ts));
74
75 // Test negative values
76 // When going to coarser grained types these should be rounded up towards 0.
77 ts.tv_sec = -5;
78 ts.tv_nsec = 123456;
79 EXPECT_EQ(-4999876544, to<nanoseconds>(ts).count());
80 EXPECT_EQ(-4999876544, duration_cast<nanoseconds>(-5s + 123456ns).count());
81 EXPECT_EQ(-4999876, to<microseconds>(ts).count());
82 EXPECT_EQ(-4999876, duration_cast<microseconds>(-5s + 123456ns).count());
83 EXPECT_EQ(-4999, to<milliseconds>(ts).count());
84 EXPECT_EQ(-4999, duration_cast<milliseconds>(-5s + 123456ns).count());
85 EXPECT_EQ(-4s, to<seconds>(ts));
86 EXPECT_EQ(-4, duration_cast<seconds>(-5s + 123456ns).count());
87 ts.tv_sec = -7200;
88 ts.tv_nsec = 123456;
89 EXPECT_EQ(-1h, to<hours>(ts));
90 EXPECT_EQ(
91 -1,
92 duration_cast<hours>(seconds{ts.tv_sec} + nanoseconds{ts.tv_nsec})
93 .count());
94 ts.tv_sec = -7000;
95 ts.tv_nsec = 123456;
96 EXPECT_EQ(-1h, to<hours>(ts));
97 EXPECT_EQ(
98 -1,
99 duration_cast<hours>(seconds{ts.tv_sec} + nanoseconds{ts.tv_nsec})
100 .count());
101 ts.tv_sec = -7201;
102 ts.tv_nsec = 123456;
103 EXPECT_EQ(-2h, to<hours>(ts));
104 EXPECT_EQ(
105 -2,
106 duration_cast<hours>(seconds{ts.tv_sec} + nanoseconds{ts.tv_nsec})
107 .count());
108
109 // Test converions to floating point durations
110 ts.tv_sec = 1;
111 ts.tv_nsec = 500000000;
112 EXPECT_EQ(1.5, to<duration<double>>(ts).count());
113 ts.tv_sec = -1;
114 ts.tv_nsec = 500000000;
115 EXPECT_EQ(-0.5, to<duration<double>>(ts).count());
116 ts.tv_sec = -1;
117 ts.tv_nsec = -500000000;
118 EXPECT_EQ(-1.5, to<duration<double>>(ts).count());
119 ts.tv_sec = 1;
120 ts.tv_nsec = 500000000;
121 auto doubleNanos = to<duration<double, std::nano>>(ts);
122 EXPECT_EQ(1500000000, doubleNanos.count());
123 ts.tv_sec = 90;
124 ts.tv_nsec = 0;
125 auto doubleMinutes = to<duration<double, std::ratio<60>>>(ts);
126 EXPECT_EQ(1.5, doubleMinutes.count());
127
128 // Test with unusual durations where neither the numerator nor denominator
129 // are 1.
130 using five_sevenths = std::chrono::duration<int64_t, std::ratio<5, 7>>;
131 ts.tv_sec = 1;
132 ts.tv_nsec = 0;
133 EXPECT_EQ(1, to<five_sevenths>(ts).count());
134 ts.tv_sec = 1;
135 ts.tv_nsec = 428571500;
136 EXPECT_EQ(2, to<five_sevenths>(ts).count());
137
138 using thirteen_thirds = std::chrono::duration<double, std::ratio<13, 3>>;
139 ts.tv_sec = 39;
140 ts.tv_nsec = 0;
141 EXPECT_NEAR(9.0, to<thirteen_thirds>(ts).count(), 0.000000001);
142 ts.tv_sec = 1;
143 ts.tv_nsec = 0;
144 EXPECT_NEAR(0.230769230, to<thirteen_thirds>(ts).count(), 0.000000001);
145}
146
147TEST(Conv, timespecToStdChronoOverflow) {
148 struct timespec ts;
149
150 // All of our boundary conditions below assume time_t is int64_t.
151 // This is true on most modern platforms.
152 if (!std::is_same<decltype(ts.tv_sec), int64_t>::value) {
153 LOG(INFO) << "skipping most overflow tests: time_t is not int64_t";
154 } else {
155 // Test the upper boundary of conversion to uint64_t nanoseconds
156 using nsec_u64 = std::chrono::duration<uint64_t, std::nano>;
157 ts.tv_sec = 18446744073;
158 ts.tv_nsec = 709551615;
159 EXPECT_EQ(std::numeric_limits<uint64_t>::max(), to<nsec_u64>(ts).count());
160
161 ts.tv_nsec += 1;
162 EXPECT_THROW(to<nsec_u64>(ts), std::range_error);
163
164 // Test the lower boundary of conversion to uint64_t nanoseconds
165 ts.tv_sec = 0;
166 ts.tv_nsec = 0;
167 EXPECT_EQ(0, to<nsec_u64>(ts).count());
168 ts.tv_sec = -1;
169 ts.tv_nsec = 0;
170 EXPECT_THROW(to<nsec_u64>(ts), std::range_error);
171
172 // Test the upper boundary of conversion to int64_t microseconds
173 using usec_i64 = std::chrono::duration<int64_t, std::micro>;
174 ts.tv_sec = 9223372036854LL;
175 ts.tv_nsec = 775807000;
176 EXPECT_EQ(std::numeric_limits<int64_t>::max(), to<usec_i64>(ts).count());
177
178 ts.tv_nsec += 1;
179 EXPECT_THROW(to<usec_i64>(ts), std::range_error);
180
181 // Test the lower boundary of conversion to int64_t microseconds
182 ts.tv_sec = -9223372036855LL;
183 ts.tv_nsec = 224192000;
184 EXPECT_EQ(std::numeric_limits<int64_t>::min(), to<usec_i64>(ts).count());
185
186 ts.tv_nsec -= 1;
187 EXPECT_THROW(to<usec_i64>(ts), std::range_error);
188
189 // Test the boundaries of conversion to int32_t seconds
190 using sec_i32 = std::chrono::duration<int32_t>;
191 ts.tv_sec = 2147483647;
192 ts.tv_nsec = 0;
193 EXPECT_EQ(std::numeric_limits<int32_t>::max(), to<sec_i32>(ts).count());
194 ts.tv_nsec = 1000000000;
195 EXPECT_THROW(to<sec_i32>(ts), std::range_error);
196 ts.tv_sec = -2147483648;
197 ts.tv_nsec = 0;
198 EXPECT_EQ(std::numeric_limits<int32_t>::min(), to<sec_i32>(ts).count());
199 ts.tv_sec = -2147483649;
200 ts.tv_nsec = 999999999;
201 EXPECT_THROW(to<sec_i32>(ts), std::range_error);
202 ts.tv_sec = -2147483649;
203 ts.tv_nsec = 0;
204 EXPECT_THROW(to<sec_i32>(ts), std::range_error);
205 ts.tv_sec = -2147483650;
206 ts.tv_nsec = 0;
207 EXPECT_THROW(to<sec_i32>(ts), std::range_error);
208
209 // Test the upper boundary of conversion to uint32_t hours
210 using hours_u32 = std::chrono::duration<uint32_t, std::ratio<3600>>;
211 ts.tv_sec = 15461882262000LL;
212 ts.tv_nsec = 0;
213 EXPECT_EQ(std::numeric_limits<uint32_t>::max(), to<hours_u32>(ts).count());
214 ts.tv_sec = 15461882265599LL;
215 EXPECT_EQ(std::numeric_limits<uint32_t>::max(), to<hours_u32>(ts).count());
216 ts.tv_sec = 15461882265600LL;
217 EXPECT_THROW(to<hours_u32>(ts), std::range_error);
218
219 using nsec_i64 = std::chrono::duration<int64_t, std::nano>;
220 ts.tv_sec = std::numeric_limits<int64_t>::max();
221 ts.tv_nsec = std::numeric_limits<int64_t>::max();
222 EXPECT_THROW(to<nsec_i64>(ts), std::range_error);
223
224 ts.tv_sec = std::numeric_limits<int64_t>::min();
225 ts.tv_nsec = std::numeric_limits<int64_t>::min();
226 EXPECT_THROW(to<nsec_i64>(ts), std::range_error);
227
228 // Test some non-normal inputs near the int64_t limit
229 ts.tv_sec = 0;
230 ts.tv_nsec = std::numeric_limits<int64_t>::min();
231 EXPECT_EQ(std::numeric_limits<int64_t>::min(), to<nsec_i64>(ts).count());
232 ts.tv_sec = -1;
233 ts.tv_nsec = std::numeric_limits<int64_t>::min() + std::nano::den;
234 EXPECT_EQ(std::numeric_limits<int64_t>::min(), to<nsec_i64>(ts).count());
235 ts.tv_sec = -1;
236 ts.tv_nsec = std::numeric_limits<int64_t>::min() + std::nano::den - 1;
237 EXPECT_THROW(to<nsec_i64>(ts), std::range_error);
238
239 ts.tv_sec = 0;
240 ts.tv_nsec = std::numeric_limits<int64_t>::max();
241 EXPECT_EQ(std::numeric_limits<int64_t>::max(), to<nsec_i64>(ts).count());
242 ts.tv_sec = 1;
243 ts.tv_nsec = std::numeric_limits<int64_t>::max() - std::nano::den;
244 EXPECT_EQ(std::numeric_limits<int64_t>::max(), to<nsec_i64>(ts).count());
245 ts.tv_sec = 1;
246 ts.tv_nsec = std::numeric_limits<int64_t>::max() - std::nano::den + 1;
247 EXPECT_THROW(to<nsec_i64>(ts), std::range_error);
248 }
249
250 // Theoretically conversion is representable in the output type,
251 // but we normalize the input first, and normalization would trigger an
252 // overflow.
253 using hours_u64 = std::chrono::duration<uint64_t, std::ratio<3600>>;
254 ts.tv_sec = std::numeric_limits<decltype(ts.tv_sec)>::max();
255 ts.tv_nsec = 1000000000;
256 EXPECT_THROW(to<hours_u64>(ts), std::range_error);
257 // If we drop it back down to the normal range it should succeed
258 ts.tv_nsec = 999999999;
259 EXPECT_EQ(
260 std::numeric_limits<decltype(ts.tv_sec)>::max() / 3600,
261 to<hours_u64>(ts).count());
262
263 // Test overflow with an unusual duration where neither the numerator nor
264 // denominator are 1.
265 using unusual_time = std::chrono::duration<int16_t, std::ratio<13, 3>>;
266 ts.tv_sec = 141994;
267 ts.tv_nsec = 666666666;
268 EXPECT_EQ(32767, to<unusual_time>(ts).count());
269 ts.tv_nsec = 666666667;
270 EXPECT_THROW(to<unusual_time>(ts), std::range_error);
271
272 ts.tv_sec = -141998;
273 ts.tv_nsec = 999999999;
274 EXPECT_EQ(-32768, to<unusual_time>(ts).count());
275 ts.tv_sec = -141999;
276 ts.tv_nsec = 0;
277 EXPECT_THROW(to<unusual_time>(ts), std::range_error);
278}
279
280TEST(Conv, timevalToStdChrono) {
281 struct timeval tv;
282
283 tv.tv_sec = 0;
284 tv.tv_usec = 10;
285 EXPECT_EQ(10000ns, to<nanoseconds>(tv));
286 EXPECT_EQ(10us, to<microseconds>(tv));
287 EXPECT_EQ(0ms, to<milliseconds>(tv));
288 EXPECT_EQ(0s, to<seconds>(tv));
289
290 tv.tv_sec = 1;
291 tv.tv_usec = 10;
292 EXPECT_EQ(1000010000ns, to<nanoseconds>(tv));
293 EXPECT_EQ(1000010us, to<microseconds>(tv));
294 EXPECT_EQ(1000ms, to<milliseconds>(tv));
295 EXPECT_EQ(1s, to<seconds>(tv));
296 EXPECT_EQ(
297 createTimePoint<system_clock>(1000010000ns),
298 to<system_clock::time_point>(tv));
299 EXPECT_EQ(
300 createTimePoint<steady_clock>(1000010000ns),
301 to<steady_clock::time_point>(tv));
302
303 // Test a non-canonical value with tv_usec larger than 1 second
304 tv.tv_sec = 5;
305 tv.tv_usec = 3219876;
306 EXPECT_EQ(8219876000LL, to<nanoseconds>(tv).count());
307 EXPECT_EQ(8219876us, to<microseconds>(tv));
308 EXPECT_EQ(8219ms, to<milliseconds>(tv));
309 EXPECT_EQ(8s, to<seconds>(tv));
310 EXPECT_EQ(
311 createTimePoint<system_clock>(nanoseconds(8219876000LL)),
312 to<system_clock::time_point>(tv));
313 EXPECT_EQ(
314 createTimePoint<steady_clock>(nanoseconds(8219876000LL)),
315 to<steady_clock::time_point>(tv));
316
317 // Test for overflow.
318 if (std::numeric_limits<decltype(tv.tv_sec)>::max() >=
319 std::numeric_limits<int64_t>::max()) {
320 // Use our own type alias here rather than std::chrono::nanoseconds
321 // to ensure we have 64-bit rep type.
322 using nsec_i64 = std::chrono::duration<int64_t, std::nano>;
323 tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::max();
324 tv.tv_usec = std::numeric_limits<decltype(tv.tv_usec)>::max();
325 EXPECT_THROW(to<nsec_i64>(tv), std::range_error);
326
327 tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::min();
328 tv.tv_usec = std::numeric_limits<decltype(tv.tv_usec)>::max();
329 EXPECT_THROW(to<nsec_i64>(tv), std::range_error);
330 }
331}
332
333TEST(Conv, stdChronoToTimespec) {
334 auto ts = to<struct timespec>(10ns);
335 EXPECT_EQ(0, ts.tv_sec);
336 EXPECT_EQ(10, ts.tv_nsec);
337
338 // We don't use std::chrono_literals suffixes here since older
339 // gcc versions silently truncate the literals to 32-bits.
340 ts = to<struct timespec>(nanoseconds(987654321012LL));
341 EXPECT_EQ(987, ts.tv_sec);
342 EXPECT_EQ(654321012, ts.tv_nsec);
343
344 ts = to<struct timespec>(nanoseconds(-987654321012LL));
345 EXPECT_EQ(-988, ts.tv_sec);
346 EXPECT_EQ(345678988, ts.tv_nsec);
347
348 ts = to<struct timespec>(microseconds(987654321012LL));
349 EXPECT_EQ(987654, ts.tv_sec);
350 EXPECT_EQ(321012000, ts.tv_nsec);
351
352 ts = to<struct timespec>(milliseconds(987654321012LL));
353 EXPECT_EQ(987654321, ts.tv_sec);
354 EXPECT_EQ(12000000, ts.tv_nsec);
355
356 ts = to<struct timespec>(seconds(987654321012LL));
357 EXPECT_EQ(987654321012, ts.tv_sec);
358 EXPECT_EQ(0, ts.tv_nsec);
359
360 ts = to<struct timespec>(10h);
361 EXPECT_EQ(36000, ts.tv_sec);
362 EXPECT_EQ(0, ts.tv_nsec);
363
364 ts = to<struct timespec>(createTimePoint<steady_clock>(123ns));
365 EXPECT_EQ(0, ts.tv_sec);
366 EXPECT_EQ(123, ts.tv_nsec);
367
368 ts = to<struct timespec>(createTimePoint<system_clock>(123ns));
369 EXPECT_EQ(0, ts.tv_sec);
370 EXPECT_EQ(123, ts.tv_nsec);
371
372 // Test with some unusual durations where neither the numerator nor
373 // denominator are 1.
374 using five_sevenths = std::chrono::duration<int64_t, std::ratio<5, 7>>;
375 ts = to<struct timespec>(five_sevenths(7));
376 EXPECT_EQ(5, ts.tv_sec);
377 EXPECT_EQ(0, ts.tv_nsec);
378 ts = to<struct timespec>(five_sevenths(19));
379 EXPECT_EQ(13, ts.tv_sec);
380 EXPECT_EQ(571428571, ts.tv_nsec);
381 using seven_fifths = std::chrono::duration<int64_t, std::ratio<7, 5>>;
382 ts = to<struct timespec>(seven_fifths(5));
383 EXPECT_EQ(7, ts.tv_sec);
384 EXPECT_EQ(0, ts.tv_nsec);
385}
386
387TEST(Conv, stdChronoToTimespecOverflow) {
388 EXPECT_THROW(to<uint8_t>(1234), std::range_error);
389
390 struct timespec ts;
391 if (!std::is_same<decltype(ts.tv_sec), int64_t>::value) {
392 LOG(INFO) << "skipping most overflow tests: time_t is not int64_t";
393 } else {
394 // Check for overflow converting from uint64_t seconds to time_t
395 using sec_u64 = duration<uint64_t>;
396 ts = to<struct timespec>(sec_u64(9223372036854775807ULL));
397 EXPECT_EQ(ts.tv_sec, 9223372036854775807ULL);
398 EXPECT_EQ(ts.tv_nsec, 0);
399
400 EXPECT_THROW(
401 to<struct timespec>(sec_u64(9223372036854775808ULL)), std::range_error);
402
403 // Check for overflow converting from int64_t hours to time_t
404 using hours_i64 = duration<int64_t, std::ratio<3600>>;
405 ts = to<struct timespec>(hours_i64(2562047788015215LL));
406 EXPECT_EQ(ts.tv_sec, 9223372036854774000LL);
407 EXPECT_EQ(ts.tv_nsec, 0);
408 EXPECT_THROW(
409 to<struct timespec>(hours_i64(2562047788015216LL)), std::range_error);
410
411 // Test overflows from an unusual duration where neither the numerator nor
412 // denominator are 1.
413 using three_halves = std::chrono::duration<uint64_t, std::ratio<3, 2>>;
414 EXPECT_THROW(
415 to<struct timespec>(three_halves(6148914691236517206ULL)),
416 std::range_error);
417 }
418
419 // Test for overflow.
420 // Use a custom hours type using time_t as the underlying storage type to
421 // guarantee that we can overflow.
422 using hours_timet = std::chrono::duration<time_t, std::ratio<3600>>;
423 EXPECT_THROW(
424 to<struct timespec>(hours_timet(std::numeric_limits<time_t>::max())),
425 std::range_error);
426}
427
428TEST(Conv, stdChronoToTimeval) {
429 auto tv = to<struct timeval>(10ns);
430 EXPECT_EQ(0, tv.tv_sec);
431 EXPECT_EQ(0, tv.tv_usec);
432
433 tv = to<struct timeval>(10us);
434 EXPECT_EQ(0, tv.tv_sec);
435 EXPECT_EQ(10, tv.tv_usec);
436
437 tv = to<struct timeval>(nanoseconds(987654321012LL));
438 EXPECT_EQ(987, tv.tv_sec);
439 EXPECT_EQ(654321, tv.tv_usec);
440
441 tv = to<struct timeval>(nanoseconds(-987654321012LL));
442 EXPECT_EQ(-988, tv.tv_sec);
443 EXPECT_EQ(345679, tv.tv_usec);
444
445 tv = to<struct timeval>(microseconds(987654321012LL));
446 EXPECT_EQ(987654, tv.tv_sec);
447 EXPECT_EQ(321012, tv.tv_usec);
448
449 tv = to<struct timeval>(milliseconds(987654321012LL));
450 EXPECT_EQ(987654321, tv.tv_sec);
451 EXPECT_EQ(12000, tv.tv_usec);
452
453 tv = to<struct timeval>(seconds(987654321012LL));
454 EXPECT_EQ(987654321012, tv.tv_sec);
455 EXPECT_EQ(0, tv.tv_usec);
456
457 // Try converting fractional seconds
458 tv = to<struct timeval>(duration<double>{3.456789});
459 EXPECT_EQ(3, tv.tv_sec);
460 EXPECT_EQ(456789, tv.tv_usec);
461 tv = to<struct timeval>(duration<double>{-3.456789});
462 EXPECT_EQ(-4, tv.tv_sec);
463 EXPECT_EQ(543211, tv.tv_usec);
464
465 // Try converting fractional hours
466 tv = to<struct timeval>(duration<double, std::ratio<3600>>{3.456789});
467 EXPECT_EQ(12444, tv.tv_sec);
468 // The usec field is generally off-by-one due to
469 // floating point rounding error
470 EXPECT_NEAR(440400, tv.tv_usec, 1);
471 tv = to<struct timeval>(duration<double, std::ratio<3600>>{-3.456789});
472 EXPECT_EQ(-12445, tv.tv_sec);
473 EXPECT_NEAR(559600, tv.tv_usec, 1);
474
475 // Try converting fractional milliseconds
476 tv = to<struct timeval>(duration<double, std::milli>{9123.456789});
477 EXPECT_EQ(9, tv.tv_sec);
478 EXPECT_EQ(123456, tv.tv_usec);
479 tv = to<struct timeval>(duration<double, std::milli>{-9123.456789});
480 EXPECT_EQ(-10, tv.tv_sec);
481 EXPECT_NEAR(876544, tv.tv_usec, 1);
482
483 tv = to<struct timeval>(duration<uint32_t, std::ratio<3600>>{3});
484 EXPECT_EQ(10800, tv.tv_sec);
485 EXPECT_EQ(0, tv.tv_usec);
486
487 tv = to<struct timeval>(duration<uint32_t, std::nano>{3123});
488 EXPECT_EQ(0, tv.tv_sec);
489 EXPECT_EQ(3, tv.tv_usec);
490 tv = to<struct timeval>(duration<int32_t, std::nano>{-3123});
491 EXPECT_EQ(-1, tv.tv_sec);
492 EXPECT_EQ(999997, tv.tv_usec);
493
494 tv = to<struct timeval>(createTimePoint<steady_clock>(123us));
495 EXPECT_EQ(0, tv.tv_sec);
496 EXPECT_EQ(123, tv.tv_usec);
497
498 tv = to<struct timeval>(createTimePoint<system_clock>(123us));
499 EXPECT_EQ(0, tv.tv_sec);
500 EXPECT_EQ(123, tv.tv_usec);
501}
502