2 The software in this package is distributed under the GNU General
3 Public License version 2 (with a special exception described below).
5 A copy of GNU General Public License (GPL) is included in this distribution,
6 in the file COPYING.GPL.
8 As a special exception, if other files instantiate templates or use macros
9 or inline functions from this file, or you compile this file and link it
10 with other works to produce a work based on this file, this file
11 does not by itself cause the resulting work to be covered
12 by the GNU General Public License.
14 However the source code for this file must still be made available
15 in accordance with section (3) of the GNU General Public License.
17 This exception does not invalidate any other reasons why a work based
18 on this file might be covered by the GNU General Public License.
21 * @brief unit test for time related functions.
23 * @copyright Copyright © 2001-2008 by Intra2net AG
27 #define BOOST_TEST_DYN_LINK
28 #include <boost/test/unit_test.hpp>
30 #include <timefunc.hxx>
31 #include <filefunc.hxx>
38 using namespace I2n::Time;
40 class TestTimeFuncFixture
43 typedef std::list< std::string > StringList;
44 std::set<std::string> used_check_files;
46 std::string get_check_file_path(std::string tag)
49 result= "__unittest__" + tag + ".dat";
50 used_check_files.insert(result);
52 } // eo get_check_file_path
54 void remove_check_files()
56 for (std::set<std::string>::iterator it= used_check_files.begin();
57 it != used_check_files.end();
60 std::string filepath(*it);
61 if (path_exists(filepath))
67 used_check_files.clear();
68 } // eo remove_check_files
75 ~TestTimeFuncFixture()
81 BOOST_FIXTURE_TEST_SUITE(TestTimeFunc, TestTimeFuncFixture)
83 BOOST_AUTO_TEST_CASE(AddIntervalsDisjoint)
87 intervals.add( Interval( 10, 100 ) );
88 intervals.add( Interval( 600, 620 ) );
90 BOOST_CHECK_EQUAL( false, intervals.empty() );
91 BOOST_CHECK_EQUAL( 2u, intervals.size() );
93 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
94 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
96 BOOST_CHECK_EQUAL( 600u, intervals.back().lower_bound() );
97 BOOST_CHECK_EQUAL( 620u, intervals.back().upper_bound() );
98 } // eo AddIntervalsDisjoint()
102 BOOST_AUTO_TEST_CASE(AddIntervalsInclude)
106 intervals.add( Interval( 10, 100 ) );
107 intervals.add( Interval( 10, 80 ) );
109 BOOST_CHECK_EQUAL( false, intervals.empty() );
110 BOOST_CHECK_EQUAL( 1u, intervals.size() );
112 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
113 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
114 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
115 } // eo AddIntervalsInclude()
119 BOOST_AUTO_TEST_CASE(AddIntervalsEmbrace)
123 intervals.add( Interval( 10, 100 ) );
124 intervals.add( Interval( 5, 120 ) );
126 BOOST_CHECK_EQUAL( false, intervals.empty() );
127 BOOST_CHECK_EQUAL( 1u, intervals.size() );
129 BOOST_CHECK_EQUAL( 5u, intervals.front().lower_bound() );
130 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
131 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
132 } // eo AddIntervalsEmbrace()
136 BOOST_AUTO_TEST_CASE(AddIntervalsJoin1)
140 intervals.add( Interval( 10, 100 ) );
141 intervals.add( Interval( 60, 120 ) );
143 BOOST_CHECK_EQUAL( false, intervals.empty() );
144 BOOST_CHECK_EQUAL( 1u, intervals.size() );
146 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
147 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
148 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
149 } // eo AddIntervalsJoin1()
153 BOOST_AUTO_TEST_CASE(AddIntervalsJoin1b)
157 intervals.add( Interval( 10, 100 ) );
158 intervals.add( Interval( 100, 120 ) );
160 BOOST_CHECK_EQUAL( false, intervals.empty() );
161 BOOST_CHECK_EQUAL( 1u, intervals.size() );
163 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
164 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
165 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
166 } // eo AddIntervalsJoin1b()
170 BOOST_AUTO_TEST_CASE(AddIntervalsJoin2)
174 intervals.add( Interval( 10, 100 ) );
175 intervals.add( Interval( 200, 250 ) );
177 BOOST_CHECK_EQUAL( false, intervals.empty() );
178 BOOST_CHECK_EQUAL( 2u, intervals.size() );
180 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
181 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
182 BOOST_CHECK_EQUAL( 200u, intervals.back().lower_bound() );
183 BOOST_CHECK_EQUAL( 250u, intervals.back().upper_bound() );
185 // now add the gap; the intervals should collapse to one covering all:
186 intervals.add( Interval(100, 200) );
188 BOOST_CHECK_EQUAL( false, intervals.empty() );
189 BOOST_CHECK_EQUAL( 1u, intervals.size() );
191 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
192 BOOST_CHECK_EQUAL( 250u, intervals.front().upper_bound() );
193 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
194 } // eo AddIntervalsJoin2()
198 BOOST_AUTO_TEST_CASE(SubIntervalsDisjoint)
202 intervals.add( Interval(10, 100) );
203 intervals.sub( Interval(0, 10) );
205 BOOST_CHECK_EQUAL( false, intervals.empty() );
206 BOOST_CHECK_EQUAL( 1u, intervals.size() );
208 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
209 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
210 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
211 } // eo SubIntervalsDisjoint()
215 BOOST_AUTO_TEST_CASE(SubIntervalsExact)
219 intervals.add( Interval(10, 100) );
220 intervals.sub( Interval(10, 100) );
222 BOOST_CHECK_EQUAL( true, intervals.empty() );
223 BOOST_CHECK_EQUAL( 0u, intervals.size() );
224 } // eo SubIntervalsExact()
228 BOOST_AUTO_TEST_CASE(SubIntervalsSplit1)
232 intervals.add( Interval(10, 100) );
233 intervals.sub( Interval(20, 40) );
235 BOOST_CHECK_EQUAL( false, intervals.empty() );
236 BOOST_CHECK_EQUAL( 2u, intervals.size() );
238 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
239 BOOST_CHECK_EQUAL( 20u, intervals.front().upper_bound() );
241 BOOST_CHECK_EQUAL( 40u, intervals.back().lower_bound() );
242 BOOST_CHECK_EQUAL( 100u, intervals.back().upper_bound() );
243 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
244 BOOST_CHECK_EQUAL( true, intervals.back().changed() );
245 } // eo SubIntervalsSplit1()
248 BOOST_AUTO_TEST_CASE(SubIntervalsCutFront)
252 intervals.add( Interval(10, 100) );
253 intervals.sub( Interval(10, 20) );
255 BOOST_CHECK_EQUAL( false, intervals.empty() );
256 BOOST_CHECK_EQUAL( 1u, intervals.size() );
258 BOOST_CHECK_EQUAL( 20u, intervals.front().lower_bound() );
259 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
260 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
261 } // eo SubIntervalsCutFront()
264 BOOST_AUTO_TEST_CASE(SubIntervalsCutBack)
268 intervals.add( Interval(10, 100) );
269 intervals.sub( Interval(87, 100) );
271 BOOST_CHECK_EQUAL( false, intervals.empty() );
272 BOOST_CHECK_EQUAL( 1u, intervals.size() );
274 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
275 BOOST_CHECK_EQUAL( 87u, intervals.front().upper_bound() );
276 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
277 } // eo SubIntervalsCutBack()
281 BOOST_AUTO_TEST_CASE(SubIntervalsCutMore)
285 intervals.add( Interval( 10, 100) );
286 intervals.add( Interval(110, 200) );
287 intervals.add( Interval(210, 300) );
289 // this should remove the first 2 intervals and cut the third:
290 intervals.sub( Interval(8, 220) );
292 BOOST_CHECK_EQUAL( false, intervals.empty() );
293 BOOST_CHECK_EQUAL( 1u, intervals.size() );
295 BOOST_CHECK_EQUAL( 220u, intervals.front().lower_bound() );
296 BOOST_CHECK_EQUAL( 300u, intervals.front().upper_bound() );
297 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
298 } // eo SubIntervalsCutMore()
301 BOOST_AUTO_TEST_CASE(IntervalComparisons)
303 Intervals intervals1;
304 Intervals intervals2;
306 intervals1.add( Interval( 10, 120) );
308 intervals2.add( Interval( 10, 110 ) );
309 intervals2.add( Interval( 100, 120 ) );
311 BOOST_CHECK_EQUAL( 1u, intervals2.size() );
313 BOOST_CHECK( intervals1 == intervals2 );
314 BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
315 BOOST_CHECK_EQUAL( true, intervals2.contains( intervals1 ));
317 intervals2.sub( Interval( 40, 50) );
319 BOOST_CHECK( intervals1 != intervals2 );
320 BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
321 BOOST_CHECK_EQUAL( false, intervals2.contains( intervals1 ));
322 } // eo IntervalComparisons()
326 BOOST_AUTO_TEST_CASE(MonotonicClock)
331 bool res = monotonic_clock_gettime(sec0,nsec0);
332 BOOST_CHECK_EQUAL( true, res );
335 res= monotonic_clock_gettime(sec1,nsec1);
336 BOOST_CHECK_EQUAL( true, res);
338 long delta_sec = sec1 - sec0;
339 long delta_nsec= nsec1 - nsec0;
341 long delta_millisec= ( delta_nsec / 1000000L) + delta_sec * 1000L;
343 BOOST_CHECK( delta_millisec >= 250 - /*fuzz*/ 1);
344 BOOST_CHECK( delta_millisec < 300 );
345 } // eo MonotonicClock()
347 BOOST_AUTO_TEST_CASE(WeekInvalid)
349 Week week("99999999");
350 BOOST_CHECK_EQUAL(false, week.is_valid());
351 BOOST_CHECK_EQUAL(string(""), week.get_displaystring());
354 BOOST_AUTO_TEST_CASE(WeekDisplayString1)
357 BOOST_CHECK_EQUAL(true, week.is_valid());
358 BOOST_CHECK_EQUAL(string(""), week.get_displaystring());
361 BOOST_AUTO_TEST_CASE(WeekDisplayString2)
363 Week week("0123456");
364 BOOST_CHECK_EQUAL(true, week.is_valid());
365 BOOST_CHECK_EQUAL(string("Mon-Sun"), week.get_displaystring());
368 BOOST_AUTO_TEST_CASE(WeekDisplayString3)
371 BOOST_CHECK_EQUAL(true, week.is_valid());
372 BOOST_CHECK_EQUAL(string("Mon-Sat"), week.get_displaystring());
375 BOOST_AUTO_TEST_CASE(WeekDisplayString4)
378 BOOST_CHECK_EQUAL(true, week.is_valid());
379 BOOST_CHECK_EQUAL(string("Mon-Fri, Sun"), week.get_displaystring());
382 BOOST_AUTO_TEST_CASE(WeekDisplayString5)
385 BOOST_CHECK_EQUAL(true, week.is_valid());
386 BOOST_CHECK_EQUAL(string("Mon, Tue, Fri, Sat"), week.get_displaystring());
389 BOOST_AUTO_TEST_CASE(WeekDisplayString6)
392 BOOST_CHECK_EQUAL(true, week.is_valid());
393 BOOST_CHECK_EQUAL(string("Tue, Thu, Sat, Sun"), week.get_displaystring());
396 BOOST_AUTO_TEST_CASE(WeekDisplayString7)
399 BOOST_CHECK_EQUAL(true, week.is_valid());
400 BOOST_CHECK_EQUAL(string("Mon, Wed, Fri"), week.get_displaystring());
403 BOOST_AUTO_TEST_CASE(WeekDisplayString8)
406 BOOST_CHECK_EQUAL(true, week.is_valid());
407 BOOST_CHECK_EQUAL(string("Mon, Fri"), week.get_displaystring());
410 BOOST_AUTO_TEST_CASE(WeekDisplayString9)
413 BOOST_CHECK_EQUAL(true, week.is_valid());
414 BOOST_CHECK_EQUAL(string("Sat, Sun"), week.get_displaystring());
417 BOOST_AUTO_TEST_CASE(WeekDisplayString10)
420 BOOST_CHECK_EQUAL(true, week.is_valid());
421 BOOST_CHECK_EQUAL(string("Fri-Sun"), week.get_displaystring());
424 BOOST_AUTO_TEST_CASE(WeekDisplayString11)
427 BOOST_CHECK_EQUAL(true, week.is_valid());
428 BOOST_CHECK_EQUAL(string("Sun"), week.get_displaystring());
431 BOOST_AUTO_TEST_CASE(WeekDisplayString12)
434 BOOST_CHECK_EQUAL(true, week.is_valid());
435 BOOST_CHECK_EQUAL(string("Sat"), week.get_displaystring());
438 BOOST_AUTO_TEST_CASE(WeekDisplayString13)
441 BOOST_CHECK_EQUAL(true, week.is_valid());
442 BOOST_CHECK_EQUAL(string("Mon-Wed"), week.get_displaystring());
445 BOOST_AUTO_TEST_CASE(FormatFullTime)
447 time_t seconds = 1318844005;
449 BOOST_CHECK_EQUAL("17.10.2011 11:33", format_full_time(seconds));
452 BOOST_AUTO_TEST_CASE(DateToSeconds1)
455 BOOST_CHECK_EQUAL(1325372400, date_to_seconds("2012-01-01"));
458 BOOST_AUTO_TEST_CASE(DateToSeconds2)
461 BOOST_CHECK_EQUAL(1341093600, date_to_seconds("2012-07-01"));
464 BOOST_AUTO_TEST_CASE(FormatISO8601_T)
466 const time_t moment = 1515492684;
467 BOOST_CHECK_EQUAL("10:11:24",
468 format_iso8601 (moment, true, false, true, false));
471 BOOST_AUTO_TEST_CASE(FormatISO8601_TZ_local)
473 const time_t moment = 1515492684;
474 BOOST_CHECK_EQUAL("11:11:24Z+0100",
475 format_iso8601 (moment, false, false, true, true));
478 BOOST_AUTO_TEST_CASE(FormatISO8601_TZ)
480 const time_t moment = 1515492684;
481 BOOST_CHECK_EQUAL("10:11:24Z+0000",
482 format_iso8601 (moment, true, false, true, true));
485 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_local)
487 const time_t moment = 1515492684;
488 BOOST_CHECK_EQUAL("2018-01-09T11:11:24Z+0100",
489 format_iso8601 (moment, false, true, true, true));
492 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ)
494 const time_t moment = 1515492684;
495 BOOST_CHECK_EQUAL("2018-01-09T10:11:24Z+0000",
496 format_iso8601 (moment, true, true, true, true));
499 BOOST_AUTO_TEST_CASE(FormatISO8601_DT)
501 const time_t moment = 1515492684;
502 BOOST_CHECK_EQUAL("2018-01-09T10:11:24",
503 format_iso8601 (moment, true, true, true, false));
506 BOOST_AUTO_TEST_CASE(FormatISO8601_D)
508 const time_t moment = 1515492684;
509 BOOST_CHECK_EQUAL("2018-01-09",
510 format_iso8601 (moment, true, true, false, false));
513 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_struct_tm)
521 helau.tm_year = 2018 - 1900;
526 helau.tm_zone = NULL;
528 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000",
529 format_iso8601 (helau, true, true, true));
532 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_struct_timespec)
534 struct timespec ts = { 1541934671, 11 };
536 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000",
537 format_iso8601 (ts, true, true, true, true));
540 BOOST_AUTO_TEST_SUITE(Clock)
542 BOOST_AUTO_TEST_CASE(ctor_simple)
546 BOOST_CHECK_EQUAL(t.get_sec (), 0);
547 BOOST_CHECK_EQUAL(t.get_nsec (), 0);
550 BOOST_AUTO_TEST_CASE(ctor_type)
552 I2n::clock::Time t (I2n::clock::type::real);
554 BOOST_CHECK_EQUAL(t.get_sec (), 0);
555 BOOST_CHECK_EQUAL(t.get_nsec (), 0);
558 BOOST_AUTO_TEST_CASE(ctor_variant)
560 I2n::clock::Time t (I2n::clock::type::cpu,
561 I2n::clock::type::thread);
563 BOOST_CHECK_EQUAL(t.get_sec (), 0);
564 BOOST_CHECK_EQUAL(t.get_nsec (), 0);
567 BOOST_AUTO_TEST_CASE(initializer_now)
569 boost::optional<I2n::clock::Time> t = I2n::clock::now ();
572 BOOST_CHECK_GT(t->get_sec (), 0);
573 BOOST_CHECK_EQUAL(t->err, 0);
576 BOOST_AUTO_TEST_CASE(initializer_zero)
578 I2n::clock::Time stundenull = I2n::clock::zero ();
580 BOOST_CHECK_EQUAL(stundenull.get_sec (), 0);
581 BOOST_CHECK_EQUAL(stundenull.get_nsec (), 0);
582 BOOST_CHECK_EQUAL(stundenull.err, 0);
585 BOOST_AUTO_TEST_CASE(member_set_now)
589 BOOST_CHECK(t.set ());
591 BOOST_CHECK_NE(t.get_sec (), 0);
594 BOOST_AUTO_TEST_CASE(member_set_value)
600 BOOST_CHECK_EQUAL(t.get_sec (), 42);
601 BOOST_CHECK_EQUAL(t.get_nsec (), 42);
604 BOOST_AUTO_TEST_CASE(member_set_value_type)
608 t.set (42, 42, I2n::clock::type::real, I2n::clock::type::exact);
610 BOOST_CHECK_EQUAL(t.get_sec (), 42);
611 BOOST_CHECK_EQUAL(t.get_nsec (), 42);
614 BOOST_AUTO_TEST_CASE(member_add_parts)
621 BOOST_CHECK_EQUAL(t.get_sec (), 2229);
622 BOOST_CHECK_EQUAL(t.get_nsec (), 2229);
625 BOOST_AUTO_TEST_CASE(member_sub_parts)
632 BOOST_CHECK_EQUAL(t.get_sec (), 0);
633 BOOST_CHECK_EQUAL(t.get_nsec (), 999999999);
636 BOOST_AUTO_TEST_CASE(member_sub_Time)
646 BOOST_CHECK_EQUAL(t1.get_sec (), 0);
647 BOOST_CHECK_EQUAL(t1.get_nsec (), 42L);
650 BOOST_AUTO_TEST_CASE(member_diff)
652 static const time_t five = 5 * 365 * 24 * 3600;
654 I2n::clock::Time t1 (42, 1337);
655 I2n::clock::Time t2 = t1 + five;;
656 I2n::clock::Time t3 = t1 - five;;
658 BOOST_CHECK_EQUAL(t2, I2n::clock::Time ((time_t)42 + five, 1337));
659 BOOST_CHECK_EQUAL(t3, I2n::clock::Time ((time_t)42 - five, 1337));
660 BOOST_CHECK_EQUAL(t1.difference (t3), t3.difference (t1));
661 BOOST_CHECK_EQUAL(t3.difference (t3), t3.difference (t3));
664 BOOST_AUTO_TEST_CASE(op_copyassign)
669 BOOST_CHECK(t1.set ());
673 BOOST_CHECK_EQUAL(t1.get_sec (), t2.get_sec ());
674 BOOST_CHECK_EQUAL(t1.get_nsec (), t2.get_nsec ());
677 BOOST_AUTO_TEST_CASE(op_equal)
682 BOOST_CHECK(t1.set ());
685 BOOST_CHECK_EQUAL(t1, t2);
688 BOOST_AUTO_TEST_CASE(op_add_Time)
692 I2n::clock::Time tsum;
698 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
699 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
702 BOOST_AUTO_TEST_CASE(op_add_Time_carry)
706 I2n::clock::Time tsum;
709 t2.set (1300, 37L * 1000 * 1000 * 1000 + 1337);
713 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
714 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
717 BOOST_AUTO_TEST_CASE(op_add_time_t)
719 I2n::clock::Time t1 (2187, 2187);
721 I2n::clock::Time tsum;
725 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
726 BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
729 BOOST_AUTO_TEST_CASE(op_add_time_t_external)
732 I2n::clock::Time t2 (2187, 2187);
733 I2n::clock::Time tsum;
737 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
738 BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
741 BOOST_AUTO_TEST_CASE(op_incr_Time)
743 I2n::clock::Time t1 (2187, 2187);
744 I2n::clock::Time t2 (1337, 1337);
748 BOOST_CHECK_EQUAL(t1.get_sec (), 3524);
749 BOOST_CHECK_EQUAL(t1.get_nsec (), 3524);
752 BOOST_AUTO_TEST_CASE(op_incr_time_t)
754 I2n::clock::Time t1 (2187, 2187);
759 BOOST_CHECK_EQUAL(t1.get_sec (), 3524);
760 BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
763 BOOST_AUTO_TEST_CASE(op_subtract_Time)
767 I2n::clock::Time tdiff;
773 BOOST_CHECK_EQUAL(tdiff.get_sec (), 850);
774 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 850);
777 BOOST_AUTO_TEST_CASE(op_subtract_time_t)
779 I2n::clock::Time t1 (2187, 2187);
781 I2n::clock::Time tdiff;
785 BOOST_CHECK_EQUAL(tdiff.get_sec (), 850);
786 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 2187);
789 BOOST_AUTO_TEST_CASE(op_subtract_time_t_external)
792 I2n::clock::Time t2 (2187, 2187);
793 I2n::clock::Time tdiff;
797 BOOST_CHECK_EQUAL(tdiff.get_sec (), -851);
798 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 999997813);
801 BOOST_AUTO_TEST_CASE(op_decr_Time)
803 I2n::clock::Time t1 (2187, 2187);
804 I2n::clock::Time t2 (1337, 1337);
808 BOOST_CHECK_EQUAL(t1.get_sec (), 850);
809 BOOST_CHECK_EQUAL(t1.get_nsec (), 850);
812 BOOST_AUTO_TEST_CASE(op_decr_time_t)
814 I2n::clock::Time t1 (2187, 2187);
819 BOOST_CHECK_EQUAL(t1.get_sec (), 850);
820 BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
823 BOOST_AUTO_TEST_CASE(op_mult_scale)
831 BOOST_CHECK_EQUAL(t2.get_sec (), 42);
832 BOOST_CHECK_EQUAL(t2.get_nsec (), 42);
835 BOOST_AUTO_TEST_CASE(op_mult_mutate)
837 I2n::clock::Time t1 ( 42, 42);
838 I2n::clock::Time t2 (1337, 0);
843 BOOST_CHECK_EQUAL(t1.get_sec (), 84);
844 BOOST_CHECK_EQUAL(t1.get_nsec (), 84);
845 BOOST_CHECK_EQUAL(t2.get_sec (), -13370);
848 BOOST_AUTO_TEST_CASE(op_mult_scale_carry)
853 t1.set (1, 500 * 1000 * 1000);
856 BOOST_CHECK_EQUAL(t2.get_sec (), 4);
857 BOOST_CHECK_EQUAL(t2.get_nsec (), 500 * 1000 * 1000);
860 BOOST_AUTO_TEST_CASE(op_equals)
868 BOOST_CHECK_EQUAL(t1, t2);
871 BOOST_AUTO_TEST_CASE(compare_equal)
879 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), 0);
882 BOOST_AUTO_TEST_CASE(compare_equal_type)
884 I2n::clock::Time t1 (42, 42, I2n::clock::type::real);
885 I2n::clock::Time t2 (42, 42, I2n::clock::type::cpu);
886 I2n::clock::Time t3 (42, 0, I2n::clock::type::real);
887 I2n::clock::Time t4 (42, 42, I2n::clock::type::real);
889 BOOST_CHECK_NE(t1, t2);
890 BOOST_CHECK_NE(t1, t3);
891 BOOST_CHECK_EQUAL(t1, t4);
894 BOOST_AUTO_TEST_CASE(compare_ne_sec)
902 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
903 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), 1);
906 BOOST_AUTO_TEST_CASE(compare_ne_nsec)
914 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
915 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), 1);
918 BOOST_AUTO_TEST_CASE(compare_ne_both)
926 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), 1);
927 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), -1);
930 BOOST_AUTO_TEST_CASE(op_ineq_sec)
932 I2n::clock::Time t1 (1337);
933 I2n::clock::Time t2 (2187);
935 BOOST_CHECK_LT(t1, t2);
936 BOOST_CHECK_GT(t2, t1);
939 BOOST_AUTO_TEST_CASE(op_ineq_nsec)
941 I2n::clock::Time t1 (1337, 23);
942 I2n::clock::Time t2 (1337, 42);
944 BOOST_CHECK_LT(t1, t2);
945 BOOST_CHECK_GT(t2, t1);
948 BOOST_AUTO_TEST_CASE(op_ineq_both)
950 I2n::clock::Time t1 (2187, 23);
951 I2n::clock::Time t2 (1337, 42);
953 BOOST_CHECK_LT(t2, t1);
954 BOOST_CHECK_GT(t1, t2);
957 BOOST_AUTO_TEST_CASE(op_eq_time_t)
959 boost::optional<I2n::clock::Time> t1 = I2n::clock::now ();
960 const time_t t2 = time (NULL); /* race here */
964 BOOST_CHECK_NE(*t1, t2);
965 BOOST_CHECK_LT(*t1, t2);
966 BOOST_CHECK_GT( t2, *t1);
969 BOOST_AUTO_TEST_CASE(FormatISO8601_T)
971 I2n::clock::Time t (42, 42);
972 boost::optional<std::string> s = t.format_iso8601 (true, false, true, false);
974 BOOST_CHECK_EQUAL("00:00:42", *s);
977 BOOST_AUTO_TEST_CASE(FormatISO8601_DT)
979 I2n::clock::Time t (1541934671, 0);
980 boost::optional<std::string> s = t.format_iso8601 (true, true, true, false);
982 BOOST_CHECK_EQUAL("2018-11-11T11:11:11", *s);
985 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ)
987 I2n::clock::Time t (1541934671, 0);
988 boost::optional<std::string> s = t.format_iso8601 (true, true, true, true);
990 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000", *s);
993 BOOST_AUTO_TEST_CASE(Format_make_nice_time)
995 I2n::clock::Time t (111111, 0);
996 boost::optional<std::string> s = t.make_nice_time ();
998 BOOST_CHECK_EQUAL("1 day, 06:51:51", *s);
1001 BOOST_AUTO_TEST_CASE(Format_format_full_time)
1003 I2n::clock::Time t (1541934671, 0);
1005 * brr, the old formatters use localtime without a way to opt out of
1008 setenv ("TZ", "UTC", 1);
1010 boost::optional<std::string> s = t.format_full_time ();
1012 BOOST_CHECK_EQUAL("11.11.2018 11:11", *s);
1015 BOOST_AUTO_TEST_CASE(Format_format_date)
1017 I2n::clock::Time t (1541934671, 0);
1018 boost::optional<std::string> s = t.format_date ();
1020 BOOST_CHECK_EQUAL("11.11.2018", *s);
1023 BOOST_AUTO_TEST_CASE(FromString_iso8601_full)
1025 const std::string in1 ("0001-01-01T00:00:00Z+0000");
1026 const std::string in2 ("2018-11-11T11:11:11Z+0000");
1028 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1029 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1034 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
1035 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
1038 BOOST_AUTO_TEST_CASE(FromString_iso8601_full_negyear)
1040 const std::string in1 ("-0001-01-01T00:00:00Z+0000");
1041 const std::string in2 ("-2018-11-11T11:11:11Z+0000");
1043 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1044 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1049 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
1050 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
1053 BOOST_AUTO_TEST_CASE(FromString_iso8601_partial)
1055 const std::string in1 ("2018-11-11T11:11:11");
1056 const std::string in2 ("2018-11-11");
1057 const std::string in3 ("11:11:11");
1059 boost::optional<I2n::clock::Time> t1 =
1060 I2n::clock::time_of_iso8601 (in1, true, true, false);
1061 boost::optional<I2n::clock::Time> t2 =
1062 I2n::clock::time_of_iso8601 (in2, true, false, false);
1063 boost::optional<I2n::clock::Time> t3 =
1064 I2n::clock::time_of_iso8601 (in3, false, true, false);
1070 * We test for the difference here which is zero if the number is
1071 * correct but causes the difference from the expected value to be
1072 * printed in case the test fails.
1074 BOOST_CHECK_EQUAL(*t1->format_iso8601 (true, true, true, false), in1);
1075 BOOST_CHECK_EQUAL(*t2->format_iso8601 (true, true, false, false), in2);
1076 BOOST_CHECK_EQUAL(*t3->format_iso8601 (true, false, true, false), in3);
1079 BOOST_AUTO_TEST_CASE(containers_list)
1081 std::list<I2n::clock::Time> ts;
1083 ts.push_back (I2n::clock::zero ());
1084 ts.push_back (I2n::clock::zero ());
1086 BOOST_CHECK_EQUAL(ts.size (), 2);
1089 BOOST_AUTO_TEST_CASE(containers_vec)
1091 std::vector<I2n::clock::Time> ts;
1093 ts.push_back (I2n::clock::zero ());
1094 ts.push_back (I2n::clock::zero ());
1096 BOOST_CHECK_EQUAL(ts.size (), 2);
1099 BOOST_AUTO_TEST_CASE(containers_set)
1101 std::set<I2n::clock::Time> ts;
1103 ts.insert (I2n::clock::zero ());
1104 ts.insert (I2n::clock::Time (42, 2187));
1105 ts.insert (I2n::clock::zero ());
1107 BOOST_CHECK_EQUAL(ts.size (), 2);
1110 BOOST_AUTO_TEST_CASE(containers_list_mean)
1112 std::list<I2n::clock::Time> ts;
1114 ts.push_back (I2n::clock::Time (42, 42));
1115 ts.push_back (I2n::clock::Time (1337, 1337));
1117 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1118 I2n::clock::Time (689, 500000689));
1121 BOOST_AUTO_TEST_CASE(containers_list_mean_zero)
1123 std::list<I2n::clock::Time> ts;
1125 ts.push_back (I2n::clock::Time (0, 0));
1126 ts.push_back (I2n::clock::Time (0, 0));
1127 ts.push_back (I2n::clock::Time (0, 0));
1128 ts.push_back (I2n::clock::Time (0, 0));
1130 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1131 I2n::clock::zero ());
1134 BOOST_AUTO_TEST_CASE(containers_list_mean_empty)
1136 std::list<I2n::clock::Time> ts;
1138 BOOST_CHECK_EQUAL(I2n::clock::mean (ts), I2n::clock::Time (0, 0));
1141 BOOST_AUTO_TEST_CASE(containers_set_mean)
1143 std::set<I2n::clock::Time> ts;
1145 ts.insert (I2n::clock::Time (42));
1146 ts.insert (I2n::clock::Time (1337));
1147 ts.insert (I2n::clock::Time (2187));
1149 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1150 I2n::clock::Time (1188, 666666666));
1153 BOOST_AUTO_TEST_CASE(containers_set_median_empty)
1155 std::set<I2n::clock::Time> ts;
1157 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0, 0));
1160 BOOST_AUTO_TEST_CASE(containers_set_median_one)
1162 std::set<I2n::clock::Time> ts;
1164 ts.insert (I2n::clock::Time (42, 0));
1166 BOOST_CHECK_EQUAL(I2n::clock::median (ts),
1167 I2n::clock::Time (42, 0));
1170 BOOST_AUTO_TEST_CASE(containers_set_median_multi)
1172 std::set<I2n::clock::Time> ts;
1174 ts.insert (I2n::clock::Time (42));
1175 ts.insert (I2n::clock::Time (1337));
1176 ts.insert (I2n::clock::Time (2187));
1178 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1181 BOOST_AUTO_TEST_CASE(containers_vec_median_multi)
1183 std::vector<I2n::clock::Time> ts;
1185 ts.push_back (I2n::clock::Time (42));
1186 ts.push_back (I2n::clock::Time (1337));
1187 ts.push_back (I2n::clock::Time (2187));
1189 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1192 BOOST_AUTO_TEST_CASE(containers_list_median_multi)
1194 std::list<I2n::clock::Time> ts;
1196 ts.push_back (I2n::clock::Time (42));
1197 ts.push_back (I2n::clock::Time (1337));
1198 ts.push_back (I2n::clock::Time (2187));
1199 ts.push_back (I2n::clock::Time (0xcafebabe));
1200 ts.push_back (I2n::clock::Time (0xdeadbeef));
1202 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (2187));
1205 BOOST_AUTO_TEST_CASE(containers_list_median_multi_evensize)
1207 std::list<I2n::clock::Time> ts;
1209 ts.push_back (I2n::clock::Time (42));
1210 ts.push_back (I2n::clock::Time (1337));
1211 ts.push_back (I2n::clock::Time (2187));
1212 ts.push_back (I2n::clock::Time (0xf00d));
1213 ts.push_back (I2n::clock::Time (0xcafebabe));
1214 ts.push_back (I2n::clock::Time (0xdeadbeef));
1216 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0xf00d));
1219 BOOST_AUTO_TEST_SUITE_END() /* [Clock] */
1221 BOOST_AUTO_TEST_SUITE_END()