1// Copyright 2010 The Kyua Authors.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
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.
16//
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.
28
29#include "utils/datetime.hpp"
30
31extern "C" {
32#include <time.h>
33#include <unistd.h>
34}
35
36#include <sstream>
37#include <stdexcept>
38
39#include <atf-c++.hpp>
40
41namespace datetime = utils::datetime;
42
43
44ATF_TEST_CASE_WITHOUT_HEAD(delta__defaults);
45ATF_TEST_CASE_BODY(delta__defaults)
46{
47    const datetime::delta delta;
48    ATF_REQUIRE_EQ(0, delta.seconds);
49    ATF_REQUIRE_EQ(0, delta.useconds);
50}
51
52
53ATF_TEST_CASE_WITHOUT_HEAD(delta__overrides);
54ATF_TEST_CASE_BODY(delta__overrides)
55{
56    const datetime::delta delta(1, 2);
57    ATF_REQUIRE_EQ(1, delta.seconds);
58    ATF_REQUIRE_EQ(2, delta.useconds);
59
60    ATF_REQUIRE_THROW_RE(
61        std::runtime_error, "Negative.*not supported.*-4999997us",
62        datetime::delta(-5, 3));
63}
64
65
66ATF_TEST_CASE_WITHOUT_HEAD(delta__from_microseconds);
67ATF_TEST_CASE_BODY(delta__from_microseconds)
68{
69    {
70        const datetime::delta delta = datetime::delta::from_microseconds(0);
71        ATF_REQUIRE_EQ(0, delta.seconds);
72        ATF_REQUIRE_EQ(0, delta.useconds);
73    }
74    {
75        const datetime::delta delta = datetime::delta::from_microseconds(
76            999999);
77        ATF_REQUIRE_EQ(0, delta.seconds);
78        ATF_REQUIRE_EQ(999999, delta.useconds);
79    }
80    {
81        const datetime::delta delta = datetime::delta::from_microseconds(
82            1000000);
83        ATF_REQUIRE_EQ(1, delta.seconds);
84        ATF_REQUIRE_EQ(0, delta.useconds);
85    }
86    {
87        const datetime::delta delta = datetime::delta::from_microseconds(
88            10576293);
89        ATF_REQUIRE_EQ(10, delta.seconds);
90        ATF_REQUIRE_EQ(576293, delta.useconds);
91    }
92    {
93        const datetime::delta delta = datetime::delta::from_microseconds(
94            123456789123456LL);
95        ATF_REQUIRE_EQ(123456789, delta.seconds);
96        ATF_REQUIRE_EQ(123456, delta.useconds);
97    }
98
99    ATF_REQUIRE_THROW_RE(
100        std::runtime_error, "Negative.*not supported.*-12345us",
101        datetime::delta::from_microseconds(-12345));
102}
103
104
105ATF_TEST_CASE_WITHOUT_HEAD(delta__to_microseconds);
106ATF_TEST_CASE_BODY(delta__to_microseconds)
107{
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());
113}
114
115
116ATF_TEST_CASE_WITHOUT_HEAD(delta__equals);
117ATF_TEST_CASE_BODY(delta__equals)
118{
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));
122
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)));
126}
127
128
129ATF_TEST_CASE_WITHOUT_HEAD(delta__differs);
130ATF_TEST_CASE_BODY(delta__differs)
131{
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)));
135
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));
139}
140
141
142ATF_TEST_CASE_WITHOUT_HEAD(delta__sorting);
143ATF_TEST_CASE_BODY(delta__sorting)
144{
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());
149
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));
154
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)));
159
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)));
164
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));
169
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));
174}
175
176
177ATF_TEST_CASE_WITHOUT_HEAD(delta__addition);
178ATF_TEST_CASE_BODY(delta__addition)
179{
180    using datetime::delta;
181
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());
185
186    ATF_REQUIRE_EQ(delta(1, 234567), delta(0, 1234567) + delta());
187    ATF_REQUIRE_EQ(delta(12, 34), delta(10, 20) + delta(2, 14));
188}
189
190
191ATF_TEST_CASE_WITHOUT_HEAD(delta__addition_and_set);
192ATF_TEST_CASE_BODY(delta__addition_and_set)
193{
194    using datetime::delta;
195
196    {
197        delta d;
198        d += delta(3, 5);
199        ATF_REQUIRE_EQ(delta(3, 5), d);
200    }
201    {
202        delta d(1, 2);
203        d += delta(3, 5);
204        ATF_REQUIRE_EQ(delta(4, 7), d);
205    }
206    {
207        delta d(1, 2);
208        ATF_REQUIRE_EQ(delta(4, 7), (d += delta(3, 5)));
209    }
210}
211
212
213ATF_TEST_CASE_WITHOUT_HEAD(delta__scale);
214ATF_TEST_CASE_BODY(delta__scale)
215{
216    using datetime::delta;
217
218    ATF_REQUIRE_EQ(delta(), delta() * 0);
219    ATF_REQUIRE_EQ(delta(), delta() * 5);
220
221    ATF_REQUIRE_EQ(delta(0, 30), delta(0, 10) * 3);
222    ATF_REQUIRE_EQ(delta(17, 500000), delta(3, 500000) * 5);
223}
224
225
226ATF_TEST_CASE_WITHOUT_HEAD(delta__scale_and_set);
227ATF_TEST_CASE_BODY(delta__scale_and_set)
228{
229    using datetime::delta;
230
231    {
232        delta d(3, 5);
233        d *= 2;
234        ATF_REQUIRE_EQ(delta(6, 10), d);
235    }
236    {
237        delta d(8, 0);
238        d *= 8;
239        ATF_REQUIRE_EQ(delta(64, 0), d);
240    }
241    {
242        delta d(3, 5);
243        ATF_REQUIRE_EQ(delta(9, 15), (d *= 3));
244    }
245}
246
247
248ATF_TEST_CASE_WITHOUT_HEAD(delta__output);
249ATF_TEST_CASE_BODY(delta__output)
250{
251    {
252        std::ostringstream str;
253        str << datetime::delta(15, 8791);
254        ATF_REQUIRE_EQ("15008791us", str.str());
255    }
256    {
257        std::ostringstream str;
258        str << datetime::delta(12345678, 0);
259        ATF_REQUIRE_EQ("12345678000000us", str.str());
260    }
261}
262
263
264ATF_TEST_CASE_WITHOUT_HEAD(timestamp__copy);
265ATF_TEST_CASE_BODY(timestamp__copy)
266{
267    const datetime::timestamp ts1 = datetime::timestamp::from_values(
268        2011, 2, 16, 19, 15, 30, 0);
269    {
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"));
276    }
277    ATF_REQUIRE_EQ("2011", ts1.strftime("%Y"));
278}
279
280
281ATF_TEST_CASE_WITHOUT_HEAD(timestamp__from_microseconds);
282ATF_TEST_CASE_BODY(timestamp__from_microseconds)
283{
284    const datetime::timestamp ts = datetime::timestamp::from_microseconds(
285        1328829351987654LL);
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());
289}
290
291
292ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__mock);
293ATF_TEST_CASE_BODY(timestamp__now__mock)
294{
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"));
298
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"));
305}
306
307
308ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__real);
309ATF_TEST_CASE_BODY(timestamp__now__real)
310{
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
314    // other way.
315
316    const time_t just_before = ::time(NULL);
317    const datetime::timestamp now = datetime::timestamp::now();
318
319    ::tm data;
320    char buf[1024];
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"));
324
325    ATF_REQUIRE(now.strftime("%Z") == "GMT" || now.strftime("%Z") == "UTC");
326}
327
328
329ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__granularity);
330ATF_TEST_CASE_BODY(timestamp__now__granularity)
331{
332    const datetime::timestamp first = datetime::timestamp::now();
333    ::usleep(1);
334    const datetime::timestamp second = datetime::timestamp::now();
335    ATF_REQUIRE(first.to_microseconds() != second.to_microseconds());
336}
337
338
339ATF_TEST_CASE_WITHOUT_HEAD(timestamp__strftime);
340ATF_TEST_CASE_BODY(timestamp__strftime)
341{
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"));
346
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"));
350}
351
352
353ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_iso8601_in_utc);
354ATF_TEST_CASE_BODY(timestamp__to_iso8601_in_utc)
355{
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());
359
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());
363}
364
365
366ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_microseconds);
367ATF_TEST_CASE_BODY(timestamp__to_microseconds)
368{
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());
372}
373
374
375ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_seconds);
376ATF_TEST_CASE_BODY(timestamp__to_seconds)
377{
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());
381}
382
383
384ATF_TEST_CASE_WITHOUT_HEAD(timestamp__leap_second);
385ATF_TEST_CASE_BODY(timestamp__leap_second)
386{
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());
392}
393
394
395ATF_TEST_CASE_WITHOUT_HEAD(timestamp__equals);
396ATF_TEST_CASE_BODY(timestamp__equals)
397{
398    ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) ==
399                datetime::timestamp::from_microseconds(1291970750123456LL));
400}
401
402
403ATF_TEST_CASE_WITHOUT_HEAD(timestamp__differs);
404ATF_TEST_CASE_BODY(timestamp__differs)
405{
406    ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) !=
407                datetime::timestamp::from_microseconds(1291970750123455LL));
408}
409
410
411ATF_TEST_CASE_WITHOUT_HEAD(timestamp__sorting);
412ATF_TEST_CASE_BODY(timestamp__sorting)
413{
414    {
415        const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
416            1291970750123455LL);
417        const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
418            1291970750123455LL);
419
420        ATF_REQUIRE(!(ts1 < ts2));
421        ATF_REQUIRE(  ts1 <= ts2);
422        ATF_REQUIRE(!(ts1 > ts2));
423        ATF_REQUIRE(  ts1 >= ts2);
424    }
425    {
426        const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
427            1291970750123455LL);
428        const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
429            1291970759123455LL);
430
431        ATF_REQUIRE( ts1 < ts2);
432        ATF_REQUIRE( ts1 <= ts2);
433        ATF_REQUIRE(!(ts1 > ts2));
434        ATF_REQUIRE(!(ts1 >= ts2));
435    }
436    {
437        const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
438            1291970759123455LL);
439        const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
440            1291970750123455LL);
441
442        ATF_REQUIRE(!(ts1 < ts2));
443        ATF_REQUIRE(!(ts1 <= ts2));
444        ATF_REQUIRE(  ts1 > ts2);
445        ATF_REQUIRE(  ts1 >= ts2);
446    }
447}
448
449
450ATF_TEST_CASE_WITHOUT_HEAD(timestamp__add_delta);
451ATF_TEST_CASE_BODY(timestamp__add_delta)
452{
453    using datetime::delta;
454    using datetime::timestamp;
455
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) +
458                   delta(30, 1234));
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));
462}
463
464
465ATF_TEST_CASE_WITHOUT_HEAD(timestamp__add_delta_and_set);
466ATF_TEST_CASE_BODY(timestamp__add_delta_and_set)
467{
468    using datetime::delta;
469    using datetime::timestamp;
470
471    {
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),
475                       ts);
476    }
477    {
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));
481    }
482}
483
484
485ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtract_delta);
486ATF_TEST_CASE_BODY(timestamp__subtract_delta)
487{
488    using datetime::delta;
489    using datetime::timestamp;
490
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) -
493                   delta(30, 1234));
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));
497}
498
499
500ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtract_delta_and_set);
501ATF_TEST_CASE_BODY(timestamp__subtract_delta_and_set)
502{
503    using datetime::delta;
504    using datetime::timestamp;
505
506    {
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),
510                       ts);
511    }
512    {
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));
516    }
517}
518
519
520ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtraction);
521ATF_TEST_CASE_BODY(timestamp__subtraction)
522{
523    const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
524        1291970750123456LL);
525    const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
526        1291970750123468LL);
527    const datetime::timestamp ts3 = datetime::timestamp::from_microseconds(
528        1291970850123456LL);
529
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);
534
535    /*
536     * NOTE (ngie): behavior change for
537     * https://github.com/jmmv/kyua/issues/155 .
538     */
539    ATF_REQUIRE_EQ(datetime::delta::from_microseconds(1), ts2 - ts3);
540}
541
542
543ATF_TEST_CASE_WITHOUT_HEAD(timestamp__output);
544ATF_TEST_CASE_BODY(timestamp__output)
545{
546    {
547        std::ostringstream str;
548        str << datetime::timestamp::from_microseconds(1291970750123456LL);
549        ATF_REQUIRE_EQ("1291970750123456us", str.str());
550    }
551    {
552        std::ostringstream str;
553        str << datetime::timestamp::from_microseconds(1028309798759812LL);
554        ATF_REQUIRE_EQ("1028309798759812us", str.str());
555    }
556}
557
558
559ATF_INIT_TEST_CASES(tcs)
560{
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);
573
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);
593}
594