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