1 // Copyright 2010 The Kyua Authors.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of Google Inc. nor the names of its contributors
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #include "utils/datetime.hpp"
39 #include <atf-c++.hpp>
41 namespace datetime = utils::datetime;
44 ATF_TEST_CASE_WITHOUT_HEAD(delta__defaults);
45 ATF_TEST_CASE_BODY(delta__defaults)
47 const datetime::delta delta;
48 ATF_REQUIRE_EQ(0, delta.seconds);
49 ATF_REQUIRE_EQ(0, delta.useconds);
53 ATF_TEST_CASE_WITHOUT_HEAD(delta__overrides);
54 ATF_TEST_CASE_BODY(delta__overrides)
56 const datetime::delta delta(1, 2);
57 ATF_REQUIRE_EQ(1, delta.seconds);
58 ATF_REQUIRE_EQ(2, delta.useconds);
61 std::runtime_error, "Negative.*not supported.*-4999997us",
62 datetime::delta(-5, 3));
66 ATF_TEST_CASE_WITHOUT_HEAD(delta__from_microseconds);
67 ATF_TEST_CASE_BODY(delta__from_microseconds)
70 const datetime::delta delta = datetime::delta::from_microseconds(0);
71 ATF_REQUIRE_EQ(0, delta.seconds);
72 ATF_REQUIRE_EQ(0, delta.useconds);
75 const datetime::delta delta = datetime::delta::from_microseconds(
77 ATF_REQUIRE_EQ(0, delta.seconds);
78 ATF_REQUIRE_EQ(999999, delta.useconds);
81 const datetime::delta delta = datetime::delta::from_microseconds(
83 ATF_REQUIRE_EQ(1, delta.seconds);
84 ATF_REQUIRE_EQ(0, delta.useconds);
87 const datetime::delta delta = datetime::delta::from_microseconds(
89 ATF_REQUIRE_EQ(10, delta.seconds);
90 ATF_REQUIRE_EQ(576293, delta.useconds);
93 const datetime::delta delta = datetime::delta::from_microseconds(
95 ATF_REQUIRE_EQ(123456789, delta.seconds);
96 ATF_REQUIRE_EQ(123456, delta.useconds);
100 std::runtime_error, "Negative.*not supported.*-12345us",
101 datetime::delta::from_microseconds(-12345));
105 ATF_TEST_CASE_WITHOUT_HEAD(delta__to_microseconds);
106 ATF_TEST_CASE_BODY(delta__to_microseconds)
108 ATF_REQUIRE_EQ(0, datetime::delta(0, 0).to_microseconds());
109 ATF_REQUIRE_EQ(999999, datetime::delta(0, 999999).to_microseconds());
110 ATF_REQUIRE_EQ(1000000, datetime::delta(1, 0).to_microseconds());
111 ATF_REQUIRE_EQ(10576293, datetime::delta(10, 576293).to_microseconds());
112 ATF_REQUIRE_EQ(11576293, datetime::delta(10, 1576293).to_microseconds());
116 ATF_TEST_CASE_WITHOUT_HEAD(delta__equals);
117 ATF_TEST_CASE_BODY(delta__equals)
119 ATF_REQUIRE(datetime::delta() == datetime::delta());
120 ATF_REQUIRE(datetime::delta() == datetime::delta(0, 0));
121 ATF_REQUIRE(datetime::delta(1, 2) == datetime::delta(1, 2));
123 ATF_REQUIRE(!(datetime::delta() == datetime::delta(0, 1)));
124 ATF_REQUIRE(!(datetime::delta() == datetime::delta(1, 0)));
125 ATF_REQUIRE(!(datetime::delta(1, 2) == datetime::delta(2, 1)));
129 ATF_TEST_CASE_WITHOUT_HEAD(delta__differs);
130 ATF_TEST_CASE_BODY(delta__differs)
132 ATF_REQUIRE(!(datetime::delta() != datetime::delta()));
133 ATF_REQUIRE(!(datetime::delta() != datetime::delta(0, 0)));
134 ATF_REQUIRE(!(datetime::delta(1, 2) != datetime::delta(1, 2)));
136 ATF_REQUIRE(datetime::delta() != datetime::delta(0, 1));
137 ATF_REQUIRE(datetime::delta() != datetime::delta(1, 0));
138 ATF_REQUIRE(datetime::delta(1, 2) != datetime::delta(2, 1));
142 ATF_TEST_CASE_WITHOUT_HEAD(delta__sorting);
143 ATF_TEST_CASE_BODY(delta__sorting)
145 ATF_REQUIRE(!(datetime::delta() < datetime::delta()));
146 ATF_REQUIRE( datetime::delta() <= datetime::delta());
147 ATF_REQUIRE(!(datetime::delta() > datetime::delta()));
148 ATF_REQUIRE( datetime::delta() >= datetime::delta());
150 ATF_REQUIRE(!(datetime::delta(9, 8) < datetime::delta(9, 8)));
151 ATF_REQUIRE( datetime::delta(9, 8) <= datetime::delta(9, 8));
152 ATF_REQUIRE(!(datetime::delta(9, 8) > datetime::delta(9, 8)));
153 ATF_REQUIRE( datetime::delta(9, 8) >= datetime::delta(9, 8));
155 ATF_REQUIRE( datetime::delta(2, 5) < datetime::delta(4, 8));
156 ATF_REQUIRE( datetime::delta(2, 5) <= datetime::delta(4, 8));
157 ATF_REQUIRE(!(datetime::delta(2, 5) > datetime::delta(4, 8)));
158 ATF_REQUIRE(!(datetime::delta(2, 5) >= datetime::delta(4, 8)));
160 ATF_REQUIRE( datetime::delta(2, 5) < datetime::delta(2, 8));
161 ATF_REQUIRE( datetime::delta(2, 5) <= datetime::delta(2, 8));
162 ATF_REQUIRE(!(datetime::delta(2, 5) > datetime::delta(2, 8)));
163 ATF_REQUIRE(!(datetime::delta(2, 5) >= datetime::delta(2, 8)));
165 ATF_REQUIRE(!(datetime::delta(4, 8) < datetime::delta(2, 5)));
166 ATF_REQUIRE(!(datetime::delta(4, 8) <= datetime::delta(2, 5)));
167 ATF_REQUIRE( datetime::delta(4, 8) > datetime::delta(2, 5));
168 ATF_REQUIRE( datetime::delta(4, 8) >= datetime::delta(2, 5));
170 ATF_REQUIRE(!(datetime::delta(2, 8) < datetime::delta(2, 5)));
171 ATF_REQUIRE(!(datetime::delta(2, 8) <= datetime::delta(2, 5)));
172 ATF_REQUIRE( datetime::delta(2, 8) > datetime::delta(2, 5));
173 ATF_REQUIRE( datetime::delta(2, 8) >= datetime::delta(2, 5));
177 ATF_TEST_CASE_WITHOUT_HEAD(delta__addition);
178 ATF_TEST_CASE_BODY(delta__addition)
180 using datetime::delta;
182 ATF_REQUIRE_EQ(delta(), delta() + delta());
183 ATF_REQUIRE_EQ(delta(0, 10), delta() + delta(0, 10));
184 ATF_REQUIRE_EQ(delta(10, 0), delta(10, 0) + delta());
186 ATF_REQUIRE_EQ(delta(1, 234567), delta(0, 1234567) + delta());
187 ATF_REQUIRE_EQ(delta(12, 34), delta(10, 20) + delta(2, 14));
191 ATF_TEST_CASE_WITHOUT_HEAD(delta__addition_and_set);
192 ATF_TEST_CASE_BODY(delta__addition_and_set)
194 using datetime::delta;
199 ATF_REQUIRE_EQ(delta(3, 5), d);
204 ATF_REQUIRE_EQ(delta(4, 7), d);
208 ATF_REQUIRE_EQ(delta(4, 7), (d += delta(3, 5)));
213 ATF_TEST_CASE_WITHOUT_HEAD(delta__scale);
214 ATF_TEST_CASE_BODY(delta__scale)
216 using datetime::delta;
218 ATF_REQUIRE_EQ(delta(), delta() * 0);
219 ATF_REQUIRE_EQ(delta(), delta() * 5);
221 ATF_REQUIRE_EQ(delta(0, 30), delta(0, 10) * 3);
222 ATF_REQUIRE_EQ(delta(17, 500000), delta(3, 500000) * 5);
226 ATF_TEST_CASE_WITHOUT_HEAD(delta__scale_and_set);
227 ATF_TEST_CASE_BODY(delta__scale_and_set)
229 using datetime::delta;
234 ATF_REQUIRE_EQ(delta(6, 10), d);
239 ATF_REQUIRE_EQ(delta(64, 0), d);
243 ATF_REQUIRE_EQ(delta(9, 15), (d *= 3));
248 ATF_TEST_CASE_WITHOUT_HEAD(delta__output);
249 ATF_TEST_CASE_BODY(delta__output)
252 std::ostringstream str;
253 str << datetime::delta(15, 8791);
254 ATF_REQUIRE_EQ("15008791us", str.str());
257 std::ostringstream str;
258 str << datetime::delta(12345678, 0);
259 ATF_REQUIRE_EQ("12345678000000us", str.str());
264 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__copy);
265 ATF_TEST_CASE_BODY(timestamp__copy)
267 const datetime::timestamp ts1 = datetime::timestamp::from_values(
268 2011, 2, 16, 19, 15, 30, 0);
270 const datetime::timestamp ts2 = ts1;
271 const datetime::timestamp ts3 = datetime::timestamp::from_values(
272 2012, 2, 16, 19, 15, 30, 0);
273 ATF_REQUIRE_EQ("2011", ts1.strftime("%Y"));
274 ATF_REQUIRE_EQ("2011", ts2.strftime("%Y"));
275 ATF_REQUIRE_EQ("2012", ts3.strftime("%Y"));
277 ATF_REQUIRE_EQ("2011", ts1.strftime("%Y"));
281 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__from_microseconds);
282 ATF_TEST_CASE_BODY(timestamp__from_microseconds)
284 const datetime::timestamp ts = datetime::timestamp::from_microseconds(
286 ATF_REQUIRE_EQ("2012-02-09 23:15:51", ts.strftime("%Y-%m-%d %H:%M:%S"));
287 ATF_REQUIRE_EQ(1328829351987654LL, ts.to_microseconds());
288 ATF_REQUIRE_EQ(1328829351, ts.to_seconds());
292 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__mock);
293 ATF_TEST_CASE_BODY(timestamp__now__mock)
295 datetime::set_mock_now(2011, 2, 21, 18, 5, 10, 0);
296 ATF_REQUIRE_EQ("2011-02-21 18:05:10",
297 datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S"));
299 datetime::set_mock_now(datetime::timestamp::from_values(
300 2012, 3, 22, 19, 6, 11, 54321));
301 ATF_REQUIRE_EQ("2012-03-22 19:06:11",
302 datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S"));
303 ATF_REQUIRE_EQ("2012-03-22 19:06:11",
304 datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S"));
308 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__real);
309 ATF_TEST_CASE_BODY(timestamp__now__real)
311 // This test is might fail if we happen to run at the crossing of one
312 // day to the other and the two measures we pick of the current time
313 // differ. This is so unlikely that I haven't bothered to do this in any
316 const time_t just_before = ::time(NULL);
317 const datetime::timestamp now = datetime::timestamp::now();
321 ATF_REQUIRE(::gmtime_r(&just_before, &data) != 0);
322 ATF_REQUIRE(::strftime(buf, sizeof(buf), "%Y-%m-%d", &data) != 0);
323 ATF_REQUIRE_EQ(buf, now.strftime("%Y-%m-%d"));
325 ATF_REQUIRE(now.strftime("%Z") == "GMT" || now.strftime("%Z") == "UTC");
329 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__granularity);
330 ATF_TEST_CASE_BODY(timestamp__now__granularity)
332 const datetime::timestamp first = datetime::timestamp::now();
334 const datetime::timestamp second = datetime::timestamp::now();
335 ATF_REQUIRE(first.to_microseconds() != second.to_microseconds());
339 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__strftime);
340 ATF_TEST_CASE_BODY(timestamp__strftime)
342 const datetime::timestamp ts1 = datetime::timestamp::from_values(
343 2010, 12, 10, 8, 45, 50, 0);
344 ATF_REQUIRE_EQ("2010-12-10", ts1.strftime("%Y-%m-%d"));
345 ATF_REQUIRE_EQ("08:45:50", ts1.strftime("%H:%M:%S"));
347 const datetime::timestamp ts2 = datetime::timestamp::from_values(
348 2011, 2, 16, 19, 15, 30, 0);
349 ATF_REQUIRE_EQ("2011-02-16T19:15:30", ts2.strftime("%Y-%m-%dT%H:%M:%S"));
353 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_iso8601_in_utc);
354 ATF_TEST_CASE_BODY(timestamp__to_iso8601_in_utc)
356 const datetime::timestamp ts1 = datetime::timestamp::from_values(
357 2010, 12, 10, 8, 45, 50, 0);
358 ATF_REQUIRE_EQ("2010-12-10T08:45:50.000000Z", ts1.to_iso8601_in_utc());
360 const datetime::timestamp ts2= datetime::timestamp::from_values(
361 2016, 7, 11, 17, 51, 28, 123456);
362 ATF_REQUIRE_EQ("2016-07-11T17:51:28.123456Z", ts2.to_iso8601_in_utc());
366 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_microseconds);
367 ATF_TEST_CASE_BODY(timestamp__to_microseconds)
369 const datetime::timestamp ts1 = datetime::timestamp::from_values(
370 2010, 12, 10, 8, 45, 50, 123456);
371 ATF_REQUIRE_EQ(1291970750123456LL, ts1.to_microseconds());
375 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_seconds);
376 ATF_TEST_CASE_BODY(timestamp__to_seconds)
378 const datetime::timestamp ts1 = datetime::timestamp::from_values(
379 2010, 12, 10, 8, 45, 50, 123456);
380 ATF_REQUIRE_EQ(1291970750, ts1.to_seconds());
384 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__leap_second);
385 ATF_TEST_CASE_BODY(timestamp__leap_second)
387 // This is actually a test for from_values(), which is the function that
388 // includes assertions to validate the input parameters.
389 const datetime::timestamp ts1 = datetime::timestamp::from_values(
390 2012, 6, 30, 23, 59, 60, 543);
391 ATF_REQUIRE_EQ(1341100800, ts1.to_seconds());
395 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__equals);
396 ATF_TEST_CASE_BODY(timestamp__equals)
398 ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) ==
399 datetime::timestamp::from_microseconds(1291970750123456LL));
403 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__differs);
404 ATF_TEST_CASE_BODY(timestamp__differs)
406 ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) !=
407 datetime::timestamp::from_microseconds(1291970750123455LL));
411 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__sorting);
412 ATF_TEST_CASE_BODY(timestamp__sorting)
415 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
417 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
420 ATF_REQUIRE(!(ts1 < ts2));
421 ATF_REQUIRE( ts1 <= ts2);
422 ATF_REQUIRE(!(ts1 > ts2));
423 ATF_REQUIRE( ts1 >= ts2);
426 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
428 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
431 ATF_REQUIRE( ts1 < ts2);
432 ATF_REQUIRE( ts1 <= ts2);
433 ATF_REQUIRE(!(ts1 > ts2));
434 ATF_REQUIRE(!(ts1 >= ts2));
437 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
439 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
442 ATF_REQUIRE(!(ts1 < ts2));
443 ATF_REQUIRE(!(ts1 <= ts2));
444 ATF_REQUIRE( ts1 > ts2);
445 ATF_REQUIRE( ts1 >= ts2);
450 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__add_delta);
451 ATF_TEST_CASE_BODY(timestamp__add_delta)
453 using datetime::delta;
454 using datetime::timestamp;
456 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 30, 1234),
457 timestamp::from_values(2014, 12, 11, 21, 43, 0, 0) +
459 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 22, 43, 7, 100),
460 timestamp::from_values(2014, 12, 11, 21, 43, 0, 0) +
461 delta(3602, 5000100));
465 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__add_delta_and_set);
466 ATF_TEST_CASE_BODY(timestamp__add_delta_and_set)
468 using datetime::delta;
469 using datetime::timestamp;
472 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 0, 0);
473 ts += delta(30, 1234);
474 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 30, 1234),
478 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 0, 0);
479 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 22, 43, 7, 100),
480 ts += delta(3602, 5000100));
485 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtract_delta);
486 ATF_TEST_CASE_BODY(timestamp__subtract_delta)
488 using datetime::delta;
489 using datetime::timestamp;
491 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 10, 4321),
492 timestamp::from_values(2014, 12, 11, 21, 43, 40, 5555) -
494 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 20, 43, 1, 300),
495 timestamp::from_values(2014, 12, 11, 21, 43, 8, 400) -
496 delta(3602, 5000100));
500 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtract_delta_and_set);
501 ATF_TEST_CASE_BODY(timestamp__subtract_delta_and_set)
503 using datetime::delta;
504 using datetime::timestamp;
507 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 40, 5555);
508 ts -= delta(30, 1234);
509 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 10, 4321),
513 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 8, 400);
514 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 20, 43, 1, 300),
515 ts -= delta(3602, 5000100));
520 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtraction);
521 ATF_TEST_CASE_BODY(timestamp__subtraction)
523 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
525 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
527 const datetime::timestamp ts3 = datetime::timestamp::from_microseconds(
530 ATF_REQUIRE_EQ(datetime::delta(0, 0), ts1 - ts1);
531 ATF_REQUIRE_EQ(datetime::delta(0, 12), ts2 - ts1);
532 ATF_REQUIRE_EQ(datetime::delta(100, 0), ts3 - ts1);
533 ATF_REQUIRE_EQ(datetime::delta(99, 999988), ts3 - ts2);
535 ATF_REQUIRE_THROW_RE(
537 "Cannot subtract 1291970850123456us from 1291970750123468us "
538 ".*negative datetime::delta.*not supported",
543 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__output);
544 ATF_TEST_CASE_BODY(timestamp__output)
547 std::ostringstream str;
548 str << datetime::timestamp::from_microseconds(1291970750123456LL);
549 ATF_REQUIRE_EQ("1291970750123456us", str.str());
552 std::ostringstream str;
553 str << datetime::timestamp::from_microseconds(1028309798759812LL);
554 ATF_REQUIRE_EQ("1028309798759812us", str.str());
559 ATF_INIT_TEST_CASES(tcs)
561 ATF_ADD_TEST_CASE(tcs, delta__defaults);
562 ATF_ADD_TEST_CASE(tcs, delta__overrides);
563 ATF_ADD_TEST_CASE(tcs, delta__from_microseconds);
564 ATF_ADD_TEST_CASE(tcs, delta__to_microseconds);
565 ATF_ADD_TEST_CASE(tcs, delta__equals);
566 ATF_ADD_TEST_CASE(tcs, delta__differs);
567 ATF_ADD_TEST_CASE(tcs, delta__sorting);
568 ATF_ADD_TEST_CASE(tcs, delta__addition);
569 ATF_ADD_TEST_CASE(tcs, delta__addition_and_set);
570 ATF_ADD_TEST_CASE(tcs, delta__scale);
571 ATF_ADD_TEST_CASE(tcs, delta__scale_and_set);
572 ATF_ADD_TEST_CASE(tcs, delta__output);
574 ATF_ADD_TEST_CASE(tcs, timestamp__copy);
575 ATF_ADD_TEST_CASE(tcs, timestamp__from_microseconds);
576 ATF_ADD_TEST_CASE(tcs, timestamp__now__mock);
577 ATF_ADD_TEST_CASE(tcs, timestamp__now__real);
578 ATF_ADD_TEST_CASE(tcs, timestamp__now__granularity);
579 ATF_ADD_TEST_CASE(tcs, timestamp__strftime);
580 ATF_ADD_TEST_CASE(tcs, timestamp__to_iso8601_in_utc);
581 ATF_ADD_TEST_CASE(tcs, timestamp__to_microseconds);
582 ATF_ADD_TEST_CASE(tcs, timestamp__to_seconds);
583 ATF_ADD_TEST_CASE(tcs, timestamp__leap_second);
584 ATF_ADD_TEST_CASE(tcs, timestamp__equals);
585 ATF_ADD_TEST_CASE(tcs, timestamp__differs);
586 ATF_ADD_TEST_CASE(tcs, timestamp__sorting);
587 ATF_ADD_TEST_CASE(tcs, timestamp__add_delta);
588 ATF_ADD_TEST_CASE(tcs, timestamp__add_delta_and_set);
589 ATF_ADD_TEST_CASE(tcs, timestamp__subtract_delta);
590 ATF_ADD_TEST_CASE(tcs, timestamp__subtract_delta_and_set);
591 ATF_ADD_TEST_CASE(tcs, timestamp__subtraction);
592 ATF_ADD_TEST_CASE(tcs, timestamp__output);