git://developer.intra2net.com / libi2ncommon / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge branch 'timefunc-new'
[libi2ncommon] / test / test_timefunc.cpp
... / ...
CommitLineData
1/*
2The software in this package is distributed under the GNU General
3Public License version 2 (with a special exception described below).
4
5A copy of GNU General Public License (GPL) is included in this distribution,
6in the file COPYING.GPL.
7
8As a special exception, if other files instantiate templates or use macros
9or inline functions from this file, or you compile this file and link it
10with other works to produce a work based on this file, this file
11does not by itself cause the resulting work to be covered
12by the GNU General Public License.
13
14However the source code for this file must still be made available
15in accordance with section (3) of the GNU General Public License.
16
17This exception does not invalidate any other reasons why a work based
18on this file might be covered by the GNU General Public License.
19*/
20/** @file
21 * @brief unit test for time related functions.
22 *
23 * @copyright Copyright © 2001-2008 by Intra2net AG
24 *
25 */
26
27#define BOOST_TEST_DYN_LINK
28#include <boost/test/unit_test.hpp>
29
30#include <timefunc.hxx>
31#include <filefunc.hxx>
32
33#include <unistd.h>
34#include <set>
35#include <iostream>
36
37using namespace std;
38using namespace I2n;
39using namespace I2n::Time;
40
41class TestTimeFuncFixture
42{
43protected:
44 typedef std::list< std::string > StringList;
45 std::set<std::string> used_check_files;
46 std::string tz; /* save and restore TZ from envp */
47
48 std::string get_check_file_path(std::string tag)
49 {
50 std::string result;
51 result= "__unittest__" + tag + ".dat";
52 used_check_files.insert(result);
53 return result;
54 } // eo get_check_file_path
55
56 void remove_check_files()
57 {
58 for (std::set<std::string>::iterator it= used_check_files.begin();
59 it != used_check_files.end();
60 ++it)
61 {
62 std::string filepath(*it);
63 if (path_exists(filepath))
64 {
65 unlink(filepath);
66 }
67 //TODO
68 }
69 used_check_files.clear();
70 } // eo remove_check_files
71
72 void set_utc (void)
73 {
74 errno = 0;
75 if (setenv ("TZ", "UTC", 1) == -1)
76 {
77 std::cerr
78 << "error setting environment 'TZ': [" << this->tz << "]"
79 << std::endl
80 ;
81 return;
82 }
83
84 tzset ();
85 }
86
87public:
88 TestTimeFuncFixture()
89 : tz (secure_getenv ("TZ") ?: "")
90 {
91 }
92
93 ~TestTimeFuncFixture()
94 {
95 remove_check_files();
96
97 errno = 0;
98 if (setenv ("TZ", this->tz.c_str (), 1) == -1)
99 {
100 std::cerr
101 << "error cleaning up environment 'TZ': [" << this->tz << "]"
102 << std::endl
103 ;
104 }
105 else
106 {
107 tzset();
108 }
109 }
110};
111
112BOOST_FIXTURE_TEST_SUITE(TestTimeFunc, TestTimeFuncFixture)
113
114BOOST_AUTO_TEST_CASE(AddIntervalsDisjoint)
115{
116 Intervals intervals;
117
118 intervals.add( Interval( 10, 100 ) );
119 intervals.add( Interval( 600, 620 ) );
120
121 BOOST_CHECK_EQUAL( false, intervals.empty() );
122 BOOST_CHECK_EQUAL( 2u, intervals.size() );
123
124 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
125 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
126
127 BOOST_CHECK_EQUAL( 600u, intervals.back().lower_bound() );
128 BOOST_CHECK_EQUAL( 620u, intervals.back().upper_bound() );
129} // eo AddIntervalsDisjoint()
130
131
132
133BOOST_AUTO_TEST_CASE(AddIntervalsInclude)
134{
135 Intervals intervals;
136
137 intervals.add( Interval( 10, 100 ) );
138 intervals.add( Interval( 10, 80 ) );
139
140 BOOST_CHECK_EQUAL( false, intervals.empty() );
141 BOOST_CHECK_EQUAL( 1u, intervals.size() );
142
143 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
144 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
145 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
146} // eo AddIntervalsInclude()
147
148
149
150BOOST_AUTO_TEST_CASE(AddIntervalsEmbrace)
151{
152 Intervals intervals;
153
154 intervals.add( Interval( 10, 100 ) );
155 intervals.add( Interval( 5, 120 ) );
156
157 BOOST_CHECK_EQUAL( false, intervals.empty() );
158 BOOST_CHECK_EQUAL( 1u, intervals.size() );
159
160 BOOST_CHECK_EQUAL( 5u, intervals.front().lower_bound() );
161 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
162 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
163} // eo AddIntervalsEmbrace()
164
165
166
167BOOST_AUTO_TEST_CASE(AddIntervalsJoin1)
168{
169 Intervals intervals;
170
171 intervals.add( Interval( 10, 100 ) );
172 intervals.add( Interval( 60, 120 ) );
173
174 BOOST_CHECK_EQUAL( false, intervals.empty() );
175 BOOST_CHECK_EQUAL( 1u, intervals.size() );
176
177 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
178 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
179 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
180} // eo AddIntervalsJoin1()
181
182
183
184BOOST_AUTO_TEST_CASE(AddIntervalsJoin1b)
185{
186 Intervals intervals;
187
188 intervals.add( Interval( 10, 100 ) );
189 intervals.add( Interval( 100, 120 ) );
190
191 BOOST_CHECK_EQUAL( false, intervals.empty() );
192 BOOST_CHECK_EQUAL( 1u, intervals.size() );
193
194 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
195 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
196 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
197} // eo AddIntervalsJoin1b()
198
199
200
201BOOST_AUTO_TEST_CASE(AddIntervalsJoin2)
202{
203 Intervals intervals;
204
205 intervals.add( Interval( 10, 100 ) );
206 intervals.add( Interval( 200, 250 ) );
207
208 BOOST_CHECK_EQUAL( false, intervals.empty() );
209 BOOST_CHECK_EQUAL( 2u, intervals.size() );
210
211 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
212 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
213 BOOST_CHECK_EQUAL( 200u, intervals.back().lower_bound() );
214 BOOST_CHECK_EQUAL( 250u, intervals.back().upper_bound() );
215
216 // now add the gap; the intervals should collapse to one covering all:
217 intervals.add( Interval(100, 200) );
218
219 BOOST_CHECK_EQUAL( false, intervals.empty() );
220 BOOST_CHECK_EQUAL( 1u, intervals.size() );
221
222 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
223 BOOST_CHECK_EQUAL( 250u, intervals.front().upper_bound() );
224 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
225} // eo AddIntervalsJoin2()
226
227
228
229BOOST_AUTO_TEST_CASE(SubIntervalsDisjoint)
230{
231 Intervals intervals;
232
233 intervals.add( Interval(10, 100) );
234 intervals.sub( Interval(0, 10) );
235
236 BOOST_CHECK_EQUAL( false, intervals.empty() );
237 BOOST_CHECK_EQUAL( 1u, intervals.size() );
238
239 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
240 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
241 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
242} // eo SubIntervalsDisjoint()
243
244
245
246BOOST_AUTO_TEST_CASE(SubIntervalsExact)
247{
248 Intervals intervals;
249
250 intervals.add( Interval(10, 100) );
251 intervals.sub( Interval(10, 100) );
252
253 BOOST_CHECK_EQUAL( true, intervals.empty() );
254 BOOST_CHECK_EQUAL( 0u, intervals.size() );
255} // eo SubIntervalsExact()
256
257
258
259BOOST_AUTO_TEST_CASE(SubIntervalsSplit1)
260{
261 Intervals intervals;
262
263 intervals.add( Interval(10, 100) );
264 intervals.sub( Interval(20, 40) );
265
266 BOOST_CHECK_EQUAL( false, intervals.empty() );
267 BOOST_CHECK_EQUAL( 2u, intervals.size() );
268
269 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
270 BOOST_CHECK_EQUAL( 20u, intervals.front().upper_bound() );
271
272 BOOST_CHECK_EQUAL( 40u, intervals.back().lower_bound() );
273 BOOST_CHECK_EQUAL( 100u, intervals.back().upper_bound() );
274 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
275 BOOST_CHECK_EQUAL( true, intervals.back().changed() );
276} // eo SubIntervalsSplit1()
277
278
279BOOST_AUTO_TEST_CASE(SubIntervalsCutFront)
280{
281 Intervals intervals;
282
283 intervals.add( Interval(10, 100) );
284 intervals.sub( Interval(10, 20) );
285
286 BOOST_CHECK_EQUAL( false, intervals.empty() );
287 BOOST_CHECK_EQUAL( 1u, intervals.size() );
288
289 BOOST_CHECK_EQUAL( 20u, intervals.front().lower_bound() );
290 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
291 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
292} // eo SubIntervalsCutFront()
293
294
295BOOST_AUTO_TEST_CASE(SubIntervalsCutBack)
296{
297 Intervals intervals;
298
299 intervals.add( Interval(10, 100) );
300 intervals.sub( Interval(87, 100) );
301
302 BOOST_CHECK_EQUAL( false, intervals.empty() );
303 BOOST_CHECK_EQUAL( 1u, intervals.size() );
304
305 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
306 BOOST_CHECK_EQUAL( 87u, intervals.front().upper_bound() );
307 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
308} // eo SubIntervalsCutBack()
309
310
311
312BOOST_AUTO_TEST_CASE(SubIntervalsCutMore)
313{
314 Intervals intervals;
315
316 intervals.add( Interval( 10, 100) );
317 intervals.add( Interval(110, 200) );
318 intervals.add( Interval(210, 300) );
319
320 // this should remove the first 2 intervals and cut the third:
321 intervals.sub( Interval(8, 220) );
322
323 BOOST_CHECK_EQUAL( false, intervals.empty() );
324 BOOST_CHECK_EQUAL( 1u, intervals.size() );
325
326 BOOST_CHECK_EQUAL( 220u, intervals.front().lower_bound() );
327 BOOST_CHECK_EQUAL( 300u, intervals.front().upper_bound() );
328 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
329} // eo SubIntervalsCutMore()
330
331
332BOOST_AUTO_TEST_CASE(IntervalComparisons)
333{
334 Intervals intervals1;
335 Intervals intervals2;
336
337 intervals1.add( Interval( 10, 120) );
338
339 intervals2.add( Interval( 10, 110 ) );
340 intervals2.add( Interval( 100, 120 ) );
341
342 BOOST_CHECK_EQUAL( 1u, intervals2.size() );
343
344 BOOST_CHECK( intervals1 == intervals2 );
345 BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
346 BOOST_CHECK_EQUAL( true, intervals2.contains( intervals1 ));
347
348 intervals2.sub( Interval( 40, 50) );
349
350 BOOST_CHECK( intervals1 != intervals2 );
351 BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
352 BOOST_CHECK_EQUAL( false, intervals2.contains( intervals1 ));
353} // eo IntervalComparisons()
354
355
356
357BOOST_AUTO_TEST_CASE(MonotonicClock)
358{
359 long sec0, nsec0;
360 long sec1, nsec1;
361
362 bool res = monotonic_clock_gettime(sec0,nsec0);
363 BOOST_CHECK_EQUAL( true, res );
364
365 usleep(250000);
366 res= monotonic_clock_gettime(sec1,nsec1);
367 BOOST_CHECK_EQUAL( true, res);
368
369 long delta_sec = sec1 - sec0;
370 long delta_nsec= nsec1 - nsec0;
371
372 long delta_millisec= ( delta_nsec / 1000000L) + delta_sec * 1000L;
373
374 BOOST_CHECK( delta_millisec >= 250 - /*fuzz*/ 1);
375 BOOST_CHECK( delta_millisec < 300 );
376} // eo MonotonicClock()
377
378BOOST_AUTO_TEST_CASE(WeekInvalid)
379{
380 Week week("99999999");
381 BOOST_CHECK_EQUAL(false, week.is_valid());
382 BOOST_CHECK_EQUAL(string(""), week.get_displaystring());
383}
384
385BOOST_AUTO_TEST_CASE(WeekDisplayString1)
386{
387 Week week("");
388 BOOST_CHECK_EQUAL(true, week.is_valid());
389 BOOST_CHECK_EQUAL(string(""), week.get_displaystring());
390}
391
392BOOST_AUTO_TEST_CASE(WeekDisplayString2)
393{
394 Week week("0123456");
395 BOOST_CHECK_EQUAL(true, week.is_valid());
396 BOOST_CHECK_EQUAL(string("Mon-Sun"), week.get_displaystring());
397}
398
399BOOST_AUTO_TEST_CASE(WeekDisplayString3)
400{
401 Week week("123456");
402 BOOST_CHECK_EQUAL(true, week.is_valid());
403 BOOST_CHECK_EQUAL(string("Mon-Sat"), week.get_displaystring());
404}
405
406BOOST_AUTO_TEST_CASE(WeekDisplayString4)
407{
408 Week week("012345");
409 BOOST_CHECK_EQUAL(true, week.is_valid());
410 BOOST_CHECK_EQUAL(string("Mon-Fri, Sun"), week.get_displaystring());
411}
412
413BOOST_AUTO_TEST_CASE(WeekDisplayString5)
414{
415 Week week("1256");
416 BOOST_CHECK_EQUAL(true, week.is_valid());
417 BOOST_CHECK_EQUAL(string("Mon, Tue, Fri, Sat"), week.get_displaystring());
418}
419
420BOOST_AUTO_TEST_CASE(WeekDisplayString6)
421{
422 Week week("0246");
423 BOOST_CHECK_EQUAL(true, week.is_valid());
424 BOOST_CHECK_EQUAL(string("Tue, Thu, Sat, Sun"), week.get_displaystring());
425}
426
427BOOST_AUTO_TEST_CASE(WeekDisplayString7)
428{
429 Week week("135");
430 BOOST_CHECK_EQUAL(true, week.is_valid());
431 BOOST_CHECK_EQUAL(string("Mon, Wed, Fri"), week.get_displaystring());
432}
433
434BOOST_AUTO_TEST_CASE(WeekDisplayString8)
435{
436 Week week("15");
437 BOOST_CHECK_EQUAL(true, week.is_valid());
438 BOOST_CHECK_EQUAL(string("Mon, Fri"), week.get_displaystring());
439}
440
441BOOST_AUTO_TEST_CASE(WeekDisplayString9)
442{
443 Week week("06");
444 BOOST_CHECK_EQUAL(true, week.is_valid());
445 BOOST_CHECK_EQUAL(string("Sat, Sun"), week.get_displaystring());
446}
447
448BOOST_AUTO_TEST_CASE(WeekDisplayString10)
449{
450 Week week("056");
451 BOOST_CHECK_EQUAL(true, week.is_valid());
452 BOOST_CHECK_EQUAL(string("Fri-Sun"), week.get_displaystring());
453}
454
455BOOST_AUTO_TEST_CASE(WeekDisplayString11)
456{
457 Week week("0");
458 BOOST_CHECK_EQUAL(true, week.is_valid());
459 BOOST_CHECK_EQUAL(string("Sun"), week.get_displaystring());
460}
461
462BOOST_AUTO_TEST_CASE(WeekDisplayString12)
463{
464 Week week("6");
465 BOOST_CHECK_EQUAL(true, week.is_valid());
466 BOOST_CHECK_EQUAL(string("Sat"), week.get_displaystring());
467}
468
469BOOST_AUTO_TEST_CASE(WeekDisplayString13)
470{
471 Week week("123");
472 BOOST_CHECK_EQUAL(true, week.is_valid());
473 BOOST_CHECK_EQUAL(string("Mon-Wed"), week.get_displaystring());
474}
475
476BOOST_AUTO_TEST_CASE(FormatFullTime)
477{
478 time_t seconds = 1318844005;
479
480 BOOST_CHECK_EQUAL("17.10.2011 11:33", format_full_time(seconds));
481}
482
483BOOST_AUTO_TEST_CASE(DateToSeconds1)
484{
485 // no DST
486 BOOST_CHECK_EQUAL(1325372400, date_to_seconds("2012-01-01"));
487}
488
489BOOST_AUTO_TEST_CASE(DateToSeconds2)
490{
491 // DST
492 BOOST_CHECK_EQUAL(1341093600, date_to_seconds("2012-07-01"));
493}
494
495BOOST_AUTO_TEST_CASE(FormatISO8601_T)
496{
497 const time_t moment = 1515492684;
498 BOOST_CHECK_EQUAL("10:11:24",
499 format_iso8601 (moment, true, false, true, false));
500}
501
502BOOST_AUTO_TEST_CASE(FormatISO8601_TZ_local)
503{
504 const time_t moment = 1515492684;
505 BOOST_CHECK_EQUAL("11:11:24Z+0100",
506 format_iso8601 (moment, false, false, true, true));
507}
508
509BOOST_AUTO_TEST_CASE(FormatISO8601_TZ)
510{
511 const time_t moment = 1515492684;
512 BOOST_CHECK_EQUAL("10:11:24Z+0000",
513 format_iso8601 (moment, true, false, true, true));
514}
515
516BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_local)
517{
518 const time_t moment = 1515492684;
519 BOOST_CHECK_EQUAL("2018-01-09T11:11:24Z+0100",
520 format_iso8601 (moment, false, true, true, true));
521}
522
523BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ)
524{
525 const time_t moment = 1515492684;
526 BOOST_CHECK_EQUAL("2018-01-09T10:11:24Z+0000",
527 format_iso8601 (moment, true, true, true, true));
528}
529
530BOOST_AUTO_TEST_CASE(FormatISO8601_DT)
531{
532 const time_t moment = 1515492684;
533 BOOST_CHECK_EQUAL("2018-01-09T10:11:24",
534 format_iso8601 (moment, true, true, true, false));
535}
536
537BOOST_AUTO_TEST_CASE(FormatISO8601_D)
538{
539 const time_t moment = 1515492684;
540 BOOST_CHECK_EQUAL("2018-01-09",
541 format_iso8601 (moment, true, true, false, false));
542}
543
544BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_struct_tm)
545{
546 struct tm helau;
547 helau.tm_sec = 11;
548 helau.tm_min = 11;
549 helau.tm_hour = 11;
550 helau.tm_mday = 11;
551 helau.tm_mon = 10;
552 helau.tm_year = 2018 - 1900;
553 helau.tm_wday = 0;
554 helau.tm_yday = 315;
555 helau.tm_isdst = 0;
556 helau.tm_gmtoff = 0;
557 helau.tm_zone = NULL;
558
559 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000",
560 format_iso8601 (helau, true, true, true));
561}
562
563BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_struct_timespec)
564{
565 struct timespec ts = { 1541934671, 11 };
566
567 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000",
568 format_iso8601 (ts, true, true, true, true));
569}
570
571BOOST_AUTO_TEST_SUITE(Clock)
572
573 BOOST_AUTO_TEST_CASE(ctor_simple)
574 {
575 I2n::clock::Time t;
576
577 BOOST_CHECK_EQUAL(t.get_sec (), 0);
578 BOOST_CHECK_EQUAL(t.get_nsec (), 0);
579 }
580
581 BOOST_AUTO_TEST_CASE(ctor_type)
582 {
583 I2n::clock::Time t1 (I2n::clock::type::real);
584 I2n::clock::Time t2 (I2n::clock::type::mono);
585 I2n::clock::Time t3 (I2n::clock::type::boot);
586 I2n::clock::Time t4 (I2n::clock::type::cpu);
587
588 BOOST_CHECK_EQUAL(t1.get_sec (), 0);
589 BOOST_CHECK_EQUAL(t1.get_nsec (), 0);
590
591 BOOST_CHECK_EQUAL(t2.get_sec (), 0);
592 BOOST_CHECK_EQUAL(t2.get_nsec (), 0);
593
594 BOOST_CHECK_EQUAL(t3.get_sec (), 0);
595 BOOST_CHECK_EQUAL(t3.get_nsec (), 0);
596
597 BOOST_CHECK_EQUAL(t4.get_sec (), 0);
598 BOOST_CHECK_EQUAL(t4.get_nsec (), 0);
599 }
600
601 BOOST_AUTO_TEST_CASE(ctor_variant)
602 {
603 I2n::clock::Time tmc (I2n::clock::type::mono);
604 I2n::clock::Time tmr (I2n::clock::type::mono, I2n::clock::type::raw);
605 I2n::clock::Time tme (I2n::clock::type::mono, I2n::clock::type::exact);
606
607 I2n::clock::Time trc (I2n::clock::type::real);
608 I2n::clock::Time tre (I2n::clock::type::real, I2n::clock::type::exact);
609
610 I2n::clock::Time tb (I2n::clock::type::boot);
611
612 I2n::clock::Time tcp (I2n::clock::type::cpu);
613 I2n::clock::Time tct (I2n::clock::type::cpu, I2n::clock::type::thread);
614
615 BOOST_CHECK_EQUAL(tmc.get_sec (), 0); /* MONO */
616 BOOST_CHECK_EQUAL(tmc.get_nsec (), 0);
617
618 BOOST_CHECK_EQUAL(tmr.get_sec (), 0);
619 BOOST_CHECK_EQUAL(tmr.get_nsec (), 0);
620
621 BOOST_CHECK_EQUAL(tme.get_sec (), 0);
622 BOOST_CHECK_EQUAL(tme.get_nsec (), 0);
623
624 BOOST_CHECK_EQUAL(trc.get_sec (), 0); /* REAL */
625 BOOST_CHECK_EQUAL(trc.get_nsec (), 0);
626
627 BOOST_CHECK_EQUAL(tre.get_sec (), 0);
628 BOOST_CHECK_EQUAL(tre.get_nsec (), 0);
629
630 BOOST_CHECK_EQUAL(tb.get_sec (), 0); /* BOOT */
631 BOOST_CHECK_EQUAL(tb.get_nsec (), 0);
632
633 BOOST_CHECK_EQUAL(tcp.get_sec (), 0); /* CPU */
634 BOOST_CHECK_EQUAL(tcp.get_nsec (), 0);
635
636 BOOST_CHECK_EQUAL(tct.get_sec (), 0);
637 BOOST_CHECK_EQUAL(tct.get_nsec (), 0);
638 }
639
640 BOOST_AUTO_TEST_CASE(initializer_now)
641 {
642 boost::optional<I2n::clock::Time> t = I2n::clock::now ();
643
644 BOOST_CHECK(t);
645 BOOST_CHECK_GT(t->get_sec (), 0);
646 BOOST_CHECK_EQUAL(t->err, 0);
647 }
648
649 BOOST_AUTO_TEST_CASE(initializer_zero)
650 {
651 I2n::clock::Time stundenull = I2n::clock::zero ();
652
653 BOOST_CHECK_EQUAL(stundenull.get_sec (), 0);
654 BOOST_CHECK_EQUAL(stundenull.get_nsec (), 0);
655 BOOST_CHECK_EQUAL(stundenull.err, 0);
656 }
657
658 BOOST_AUTO_TEST_CASE(member_set_now)
659 {
660 I2n::clock::Time t;
661
662 BOOST_CHECK(t.set ());
663
664 BOOST_CHECK_NE(t.get_sec (), 0);
665 }
666
667 BOOST_AUTO_TEST_CASE(member_set_value)
668 {
669 I2n::clock::Time t;
670
671 t.set (42, 42);
672
673 BOOST_CHECK_EQUAL(t.get_sec (), 42);
674 BOOST_CHECK_EQUAL(t.get_nsec (), 42);
675 }
676
677 BOOST_AUTO_TEST_CASE(member_set_value_type)
678 {
679 I2n::clock::Time t;
680
681 t.set (42, 42, I2n::clock::type::real, I2n::clock::type::exact);
682
683 BOOST_CHECK_EQUAL(t.get_sec (), 42);
684 BOOST_CHECK_EQUAL(t.get_nsec (), 42);
685 }
686
687 BOOST_AUTO_TEST_CASE(member_add_parts)
688 {
689 I2n::clock::Time t;
690
691 t.set (42, 42);
692 t.add (2187, 2187);
693
694 BOOST_CHECK_EQUAL(t.get_sec (), 2229);
695 BOOST_CHECK_EQUAL(t.get_nsec (), 2229);
696 }
697
698 BOOST_AUTO_TEST_CASE(member_sub_parts)
699 {
700 I2n::clock::Time t;
701
702 t.set (2, 0L);
703 t.subtract (1, 1L);
704
705 BOOST_CHECK_EQUAL(t.get_sec (), 0);
706 BOOST_CHECK_EQUAL(t.get_nsec (), 999999999);
707 }
708
709 BOOST_AUTO_TEST_CASE(member_sub_Time)
710 {
711 I2n::clock::Time t1;
712 I2n::clock::Time t2;
713
714 t1.set (42, 42L);
715 t2.set (42, 0L);
716
717 t1.subtract (t2);
718
719 BOOST_CHECK_EQUAL(t1.get_sec (), 0);
720 BOOST_CHECK_EQUAL(t1.get_nsec (), 42L);
721 }
722
723 BOOST_AUTO_TEST_CASE(member_diff)
724 {
725 static const time_t five = 5 * 365 * 24 * 3600;
726
727 I2n::clock::Time t1 (42, 1337);
728 I2n::clock::Time t2 = t1 + five;;
729 I2n::clock::Time t3 = t1 - five;;
730
731 BOOST_CHECK_EQUAL(t2, I2n::clock::Time ((time_t)42 + five, 1337));
732 BOOST_CHECK_EQUAL(t3, I2n::clock::Time ((time_t)42 - five, 1337));
733 BOOST_CHECK_EQUAL(t1.difference (t3), t3.difference (t1));
734 BOOST_CHECK_EQUAL(t3.difference (t3), t3.difference (t3));
735 }
736
737 BOOST_AUTO_TEST_CASE(op_copyassign)
738 {
739 I2n::clock::Time t1;
740 I2n::clock::Time t2;
741
742 BOOST_CHECK(t1.set ());
743
744 t2 = t1;
745
746 BOOST_CHECK_EQUAL(t1.get_sec (), t2.get_sec ());
747 BOOST_CHECK_EQUAL(t1.get_nsec (), t2.get_nsec ());
748 }
749
750 BOOST_AUTO_TEST_CASE(op_equal)
751 {
752 I2n::clock::Time t1;
753 I2n::clock::Time t2;
754
755 BOOST_CHECK(t1.set ());
756 t2 = t1;
757
758 BOOST_CHECK_EQUAL(t1, t2);
759 }
760
761 BOOST_AUTO_TEST_CASE(op_add_Time)
762 {
763 I2n::clock::Time t1;
764 I2n::clock::Time t2;
765 I2n::clock::Time tsum;
766
767 t1.set (2187, 2187);
768 t2.set (1337, 1337);
769 tsum = t1 + t2;
770
771 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
772 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
773 }
774
775 BOOST_AUTO_TEST_CASE(op_add_Time_carry)
776 {
777 I2n::clock::Time t1;
778 I2n::clock::Time t2;
779 I2n::clock::Time tsum;
780
781 t1.set (2187, 2187);
782# if LONG_BIT == 32
783 t2.set (1300, 2L * 1000 * 1000 * 1000 + 1337);
784# else
785 t2.set (1300, 37L * 1000 * 1000 * 1000 + 1337);
786# endif
787
788 tsum = t1 + t2;
789
790# if LONG_BIT == 32
791 BOOST_CHECK_EQUAL(tsum.get_sec (), 3489);
792 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
793# else
794 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
795 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
796# endif
797 }
798
799 BOOST_AUTO_TEST_CASE(op_add_time_t)
800 {
801 I2n::clock::Time t1 (2187, 2187);
802 time_t t2 = 1337;
803 I2n::clock::Time tsum;
804
805 tsum = t1 + t2;
806
807 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
808 BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
809 }
810
811 BOOST_AUTO_TEST_CASE(op_add_time_t_external)
812 {
813 time_t t1 = 1337;
814 I2n::clock::Time t2 (2187, 2187);
815 I2n::clock::Time tsum;
816
817 tsum = t1 + t2;
818
819 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
820 BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
821 }
822
823 BOOST_AUTO_TEST_CASE(op_incr_Time)
824 {
825 I2n::clock::Time t1 (2187, 2187);
826 I2n::clock::Time t2 (1337, 1337);
827
828 t1 += t2;
829
830 BOOST_CHECK_EQUAL(t1.get_sec (), 3524);
831 BOOST_CHECK_EQUAL(t1.get_nsec (), 3524);
832 }
833
834 BOOST_AUTO_TEST_CASE(op_incr_time_t)
835 {
836 I2n::clock::Time t1 (2187, 2187);
837 time_t t2 = 1337;
838
839 t1 += t2;
840
841 BOOST_CHECK_EQUAL(t1.get_sec (), 3524);
842 BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
843 }
844
845 BOOST_AUTO_TEST_CASE(op_subtract_Time)
846 {
847 I2n::clock::Time t1;
848 I2n::clock::Time t2;
849 I2n::clock::Time tdiff;
850
851 t1.set (2187, 2187);
852 t2.set (1337, 1337);
853 tdiff = t1 - t2;
854
855 BOOST_CHECK_EQUAL(tdiff.get_sec (), 850);
856 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 850);
857 }
858
859 BOOST_AUTO_TEST_CASE(op_subtract_time_t)
860 {
861 I2n::clock::Time t1 (2187, 2187);
862 time_t t2 = 1337;
863 I2n::clock::Time tdiff;
864
865 tdiff = t1 - t2;
866
867 BOOST_CHECK_EQUAL(tdiff.get_sec (), 850);
868 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 2187);
869 }
870
871 BOOST_AUTO_TEST_CASE(op_subtract_time_t_external)
872 {
873 time_t t1 = 1337;
874 I2n::clock::Time t2 (2187, 2187);
875 I2n::clock::Time tdiff;
876
877 tdiff = t1 - t2;
878
879 BOOST_CHECK_EQUAL(tdiff.get_sec (), -851);
880 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 999997813);
881 }
882
883 BOOST_AUTO_TEST_CASE(op_decr_Time)
884 {
885 I2n::clock::Time t1 (2187, 2187);
886 I2n::clock::Time t2 (1337, 1337);
887
888 t1 -= t2;
889
890 BOOST_CHECK_EQUAL(t1.get_sec (), 850);
891 BOOST_CHECK_EQUAL(t1.get_nsec (), 850);
892 }
893
894 BOOST_AUTO_TEST_CASE(op_decr_time_t)
895 {
896 I2n::clock::Time t1 (2187, 2187);
897 time_t t2 = 1337;
898
899 t1 -= t2;
900
901 BOOST_CHECK_EQUAL(t1.get_sec (), 850);
902 BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
903 }
904
905 BOOST_AUTO_TEST_CASE(op_mult_scale)
906 {
907 I2n::clock::Time t1;
908 I2n::clock::Time t2;
909
910 t1.set (1, 1);
911 t2 = t1 * 42;
912
913 BOOST_CHECK_EQUAL(t2.get_sec (), 42);
914 BOOST_CHECK_EQUAL(t2.get_nsec (), 42);
915 }
916
917 BOOST_AUTO_TEST_CASE(op_mult_mutate)
918 {
919 I2n::clock::Time t1 ( 42, 42);
920 I2n::clock::Time t2 (1337, 0);
921
922 t1 *= 2;
923 t2 *= -10;
924
925 BOOST_CHECK_EQUAL(t1.get_sec (), 84);
926 BOOST_CHECK_EQUAL(t1.get_nsec (), 84);
927 BOOST_CHECK_EQUAL(t2.get_sec (), -13370);
928 }
929
930 BOOST_AUTO_TEST_CASE(op_mult_scale_carry)
931 {
932 I2n::clock::Time t1;
933 I2n::clock::Time t2;
934
935 t1.set (1, 500 * 1000 * 1000);
936 t2 = t1 * 3;
937
938 BOOST_CHECK_EQUAL(t2.get_sec (), 4);
939 BOOST_CHECK_EQUAL(t2.get_nsec (), 500 * 1000 * 1000);
940 }
941
942 BOOST_AUTO_TEST_CASE(op_equals)
943 {
944 I2n::clock::Time t1;
945 I2n::clock::Time t2;
946
947 t1.set (50, 50);
948 t2.set (50, 50);
949
950 BOOST_CHECK_EQUAL(t1, t2);
951 }
952
953 BOOST_AUTO_TEST_CASE(compare_equal)
954 {
955 I2n::clock::Time t1;
956 I2n::clock::Time t2;
957
958 t1.set (42, 42);
959 t2.set (42, 42);
960
961 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), 0);
962 }
963
964 BOOST_AUTO_TEST_CASE(compare_equal_type)
965 {
966 I2n::clock::Time t1 (42, 42, I2n::clock::type::real);
967 I2n::clock::Time t2 (42, 42, I2n::clock::type::cpu);
968 I2n::clock::Time t3 (42, 0, I2n::clock::type::real);
969 I2n::clock::Time t4 (42, 42, I2n::clock::type::real);
970
971 BOOST_CHECK_NE(t1, t2);
972 BOOST_CHECK_NE(t1, t3);
973 BOOST_CHECK_EQUAL(t1, t4);
974 }
975
976 BOOST_AUTO_TEST_CASE(compare_ne_sec)
977 {
978 I2n::clock::Time t1;
979 I2n::clock::Time t2;
980
981 t1.set ( 42, 42);
982 t2.set (1337, 42);
983
984 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
985 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), 1);
986 }
987
988 BOOST_AUTO_TEST_CASE(compare_ne_nsec)
989 {
990 I2n::clock::Time t1;
991 I2n::clock::Time t2;
992
993 t1.set (42, 42);
994 t2.set (42, 1337);
995
996 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
997 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), 1);
998 }
999
1000 BOOST_AUTO_TEST_CASE(compare_ne_both)
1001 {
1002 I2n::clock::Time t1;
1003 I2n::clock::Time t2;
1004
1005 t1.set (42, 2187);
1006 t2.set (23, 1337);
1007
1008 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), 1);
1009 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), -1);
1010 }
1011
1012 BOOST_AUTO_TEST_CASE(op_ineq_sec)
1013 {
1014 I2n::clock::Time t1 (1337);
1015 I2n::clock::Time t2 (2187);
1016
1017 BOOST_CHECK_LT(t1, t2);
1018 BOOST_CHECK_GT(t2, t1);
1019 }
1020
1021 BOOST_AUTO_TEST_CASE(op_ineq_nsec)
1022 {
1023 I2n::clock::Time t1 (1337, 23);
1024 I2n::clock::Time t2 (1337, 42);
1025
1026 BOOST_CHECK_LT(t1, t2);
1027 BOOST_CHECK_GT(t2, t1);
1028 }
1029
1030 BOOST_AUTO_TEST_CASE(op_ineq_both)
1031 {
1032 I2n::clock::Time t1 (2187, 23);
1033 I2n::clock::Time t2 (1337, 42);
1034
1035 BOOST_CHECK_LT(t2, t1);
1036 BOOST_CHECK_GT(t1, t2);
1037 }
1038
1039 BOOST_AUTO_TEST_CASE(op_eq_time_t)
1040 {
1041 boost::optional<I2n::clock::Time> t1 = I2n::clock::now ();
1042 const time_t t2 = time (NULL); /* race here */
1043
1044 *t1 -= (time_t)42;
1045
1046 BOOST_CHECK_NE(*t1, t2);
1047 BOOST_CHECK_LT(*t1, t2);
1048 BOOST_CHECK_GT( t2, *t1);
1049 }
1050
1051 BOOST_AUTO_TEST_CASE(Format_sec_msec)
1052 {
1053 I2n::clock::Time t1 (42, 42);
1054 I2n::clock::Time t2 ( 4, 242424242);
1055 I2n::clock::Time t3 ( 0, 133713371);
1056 I2n::clock::Time t4 ( 0, 0);
1057
1058 std::string s1 = t1.format_sec_msec ();
1059 std::string s2 = t2.format_sec_msec ();
1060 std::string s3 = t3.format_sec_msec ();
1061 std::string s4 = t4.format_sec_msec ();
1062
1063 BOOST_CHECK_EQUAL("42s 0ms" , s1);
1064 BOOST_CHECK_EQUAL( "4s 242ms", s2);
1065 BOOST_CHECK_EQUAL( "0s 133ms", s3);
1066 BOOST_CHECK_EQUAL( "0s 0ms" , s4);
1067 }
1068
1069 BOOST_AUTO_TEST_CASE(Format_min_sec_msec)
1070 {
1071 I2n::clock::Time t1 (42*60 + 42, 42);
1072 I2n::clock::Time t2 ( 4*60 + 42, 242424242);
1073 I2n::clock::Time t3 ( 0*60 + 42, 133713371);
1074 I2n::clock::Time t4 ( 0 + 0, 0);
1075
1076 std::string s1 = *t1.format_min_sec_msec ();
1077 std::string s2 = *t2.format_min_sec_msec ();
1078 std::string s3 = *t3.format_min_sec_msec ();
1079 std::string s4 = *t4.format_min_sec_msec ();
1080
1081 BOOST_CHECK_EQUAL("42m42.000s", s1);
1082 BOOST_CHECK_EQUAL( "4m42.242s", s2);
1083 BOOST_CHECK_EQUAL( "0m42.133s", s3);
1084 BOOST_CHECK_EQUAL( "0m0.000s", s4);
1085 }
1086
1087 BOOST_AUTO_TEST_CASE(FormatISO8601_T)
1088 {
1089 I2n::clock::Time t (42, 42);
1090 boost::optional<std::string> s = t.format_iso8601 (true, false, true, false);
1091
1092 BOOST_CHECK_EQUAL("00:00:42", *s);
1093 }
1094
1095 BOOST_AUTO_TEST_CASE(FormatISO8601_DT)
1096 {
1097 I2n::clock::Time t (1541934671, 0);
1098 boost::optional<std::string> s = t.format_iso8601 (true, true, true, false);
1099
1100 BOOST_CHECK_EQUAL("2018-11-11T11:11:11", *s);
1101 }
1102
1103 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ)
1104 {
1105 I2n::clock::Time t (1541934671, 0);
1106 boost::optional<std::string> s = t.format_iso8601 (true, true, true, true);
1107
1108 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000", *s);
1109 }
1110
1111 BOOST_AUTO_TEST_CASE(Format_make_nice_time)
1112 {
1113 I2n::clock::Time t (111111, 0);
1114 boost::optional<std::string> s = t.make_nice_time ();
1115
1116 BOOST_CHECK_EQUAL("1 day, 06:51:51", *s);
1117 }
1118
1119 BOOST_AUTO_TEST_CASE(Format_format_full_time)
1120 {
1121 I2n::clock::Time t (1541934671, 0);
1122 /*
1123 * brr, the old formatters use localtime without a way to opt out of
1124 * it!
1125 */
1126 this->set_utc ();
1127 boost::optional<std::string> s = t.format_full_time ();
1128
1129 BOOST_CHECK_EQUAL("11.11.2018 11:11", *s);
1130 }
1131
1132 BOOST_AUTO_TEST_CASE(Format_format_date)
1133 {
1134 I2n::clock::Time t (1541934671, 0);
1135 boost::optional<std::string> s = t.format_date ();
1136
1137 BOOST_CHECK_EQUAL("11.11.2018", *s);
1138 }
1139
1140 BOOST_AUTO_TEST_CASE(FromString_iso8601_full)
1141 {
1142 const std::string in1 ("0001-01-01T00:00:00Z+0000");
1143 const std::string in2 ("2018-11-11T11:11:11Z+0000");
1144
1145 this->set_utc ();
1146
1147 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1148 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1149
1150# if LONG_BIT == 32
1151 BOOST_CHECK(!t1);
1152# else
1153 BOOST_CHECK(t1);
1154 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
1155# endif
1156
1157 BOOST_CHECK(t2);
1158 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
1159 }
1160
1161 BOOST_AUTO_TEST_CASE(FromString_iso8601_full_negyear)
1162 {
1163 const std::string in1 ("-0001-01-01T00:00:00Z+0000");
1164 const std::string in2 ("-2018-11-11T11:11:11Z+0000");
1165
1166 this->set_utc ();
1167
1168 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1169 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1170
1171# if LONG_BIT == 32
1172 BOOST_CHECK(!t1);
1173 BOOST_CHECK(!t2);
1174# else
1175 BOOST_CHECK(t1);
1176 BOOST_CHECK(t2);
1177 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
1178 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
1179# endif
1180 }
1181
1182 BOOST_AUTO_TEST_CASE(FromString_iso8601_partial)
1183 {
1184 const std::string in1 ("2018-11-11T11:11:11");
1185 const std::string in2 ("2018-11-11");
1186
1187 this->set_utc ();
1188
1189 boost::optional<I2n::clock::Time> t1 =
1190 I2n::clock::time_of_iso8601 (in1, true, true, false);
1191 boost::optional<I2n::clock::Time> t2 =
1192 I2n::clock::time_of_iso8601 (in2, true, false, false);
1193
1194 BOOST_CHECK(t1);
1195 BOOST_CHECK(t2);
1196 /*
1197 * We test for the difference here which is zero if the number is
1198 * correct but causes the difference from the expected value to be
1199 * printed in case the test fails.
1200 */
1201 BOOST_CHECK_EQUAL(*t1->format_iso8601 (true, true, true, false), in1);
1202 BOOST_CHECK_EQUAL(*t2->format_iso8601 (true, true, false, false), in2);
1203 }
1204
1205 BOOST_AUTO_TEST_CASE(FromString_iso8601_32bit_time_t_err)
1206 {
1207 const std::string timeless ("11:11:11");
1208 boost::optional<I2n::clock::Time> untimely = boost::none;
1209
1210 this->set_utc ();
1211
1212 untimely = I2n::clock::time_of_iso8601 (timeless, false, true, false);
1213
1214# if LONG_BIT == 32
1215 BOOST_CHECK(!untimely);
1216# else
1217 BOOST_CHECK(untimely);
1218 BOOST_CHECK_EQUAL(*untimely->format_iso8601 (true, false, true, false),
1219 timeless);
1220# endif
1221 }
1222
1223 BOOST_AUTO_TEST_CASE(Ctor_32bit_time_t_err)
1224 {
1225 boost::optional<std::string> threw = boost::none;
1226
1227 struct tm tm;
1228 memset (&tm, 0, sizeof (tm));
1229
1230 tm.tm_sec = 11;
1231 tm.tm_min = 11;
1232 tm.tm_hour = 11;
1233 tm.tm_mday = 11;
1234 tm.tm_mon = 10;
1235 tm.tm_year = -789;
1236 tm.tm_gmtoff = 0;
1237
1238 try {
1239 I2n::clock::Time untimely (tm);
1240 } catch (I2n::clock::conversion_error &exn) {
1241 threw = std::string (exn);
1242 }
1243
1244
1245# if LONG_BIT == 32
1246 BOOST_CHECK_EQUAL(*threw,
1247 "errno=0 [mktime: from struct tm {Sun Nov 11 11:11:11 1111}]");
1248# else
1249 BOOST_CHECK(!threw);
1250# endif
1251 }
1252
1253 BOOST_AUTO_TEST_CASE(containers_list)
1254 {
1255 std::list<I2n::clock::Time> ts;
1256
1257 ts.push_back (I2n::clock::zero ());
1258 ts.push_back (I2n::clock::zero ());
1259
1260 BOOST_CHECK_EQUAL(ts.size (), 2);
1261 }
1262
1263 BOOST_AUTO_TEST_CASE(containers_vec)
1264 {
1265 std::vector<I2n::clock::Time> ts;
1266
1267 ts.push_back (I2n::clock::zero ());
1268 ts.push_back (I2n::clock::zero ());
1269
1270 BOOST_CHECK_EQUAL(ts.size (), 2);
1271 }
1272
1273 BOOST_AUTO_TEST_CASE(containers_set)
1274 {
1275 std::set<I2n::clock::Time> ts;
1276
1277 ts.insert (I2n::clock::zero ());
1278 ts.insert (I2n::clock::Time (42, 2187));
1279 ts.insert (I2n::clock::zero ());
1280
1281 BOOST_CHECK_EQUAL(ts.size (), 2);
1282 }
1283
1284 BOOST_AUTO_TEST_CASE(containers_list_mean)
1285 {
1286 std::list<I2n::clock::Time> ts;
1287
1288 ts.push_back (I2n::clock::Time (42, 42));
1289 ts.push_back (I2n::clock::Time (1337, 1337));
1290
1291 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1292 I2n::clock::Time (689, 500000689));
1293 }
1294
1295 BOOST_AUTO_TEST_CASE(containers_list_mean_zero)
1296 {
1297 std::list<I2n::clock::Time> ts;
1298
1299 ts.push_back (I2n::clock::Time (0, 0));
1300 ts.push_back (I2n::clock::Time (0, 0));
1301 ts.push_back (I2n::clock::Time (0, 0));
1302 ts.push_back (I2n::clock::Time (0, 0));
1303
1304 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1305 I2n::clock::zero ());
1306 }
1307
1308 BOOST_AUTO_TEST_CASE(containers_list_mean_empty)
1309 {
1310 std::list<I2n::clock::Time> ts;
1311
1312 BOOST_CHECK_EQUAL(I2n::clock::mean (ts), I2n::clock::Time (0, 0));
1313 }
1314
1315 BOOST_AUTO_TEST_CASE(containers_set_mean)
1316 {
1317 std::set<I2n::clock::Time> ts;
1318
1319 ts.insert (I2n::clock::Time (42));
1320 ts.insert (I2n::clock::Time (1337));
1321 ts.insert (I2n::clock::Time (2187));
1322
1323 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1324 I2n::clock::Time (1188, 666666666));
1325 }
1326
1327 BOOST_AUTO_TEST_CASE(containers_set_median_empty)
1328 {
1329 std::set<I2n::clock::Time> ts;
1330
1331 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0, 0));
1332 }
1333
1334 BOOST_AUTO_TEST_CASE(containers_set_median_one)
1335 {
1336 std::set<I2n::clock::Time> ts;
1337
1338 ts.insert (I2n::clock::Time (42, 0));
1339
1340 BOOST_CHECK_EQUAL(I2n::clock::median (ts),
1341 I2n::clock::Time (42, 0));
1342 }
1343
1344 BOOST_AUTO_TEST_CASE(containers_set_median_multi)
1345 {
1346 std::set<I2n::clock::Time> ts;
1347
1348 ts.insert (I2n::clock::Time (42));
1349 ts.insert (I2n::clock::Time (1337));
1350 ts.insert (I2n::clock::Time (2187));
1351
1352 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1353 }
1354
1355 BOOST_AUTO_TEST_CASE(containers_vec_median_multi)
1356 {
1357 std::vector<I2n::clock::Time> ts;
1358
1359 ts.push_back (I2n::clock::Time (42));
1360 ts.push_back (I2n::clock::Time (1337));
1361 ts.push_back (I2n::clock::Time (2187));
1362
1363 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1364 }
1365
1366 BOOST_AUTO_TEST_CASE(containers_list_median_multi)
1367 {
1368 std::list<I2n::clock::Time> ts;
1369
1370 ts.push_back (I2n::clock::Time (42));
1371 ts.push_back (I2n::clock::Time (1337));
1372 ts.push_back (I2n::clock::Time (2187));
1373 ts.push_back (I2n::clock::Time (0xdead));
1374 ts.push_back (I2n::clock::Time (0xbeef));
1375
1376 BOOST_CHECK_EQUAL(I2n::clock::median (ts),
1377 I2n::clock::Time (2187));
1378 }
1379
1380 BOOST_AUTO_TEST_CASE(containers_list_median_multi_evensize)
1381 {
1382 std::list<I2n::clock::Time> ts;
1383
1384 ts.push_back (I2n::clock::Time (42));
1385 ts.push_back (I2n::clock::Time (1337));
1386 ts.push_back (I2n::clock::Time (2187));
1387 ts.push_back (I2n::clock::Time (0xf00d));
1388 ts.push_back (I2n::clock::Time (0xfeed));
1389 ts.push_back (I2n::clock::Time (0xdeadf0e));
1390
1391 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0xf00d));
1392 }
1393
1394BOOST_AUTO_TEST_SUITE_END() /* [Clock] */
1395
1396BOOST_AUTO_TEST_SUITE_END()
libi2ncommon: Common functions used in Intra2net programs