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>
39 using namespace I2n::Time;
41 class TestTimeFuncFixture
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 */
48 std::string get_check_file_path(std::string tag)
51 result= "__unittest__" + tag + ".dat";
52 used_check_files.insert(result);
54 } // eo get_check_file_path
56 void remove_check_files()
58 for (std::set<std::string>::iterator it= used_check_files.begin();
59 it != used_check_files.end();
62 std::string filepath(*it);
63 if (path_exists(filepath))
69 used_check_files.clear();
70 } // eo remove_check_files
72 void set_tz (const std::string &tzname)
75 if (setenv ("TZ", tzname.c_str (), 1) == -1)
78 << "error setting environment 'TZ': [" << tzname << "]"
87 inline void set_utc (void)
94 : tz (secure_getenv ("TZ") ?: "")
98 ~TestTimeFuncFixture()
100 remove_check_files();
103 if (setenv ("TZ", this->tz.c_str (), 1) == -1)
106 << "error cleaning up environment 'TZ': [" << this->tz << "]"
117 BOOST_FIXTURE_TEST_SUITE(TestTimeFunc, TestTimeFuncFixture)
119 BOOST_AUTO_TEST_CASE(AddIntervalsDisjoint)
123 intervals.add( Interval( 10, 100 ) );
124 intervals.add( Interval( 600, 620 ) );
126 BOOST_CHECK_EQUAL( false, intervals.empty() );
127 BOOST_CHECK_EQUAL( 2u, intervals.size() );
129 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
130 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
132 BOOST_CHECK_EQUAL( 600u, intervals.back().lower_bound() );
133 BOOST_CHECK_EQUAL( 620u, intervals.back().upper_bound() );
134 } // eo AddIntervalsDisjoint()
138 BOOST_AUTO_TEST_CASE(AddIntervalsInclude)
142 intervals.add( Interval( 10, 100 ) );
143 intervals.add( Interval( 10, 80 ) );
145 BOOST_CHECK_EQUAL( false, intervals.empty() );
146 BOOST_CHECK_EQUAL( 1u, intervals.size() );
148 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
149 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
150 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
151 } // eo AddIntervalsInclude()
155 BOOST_AUTO_TEST_CASE(AddIntervalsEmbrace)
159 intervals.add( Interval( 10, 100 ) );
160 intervals.add( Interval( 5, 120 ) );
162 BOOST_CHECK_EQUAL( false, intervals.empty() );
163 BOOST_CHECK_EQUAL( 1u, intervals.size() );
165 BOOST_CHECK_EQUAL( 5u, intervals.front().lower_bound() );
166 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
167 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
168 } // eo AddIntervalsEmbrace()
172 BOOST_AUTO_TEST_CASE(AddIntervalsJoin1)
176 intervals.add( Interval( 10, 100 ) );
177 intervals.add( Interval( 60, 120 ) );
179 BOOST_CHECK_EQUAL( false, intervals.empty() );
180 BOOST_CHECK_EQUAL( 1u, intervals.size() );
182 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
183 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
184 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
185 } // eo AddIntervalsJoin1()
189 BOOST_AUTO_TEST_CASE(AddIntervalsJoin1b)
193 intervals.add( Interval( 10, 100 ) );
194 intervals.add( Interval( 100, 120 ) );
196 BOOST_CHECK_EQUAL( false, intervals.empty() );
197 BOOST_CHECK_EQUAL( 1u, intervals.size() );
199 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
200 BOOST_CHECK_EQUAL( 120u, intervals.front().upper_bound() );
201 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
202 } // eo AddIntervalsJoin1b()
206 BOOST_AUTO_TEST_CASE(AddIntervalsJoin2)
210 intervals.add( Interval( 10, 100 ) );
211 intervals.add( Interval( 200, 250 ) );
213 BOOST_CHECK_EQUAL( false, intervals.empty() );
214 BOOST_CHECK_EQUAL( 2u, intervals.size() );
216 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
217 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
218 BOOST_CHECK_EQUAL( 200u, intervals.back().lower_bound() );
219 BOOST_CHECK_EQUAL( 250u, intervals.back().upper_bound() );
221 // now add the gap; the intervals should collapse to one covering all:
222 intervals.add( Interval(100, 200) );
224 BOOST_CHECK_EQUAL( false, intervals.empty() );
225 BOOST_CHECK_EQUAL( 1u, intervals.size() );
227 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
228 BOOST_CHECK_EQUAL( 250u, intervals.front().upper_bound() );
229 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
230 } // eo AddIntervalsJoin2()
234 BOOST_AUTO_TEST_CASE(SubIntervalsDisjoint)
238 intervals.add( Interval(10, 100) );
239 intervals.sub( Interval(0, 10) );
241 BOOST_CHECK_EQUAL( false, intervals.empty() );
242 BOOST_CHECK_EQUAL( 1u, intervals.size() );
244 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
245 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
246 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
247 } // eo SubIntervalsDisjoint()
251 BOOST_AUTO_TEST_CASE(SubIntervalsExact)
255 intervals.add( Interval(10, 100) );
256 intervals.sub( Interval(10, 100) );
258 BOOST_CHECK_EQUAL( true, intervals.empty() );
259 BOOST_CHECK_EQUAL( 0u, intervals.size() );
260 } // eo SubIntervalsExact()
264 BOOST_AUTO_TEST_CASE(SubIntervalsSplit1)
268 intervals.add( Interval(10, 100) );
269 intervals.sub( Interval(20, 40) );
271 BOOST_CHECK_EQUAL( false, intervals.empty() );
272 BOOST_CHECK_EQUAL( 2u, intervals.size() );
274 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
275 BOOST_CHECK_EQUAL( 20u, intervals.front().upper_bound() );
277 BOOST_CHECK_EQUAL( 40u, intervals.back().lower_bound() );
278 BOOST_CHECK_EQUAL( 100u, intervals.back().upper_bound() );
279 BOOST_CHECK_EQUAL( false, intervals.front().changed() );
280 BOOST_CHECK_EQUAL( true, intervals.back().changed() );
281 } // eo SubIntervalsSplit1()
284 BOOST_AUTO_TEST_CASE(SubIntervalsCutFront)
288 intervals.add( Interval(10, 100) );
289 intervals.sub( Interval(10, 20) );
291 BOOST_CHECK_EQUAL( false, intervals.empty() );
292 BOOST_CHECK_EQUAL( 1u, intervals.size() );
294 BOOST_CHECK_EQUAL( 20u, intervals.front().lower_bound() );
295 BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
296 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
297 } // eo SubIntervalsCutFront()
300 BOOST_AUTO_TEST_CASE(SubIntervalsCutBack)
304 intervals.add( Interval(10, 100) );
305 intervals.sub( Interval(87, 100) );
307 BOOST_CHECK_EQUAL( false, intervals.empty() );
308 BOOST_CHECK_EQUAL( 1u, intervals.size() );
310 BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
311 BOOST_CHECK_EQUAL( 87u, intervals.front().upper_bound() );
312 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
313 } // eo SubIntervalsCutBack()
317 BOOST_AUTO_TEST_CASE(SubIntervalsCutMore)
321 intervals.add( Interval( 10, 100) );
322 intervals.add( Interval(110, 200) );
323 intervals.add( Interval(210, 300) );
325 // this should remove the first 2 intervals and cut the third:
326 intervals.sub( Interval(8, 220) );
328 BOOST_CHECK_EQUAL( false, intervals.empty() );
329 BOOST_CHECK_EQUAL( 1u, intervals.size() );
331 BOOST_CHECK_EQUAL( 220u, intervals.front().lower_bound() );
332 BOOST_CHECK_EQUAL( 300u, intervals.front().upper_bound() );
333 BOOST_CHECK_EQUAL( true, intervals.front().changed() );
334 } // eo SubIntervalsCutMore()
337 BOOST_AUTO_TEST_CASE(IntervalComparisons)
339 Intervals intervals1;
340 Intervals intervals2;
342 intervals1.add( Interval( 10, 120) );
344 intervals2.add( Interval( 10, 110 ) );
345 intervals2.add( Interval( 100, 120 ) );
347 BOOST_CHECK_EQUAL( 1u, intervals2.size() );
349 BOOST_CHECK( intervals1 == intervals2 );
350 BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
351 BOOST_CHECK_EQUAL( true, intervals2.contains( intervals1 ));
353 intervals2.sub( Interval( 40, 50) );
355 BOOST_CHECK( intervals1 != intervals2 );
356 BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
357 BOOST_CHECK_EQUAL( false, intervals2.contains( intervals1 ));
358 } // eo IntervalComparisons()
362 BOOST_AUTO_TEST_CASE(MonotonicClock)
367 bool res = monotonic_clock_gettime(sec0,nsec0);
368 BOOST_CHECK_EQUAL( true, res );
371 res= monotonic_clock_gettime(sec1,nsec1);
372 BOOST_CHECK_EQUAL( true, res);
374 long delta_sec = sec1 - sec0;
375 long delta_nsec= nsec1 - nsec0;
377 long delta_millisec= ( delta_nsec / 1000000L) + delta_sec * 1000L;
379 BOOST_CHECK( delta_millisec >= 250 - /*fuzz*/ 1);
380 BOOST_CHECK( delta_millisec < 300 );
381 } // eo MonotonicClock()
383 BOOST_AUTO_TEST_CASE(WeekInvalid)
385 Week week("99999999");
386 BOOST_CHECK_EQUAL(false, week.is_valid());
387 BOOST_CHECK_EQUAL(string(""), week.get_displaystring());
390 BOOST_AUTO_TEST_CASE(WeekDisplayString1)
393 BOOST_CHECK_EQUAL(true, week.is_valid());
394 BOOST_CHECK_EQUAL(string(""), week.get_displaystring());
397 BOOST_AUTO_TEST_CASE(WeekDisplayString2)
399 Week week("0123456");
400 BOOST_CHECK_EQUAL(true, week.is_valid());
401 BOOST_CHECK_EQUAL(string("Mon-Sun"), week.get_displaystring());
404 BOOST_AUTO_TEST_CASE(WeekDisplayString3)
407 BOOST_CHECK_EQUAL(true, week.is_valid());
408 BOOST_CHECK_EQUAL(string("Mon-Sat"), week.get_displaystring());
411 BOOST_AUTO_TEST_CASE(WeekDisplayString4)
414 BOOST_CHECK_EQUAL(true, week.is_valid());
415 BOOST_CHECK_EQUAL(string("Mon-Fri, Sun"), week.get_displaystring());
418 BOOST_AUTO_TEST_CASE(WeekDisplayString5)
421 BOOST_CHECK_EQUAL(true, week.is_valid());
422 BOOST_CHECK_EQUAL(string("Mon, Tue, Fri, Sat"), week.get_displaystring());
425 BOOST_AUTO_TEST_CASE(WeekDisplayString6)
428 BOOST_CHECK_EQUAL(true, week.is_valid());
429 BOOST_CHECK_EQUAL(string("Tue, Thu, Sat, Sun"), week.get_displaystring());
432 BOOST_AUTO_TEST_CASE(WeekDisplayString7)
435 BOOST_CHECK_EQUAL(true, week.is_valid());
436 BOOST_CHECK_EQUAL(string("Mon, Wed, Fri"), week.get_displaystring());
439 BOOST_AUTO_TEST_CASE(WeekDisplayString8)
442 BOOST_CHECK_EQUAL(true, week.is_valid());
443 BOOST_CHECK_EQUAL(string("Mon, Fri"), week.get_displaystring());
446 BOOST_AUTO_TEST_CASE(WeekDisplayString9)
449 BOOST_CHECK_EQUAL(true, week.is_valid());
450 BOOST_CHECK_EQUAL(string("Sat, Sun"), week.get_displaystring());
453 BOOST_AUTO_TEST_CASE(WeekDisplayString10)
456 BOOST_CHECK_EQUAL(true, week.is_valid());
457 BOOST_CHECK_EQUAL(string("Fri-Sun"), week.get_displaystring());
460 BOOST_AUTO_TEST_CASE(WeekDisplayString11)
463 BOOST_CHECK_EQUAL(true, week.is_valid());
464 BOOST_CHECK_EQUAL(string("Sun"), week.get_displaystring());
467 BOOST_AUTO_TEST_CASE(WeekDisplayString12)
470 BOOST_CHECK_EQUAL(true, week.is_valid());
471 BOOST_CHECK_EQUAL(string("Sat"), week.get_displaystring());
474 BOOST_AUTO_TEST_CASE(WeekDisplayString13)
477 BOOST_CHECK_EQUAL(true, week.is_valid());
478 BOOST_CHECK_EQUAL(string("Mon-Wed"), week.get_displaystring());
481 BOOST_AUTO_TEST_CASE(FormatFullTime)
483 this->set_tz ("CET");
484 time_t seconds = 1318844005;
486 BOOST_CHECK_EQUAL("17.10.2011 11:33", format_full_time(seconds));
489 BOOST_AUTO_TEST_CASE(DateToSeconds1)
491 this->set_tz ("CET");
493 BOOST_CHECK_EQUAL(1325372400, date_to_seconds("2012-01-01"));
496 BOOST_AUTO_TEST_CASE(DateToSeconds2)
498 this->set_tz ("CET");
500 BOOST_CHECK_EQUAL(1341093600, date_to_seconds("2012-07-01"));
503 BOOST_AUTO_TEST_CASE(FormatISO8601_T)
505 const time_t moment = 1515492684;
506 BOOST_CHECK_EQUAL("10:11:24",
507 format_iso8601 (moment, true, false, true, false));
510 BOOST_AUTO_TEST_CASE(FormatISO8601_TZ_local)
512 this->set_tz ("CET");
513 const time_t moment = 1515492684;
514 BOOST_CHECK_EQUAL("11:11:24Z+0100",
515 format_iso8601 (moment, false, false, true, true));
518 BOOST_AUTO_TEST_CASE(FormatISO8601_TZ)
520 const time_t moment = 1515492684;
521 BOOST_CHECK_EQUAL("10:11:24Z+0000",
522 format_iso8601 (moment, true, false, true, true));
525 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_local)
527 this->set_tz ("CET");
528 const time_t moment = 1515492684;
529 BOOST_CHECK_EQUAL("2018-01-09T11:11:24Z+0100",
530 format_iso8601 (moment, false, true, true, true));
533 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ)
535 const time_t moment = 1515492684;
536 BOOST_CHECK_EQUAL("2018-01-09T10:11:24Z+0000",
537 format_iso8601 (moment, true, true, true, true));
540 BOOST_AUTO_TEST_CASE(FormatISO8601_DT)
542 const time_t moment = 1515492684;
543 BOOST_CHECK_EQUAL("2018-01-09T10:11:24",
544 format_iso8601 (moment, true, true, true, false));
547 BOOST_AUTO_TEST_CASE(FormatISO8601_D)
549 const time_t moment = 1515492684;
550 BOOST_CHECK_EQUAL("2018-01-09",
551 format_iso8601 (moment, true, true, false, false));
554 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_struct_tm)
562 helau.tm_year = 2018 - 1900;
567 helau.tm_zone = NULL;
569 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000",
570 format_iso8601 (helau, true, true, true));
573 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ_struct_timespec)
575 struct timespec ts = { 1541934671, 11 };
577 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000",
578 format_iso8601 (ts, true, true, true, true));
581 BOOST_AUTO_TEST_SUITE(Clock)
583 BOOST_AUTO_TEST_CASE(ctor_simple)
587 BOOST_CHECK_EQUAL(t.get_sec (), 0);
588 BOOST_CHECK_EQUAL(t.get_nsec (), 0);
591 BOOST_AUTO_TEST_CASE(ctor_type)
593 I2n::clock::Time t1 (I2n::clock::type::real);
594 I2n::clock::Time t2 (I2n::clock::type::mono);
595 I2n::clock::Time t3 (I2n::clock::type::boot);
596 I2n::clock::Time t4 (I2n::clock::type::cpu);
598 BOOST_CHECK_EQUAL(t1.get_sec (), 0);
599 BOOST_CHECK_EQUAL(t1.get_nsec (), 0);
601 BOOST_CHECK_EQUAL(t2.get_sec (), 0);
602 BOOST_CHECK_EQUAL(t2.get_nsec (), 0);
604 BOOST_CHECK_EQUAL(t3.get_sec (), 0);
605 BOOST_CHECK_EQUAL(t3.get_nsec (), 0);
607 BOOST_CHECK_EQUAL(t4.get_sec (), 0);
608 BOOST_CHECK_EQUAL(t4.get_nsec (), 0);
611 BOOST_AUTO_TEST_CASE(ctor_variant)
613 I2n::clock::Time tmc (I2n::clock::type::mono);
614 I2n::clock::Time tmr (I2n::clock::type::mono, I2n::clock::type::raw);
615 I2n::clock::Time tme (I2n::clock::type::mono, I2n::clock::type::exact);
617 I2n::clock::Time trc (I2n::clock::type::real);
618 I2n::clock::Time tre (I2n::clock::type::real, I2n::clock::type::exact);
620 I2n::clock::Time tb (I2n::clock::type::boot);
622 I2n::clock::Time tcp (I2n::clock::type::cpu);
623 I2n::clock::Time tct (I2n::clock::type::cpu, I2n::clock::type::thread);
625 BOOST_CHECK_EQUAL(tmc.get_sec (), 0); /* MONO */
626 BOOST_CHECK_EQUAL(tmc.get_nsec (), 0);
628 BOOST_CHECK_EQUAL(tmr.get_sec (), 0);
629 BOOST_CHECK_EQUAL(tmr.get_nsec (), 0);
631 BOOST_CHECK_EQUAL(tme.get_sec (), 0);
632 BOOST_CHECK_EQUAL(tme.get_nsec (), 0);
634 BOOST_CHECK_EQUAL(trc.get_sec (), 0); /* REAL */
635 BOOST_CHECK_EQUAL(trc.get_nsec (), 0);
637 BOOST_CHECK_EQUAL(tre.get_sec (), 0);
638 BOOST_CHECK_EQUAL(tre.get_nsec (), 0);
640 BOOST_CHECK_EQUAL(tb.get_sec (), 0); /* BOOT */
641 BOOST_CHECK_EQUAL(tb.get_nsec (), 0);
643 BOOST_CHECK_EQUAL(tcp.get_sec (), 0); /* CPU */
644 BOOST_CHECK_EQUAL(tcp.get_nsec (), 0);
646 BOOST_CHECK_EQUAL(tct.get_sec (), 0);
647 BOOST_CHECK_EQUAL(tct.get_nsec (), 0);
650 BOOST_AUTO_TEST_CASE(initializer_now)
652 boost::optional<I2n::clock::Time> t = I2n::clock::now ();
655 BOOST_CHECK_GT(t->get_sec (), 0);
656 BOOST_CHECK_EQUAL(t->err, 0);
659 BOOST_AUTO_TEST_CASE(initializer_zero)
661 I2n::clock::Time stundenull = I2n::clock::zero ();
663 BOOST_CHECK_EQUAL(stundenull.get_sec (), 0);
664 BOOST_CHECK_EQUAL(stundenull.get_nsec (), 0);
665 BOOST_CHECK_EQUAL(stundenull.err, 0);
668 BOOST_AUTO_TEST_CASE(member_set_now)
672 BOOST_CHECK(t.set ());
674 BOOST_CHECK_NE(t.get_sec (), 0);
677 BOOST_AUTO_TEST_CASE(member_set_value)
683 BOOST_CHECK_EQUAL(t.get_sec (), 42);
684 BOOST_CHECK_EQUAL(t.get_nsec (), 42);
687 BOOST_AUTO_TEST_CASE(member_set_value_type)
691 t.set (42, 42, I2n::clock::type::real, I2n::clock::type::exact);
693 BOOST_CHECK_EQUAL(t.get_sec (), 42);
694 BOOST_CHECK_EQUAL(t.get_nsec (), 42);
697 BOOST_AUTO_TEST_CASE(member_add_parts)
704 BOOST_CHECK_EQUAL(t.get_sec (), 2229);
705 BOOST_CHECK_EQUAL(t.get_nsec (), 2229);
708 BOOST_AUTO_TEST_CASE(member_sub_parts)
715 BOOST_CHECK_EQUAL(t.get_sec (), 0);
716 BOOST_CHECK_EQUAL(t.get_nsec (), 999999999);
719 BOOST_AUTO_TEST_CASE(member_sub_Time)
729 BOOST_CHECK_EQUAL(t1.get_sec (), 0);
730 BOOST_CHECK_EQUAL(t1.get_nsec (), 42L);
733 BOOST_AUTO_TEST_CASE(member_diff)
735 static const time_t five = 5 * 365 * 24 * 3600;
737 I2n::clock::Time t1 (42, 1337);
738 I2n::clock::Time t2 = t1 + five;;
739 I2n::clock::Time t3 = t1 - five;;
741 BOOST_CHECK_EQUAL(t2, I2n::clock::Time ((time_t)42 + five, 1337));
742 BOOST_CHECK_EQUAL(t3, I2n::clock::Time ((time_t)42 - five, 1337));
743 BOOST_CHECK_EQUAL(t1.difference (t3), t3.difference (t1));
744 BOOST_CHECK_EQUAL(t3.difference (t3), t3.difference (t3));
747 BOOST_AUTO_TEST_CASE(op_copyassign)
752 BOOST_CHECK(t1.set ());
756 BOOST_CHECK_EQUAL(t1.get_sec (), t2.get_sec ());
757 BOOST_CHECK_EQUAL(t1.get_nsec (), t2.get_nsec ());
760 BOOST_AUTO_TEST_CASE(op_equal)
765 BOOST_CHECK(t1.set ());
768 BOOST_CHECK_EQUAL(t1, t2);
771 BOOST_AUTO_TEST_CASE(op_add_Time)
775 I2n::clock::Time tsum;
781 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
782 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
785 BOOST_AUTO_TEST_CASE(op_add_Time_carry)
789 I2n::clock::Time tsum;
793 t2.set (1300, 2L * 1000 * 1000 * 1000 + 1337);
795 t2.set (1300, 37L * 1000 * 1000 * 1000 + 1337);
801 BOOST_CHECK_EQUAL(tsum.get_sec (), 3489);
802 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
804 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
805 BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
809 BOOST_AUTO_TEST_CASE(op_add_time_t)
811 I2n::clock::Time t1 (2187, 2187);
813 I2n::clock::Time tsum;
817 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
818 BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
821 BOOST_AUTO_TEST_CASE(op_add_time_t_external)
824 I2n::clock::Time t2 (2187, 2187);
825 I2n::clock::Time tsum;
829 BOOST_CHECK_EQUAL(tsum.get_sec (), 3524);
830 BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
833 BOOST_AUTO_TEST_CASE(op_incr_Time)
835 I2n::clock::Time t1 (2187, 2187);
836 I2n::clock::Time t2 (1337, 1337);
840 BOOST_CHECK_EQUAL(t1.get_sec (), 3524);
841 BOOST_CHECK_EQUAL(t1.get_nsec (), 3524);
844 BOOST_AUTO_TEST_CASE(op_incr_time_t)
846 I2n::clock::Time t1 (2187, 2187);
851 BOOST_CHECK_EQUAL(t1.get_sec (), 3524);
852 BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
855 BOOST_AUTO_TEST_CASE(op_subtract_Time)
859 I2n::clock::Time tdiff;
865 BOOST_CHECK_EQUAL(tdiff.get_sec (), 850);
866 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 850);
869 BOOST_AUTO_TEST_CASE(op_subtract_time_t)
871 I2n::clock::Time t1 (2187, 2187);
873 I2n::clock::Time tdiff;
877 BOOST_CHECK_EQUAL(tdiff.get_sec (), 850);
878 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 2187);
881 BOOST_AUTO_TEST_CASE(op_subtract_time_t_external)
884 I2n::clock::Time t2 (2187, 2187);
885 I2n::clock::Time tdiff;
889 BOOST_CHECK_EQUAL(tdiff.get_sec (), -851);
890 BOOST_CHECK_EQUAL(tdiff.get_nsec (), 999997813);
893 BOOST_AUTO_TEST_CASE(op_decr_Time)
895 I2n::clock::Time t1 (2187, 2187);
896 I2n::clock::Time t2 (1337, 1337);
900 BOOST_CHECK_EQUAL(t1.get_sec (), 850);
901 BOOST_CHECK_EQUAL(t1.get_nsec (), 850);
904 BOOST_AUTO_TEST_CASE(op_decr_time_t)
906 I2n::clock::Time t1 (2187, 2187);
911 BOOST_CHECK_EQUAL(t1.get_sec (), 850);
912 BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
915 BOOST_AUTO_TEST_CASE(op_mult_scale)
923 BOOST_CHECK_EQUAL(t2.get_sec (), 42);
924 BOOST_CHECK_EQUAL(t2.get_nsec (), 42);
927 BOOST_AUTO_TEST_CASE(op_mult_mutate)
929 I2n::clock::Time t1 ( 42, 42);
930 I2n::clock::Time t2 (1337, 0);
935 BOOST_CHECK_EQUAL(t1.get_sec (), 84);
936 BOOST_CHECK_EQUAL(t1.get_nsec (), 84);
937 BOOST_CHECK_EQUAL(t2.get_sec (), -13370);
940 BOOST_AUTO_TEST_CASE(op_mult_scale_carry)
945 t1.set (1, 500 * 1000 * 1000);
948 BOOST_CHECK_EQUAL(t2.get_sec (), 4);
949 BOOST_CHECK_EQUAL(t2.get_nsec (), 500 * 1000 * 1000);
952 BOOST_AUTO_TEST_CASE(op_equals)
960 BOOST_CHECK_EQUAL(t1, t2);
963 BOOST_AUTO_TEST_CASE(compare_equal)
971 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), 0);
974 BOOST_AUTO_TEST_CASE(compare_equal_type)
976 I2n::clock::Time t1 (42, 42, I2n::clock::type::real);
977 I2n::clock::Time t2 (42, 42, I2n::clock::type::cpu);
978 I2n::clock::Time t3 (42, 0, I2n::clock::type::real);
979 I2n::clock::Time t4 (42, 42, I2n::clock::type::real);
981 BOOST_CHECK_NE(t1, t2);
982 BOOST_CHECK_NE(t1, t3);
983 BOOST_CHECK_EQUAL(t1, t4);
986 BOOST_AUTO_TEST_CASE(compare_ne_sec)
994 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
995 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), 1);
998 BOOST_AUTO_TEST_CASE(compare_ne_nsec)
1000 I2n::clock::Time t1;
1001 I2n::clock::Time t2;
1006 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
1007 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), 1);
1010 BOOST_AUTO_TEST_CASE(compare_ne_both)
1012 I2n::clock::Time t1;
1013 I2n::clock::Time t2;
1018 BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), 1);
1019 BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), -1);
1022 BOOST_AUTO_TEST_CASE(op_ineq_sec)
1024 I2n::clock::Time t1 (1337);
1025 I2n::clock::Time t2 (2187);
1027 BOOST_CHECK_LT(t1, t2);
1028 BOOST_CHECK_GT(t2, t1);
1031 BOOST_AUTO_TEST_CASE(op_ineq_nsec)
1033 I2n::clock::Time t1 (1337, 23);
1034 I2n::clock::Time t2 (1337, 42);
1036 BOOST_CHECK_LT(t1, t2);
1037 BOOST_CHECK_GT(t2, t1);
1040 BOOST_AUTO_TEST_CASE(op_ineq_both)
1042 I2n::clock::Time t1 (2187, 23);
1043 I2n::clock::Time t2 (1337, 42);
1045 BOOST_CHECK_LT(t2, t1);
1046 BOOST_CHECK_GT(t1, t2);
1049 BOOST_AUTO_TEST_CASE(op_eq_time_t)
1051 boost::optional<I2n::clock::Time> t1 = I2n::clock::now ();
1052 const time_t t2 = time (NULL); /* race here */
1056 BOOST_CHECK_NE(*t1, t2);
1057 BOOST_CHECK_LT(*t1, t2);
1058 BOOST_CHECK_GT( t2, *t1);
1061 BOOST_AUTO_TEST_CASE(Format_sec_msec)
1063 I2n::clock::Time t1 (42, 42);
1064 I2n::clock::Time t2 ( 4, 242424242);
1065 I2n::clock::Time t3 ( 0, 133713371);
1066 I2n::clock::Time t4 ( 0, 0);
1068 std::string s1 = t1.format_sec_msec ();
1069 std::string s2 = t2.format_sec_msec ();
1070 std::string s3 = t3.format_sec_msec ();
1071 std::string s4 = t4.format_sec_msec ();
1073 BOOST_CHECK_EQUAL("42s 0ms" , s1);
1074 BOOST_CHECK_EQUAL( "4s 242ms", s2);
1075 BOOST_CHECK_EQUAL( "0s 133ms", s3);
1076 BOOST_CHECK_EQUAL( "0s 0ms" , s4);
1079 BOOST_AUTO_TEST_CASE(Format_min_sec_msec)
1081 I2n::clock::Time t1 (42*60 + 42, 42);
1082 I2n::clock::Time t2 ( 4*60 + 42, 242424242);
1083 I2n::clock::Time t3 ( 0*60 + 42, 133713371);
1084 I2n::clock::Time t4 ( 0 + 0, 0);
1086 std::string s1 = *t1.format_min_sec_msec ();
1087 std::string s2 = *t2.format_min_sec_msec ();
1088 std::string s3 = *t3.format_min_sec_msec ();
1089 std::string s4 = *t4.format_min_sec_msec ();
1091 BOOST_CHECK_EQUAL("42m42.000s", s1);
1092 BOOST_CHECK_EQUAL( "4m42.242s", s2);
1093 BOOST_CHECK_EQUAL( "0m42.133s", s3);
1094 BOOST_CHECK_EQUAL( "0m0.000s", s4);
1097 BOOST_AUTO_TEST_CASE(FormatISO8601_T)
1099 I2n::clock::Time t (42, 42);
1100 boost::optional<std::string> s = t.format_iso8601 (true, false, true, false);
1102 BOOST_CHECK_EQUAL("00:00:42", *s);
1105 BOOST_AUTO_TEST_CASE(FormatISO8601_DT)
1107 I2n::clock::Time t (1541934671, 0);
1108 boost::optional<std::string> s = t.format_iso8601 (true, true, true, false);
1110 BOOST_CHECK_EQUAL("2018-11-11T11:11:11", *s);
1113 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ)
1115 I2n::clock::Time t (1541934671, 0);
1116 boost::optional<std::string> s = t.format_iso8601 (true, true, true, true);
1118 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000", *s);
1121 BOOST_AUTO_TEST_CASE(Format_make_nice_time)
1123 I2n::clock::Time t (111111, 0);
1124 boost::optional<std::string> s = t.make_nice_time ();
1126 BOOST_CHECK_EQUAL("1 day, 06:51:51", *s);
1129 BOOST_AUTO_TEST_CASE(Format_format_full_time)
1131 I2n::clock::Time t (1541934671, 0);
1133 * brr, the old formatters use localtime without a way to opt out of
1137 boost::optional<std::string> s = t.format_full_time ();
1139 BOOST_CHECK_EQUAL("11.11.2018 11:11", *s);
1142 BOOST_AUTO_TEST_CASE(Format_format_date)
1144 I2n::clock::Time t (1541934671, 0);
1145 boost::optional<std::string> s = t.format_date ();
1147 BOOST_CHECK_EQUAL("11.11.2018", *s);
1150 BOOST_AUTO_TEST_CASE(FromString_iso8601_full)
1152 const std::string in1 ("0001-01-01T00:00:00Z+0000");
1153 const std::string in2 ("2018-11-11T11:11:11Z+0000");
1157 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1158 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1164 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
1168 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
1171 BOOST_AUTO_TEST_CASE(FromString_iso8601_full_negyear)
1173 const std::string in1 ("-0001-01-01T00:00:00Z+0000");
1174 const std::string in2 ("-2018-11-11T11:11:11Z+0000");
1178 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1179 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1187 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
1188 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
1192 BOOST_AUTO_TEST_CASE(FromString_iso8601_partial)
1194 const std::string in1 ("2018-11-11T11:11:11");
1195 const std::string in2 ("2018-11-11");
1199 boost::optional<I2n::clock::Time> t1 =
1200 I2n::clock::time_of_iso8601 (in1, true, true, false);
1201 boost::optional<I2n::clock::Time> t2 =
1202 I2n::clock::time_of_iso8601 (in2, true, false, false);
1207 * We test for the difference here which is zero if the number is
1208 * correct but causes the difference from the expected value to be
1209 * printed in case the test fails.
1211 BOOST_CHECK_EQUAL(*t1->format_iso8601 (true, true, true, false), in1);
1212 BOOST_CHECK_EQUAL(*t2->format_iso8601 (true, true, false, false), in2);
1215 BOOST_AUTO_TEST_CASE(FromString_iso8601_32bit_time_t_err)
1217 const std::string timeless ("11:11:11");
1218 boost::optional<I2n::clock::Time> untimely = boost::none;
1222 untimely = I2n::clock::time_of_iso8601 (timeless, false, true, false);
1225 BOOST_CHECK(!untimely);
1227 BOOST_CHECK(untimely);
1228 BOOST_CHECK_EQUAL(*untimely->format_iso8601 (true, false, true, false),
1233 BOOST_AUTO_TEST_CASE(Ctor_32bit_time_t_err)
1235 boost::optional<std::string> threw = boost::none;
1238 memset (&tm, 0, sizeof (tm));
1249 I2n::clock::Time untimely (tm);
1250 } catch (I2n::clock::conversion_error &exn) {
1251 threw = std::string (exn);
1256 BOOST_CHECK_EQUAL(*threw,
1257 "errno=0 [mktime: from struct tm {Sun Nov 11 11:11:11 1111}]");
1259 BOOST_CHECK(!threw);
1263 BOOST_AUTO_TEST_CASE(containers_list)
1265 std::list<I2n::clock::Time> ts;
1267 ts.push_back (I2n::clock::zero ());
1268 ts.push_back (I2n::clock::zero ());
1270 BOOST_CHECK_EQUAL(ts.size (), 2);
1273 BOOST_AUTO_TEST_CASE(containers_vec)
1275 std::vector<I2n::clock::Time> ts;
1277 ts.push_back (I2n::clock::zero ());
1278 ts.push_back (I2n::clock::zero ());
1280 BOOST_CHECK_EQUAL(ts.size (), 2);
1283 BOOST_AUTO_TEST_CASE(containers_set)
1285 std::set<I2n::clock::Time> ts;
1287 ts.insert (I2n::clock::zero ());
1288 ts.insert (I2n::clock::Time (42, 2187));
1289 ts.insert (I2n::clock::zero ());
1291 BOOST_CHECK_EQUAL(ts.size (), 2);
1294 BOOST_AUTO_TEST_CASE(containers_list_mean)
1296 std::list<I2n::clock::Time> ts;
1298 ts.push_back (I2n::clock::Time (42, 42));
1299 ts.push_back (I2n::clock::Time (1337, 1337));
1301 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1302 I2n::clock::Time (689, 500000689));
1305 BOOST_AUTO_TEST_CASE(containers_list_mean_zero)
1307 std::list<I2n::clock::Time> ts;
1309 ts.push_back (I2n::clock::Time (0, 0));
1310 ts.push_back (I2n::clock::Time (0, 0));
1311 ts.push_back (I2n::clock::Time (0, 0));
1312 ts.push_back (I2n::clock::Time (0, 0));
1314 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1315 I2n::clock::zero ());
1318 BOOST_AUTO_TEST_CASE(containers_list_mean_empty)
1320 std::list<I2n::clock::Time> ts;
1322 BOOST_CHECK_EQUAL(I2n::clock::mean (ts), I2n::clock::Time (0, 0));
1325 BOOST_AUTO_TEST_CASE(containers_set_mean)
1327 std::set<I2n::clock::Time> ts;
1329 ts.insert (I2n::clock::Time (42));
1330 ts.insert (I2n::clock::Time (1337));
1331 ts.insert (I2n::clock::Time (2187));
1333 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1334 I2n::clock::Time (1188, 666666666));
1337 BOOST_AUTO_TEST_CASE(containers_set_median_empty)
1339 std::set<I2n::clock::Time> ts;
1341 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0, 0));
1344 BOOST_AUTO_TEST_CASE(containers_set_median_one)
1346 std::set<I2n::clock::Time> ts;
1348 ts.insert (I2n::clock::Time (42, 0));
1350 BOOST_CHECK_EQUAL(I2n::clock::median (ts),
1351 I2n::clock::Time (42, 0));
1354 BOOST_AUTO_TEST_CASE(containers_set_median_multi)
1356 std::set<I2n::clock::Time> ts;
1358 ts.insert (I2n::clock::Time (42));
1359 ts.insert (I2n::clock::Time (1337));
1360 ts.insert (I2n::clock::Time (2187));
1362 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1365 BOOST_AUTO_TEST_CASE(containers_vec_median_multi)
1367 std::vector<I2n::clock::Time> ts;
1369 ts.push_back (I2n::clock::Time (42));
1370 ts.push_back (I2n::clock::Time (1337));
1371 ts.push_back (I2n::clock::Time (2187));
1373 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1376 BOOST_AUTO_TEST_CASE(containers_list_median_multi)
1378 std::list<I2n::clock::Time> ts;
1380 ts.push_back (I2n::clock::Time (42));
1381 ts.push_back (I2n::clock::Time (1337));
1382 ts.push_back (I2n::clock::Time (2187));
1383 ts.push_back (I2n::clock::Time (0xdead));
1384 ts.push_back (I2n::clock::Time (0xbeef));
1386 BOOST_CHECK_EQUAL(I2n::clock::median (ts),
1387 I2n::clock::Time (2187));
1390 BOOST_AUTO_TEST_CASE(containers_list_median_multi_evensize)
1392 std::list<I2n::clock::Time> ts;
1394 ts.push_back (I2n::clock::Time (42));
1395 ts.push_back (I2n::clock::Time (1337));
1396 ts.push_back (I2n::clock::Time (2187));
1397 ts.push_back (I2n::clock::Time (0xf00d));
1398 ts.push_back (I2n::clock::Time (0xfeed));
1399 ts.push_back (I2n::clock::Time (0xdeadf0e));
1401 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0xf00d));
1404 BOOST_AUTO_TEST_SUITE_END() /* [Clock] */
1406 BOOST_AUTO_TEST_SUITE_END()