git://developer.intra2net.com / libi2ncommon / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
take precautions for 32bit time_t/long
[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
72acd54c
PG		 978 BOOST_AUTO_TEST_CASE(FormatISO8601_T)
979 {
980 I2n::clock::Time t (42, 42);
981 boost::optional<std::string> s = t.format_iso8601 (true, false, true, false);
982
983 BOOST_CHECK_EQUAL("00:00:42", *s);
984 }
985
986 BOOST_AUTO_TEST_CASE(FormatISO8601_DT)
987 {
988 I2n::clock::Time t (1541934671, 0);
989 boost::optional<std::string> s = t.format_iso8601 (true, true, true, false);
990
991 BOOST_CHECK_EQUAL("2018-11-11T11:11:11", *s);
992 }
993
994 BOOST_AUTO_TEST_CASE(FormatISO8601_DTZ)
995 {
996 I2n::clock::Time t (1541934671, 0);
997 boost::optional<std::string> s = t.format_iso8601 (true, true, true, true);
998
999 BOOST_CHECK_EQUAL("2018-11-11T11:11:11Z+0000", *s);
1000 }
1001
1002 BOOST_AUTO_TEST_CASE(Format_make_nice_time)
1003 {
1004 I2n::clock::Time t (111111, 0);
1005 boost::optional<std::string> s = t.make_nice_time ();
1006
1007 BOOST_CHECK_EQUAL("1 day, 06:51:51", *s);
1008 }
1009
1010 BOOST_AUTO_TEST_CASE(Format_format_full_time)
1011 {
1012 I2n::clock::Time t (1541934671, 0);
1013 /*
1014 * brr, the old formatters use localtime without a way to opt out of
1015 * it!
1016 */
1017 setenv ("TZ", "UTC", 1);
1018 tzset();
1019 boost::optional<std::string> s = t.format_full_time ();
1020
1021 BOOST_CHECK_EQUAL("11.11.2018 11:11", *s);
1022 }
1023
1024 BOOST_AUTO_TEST_CASE(Format_format_date)
1025 {
1026 I2n::clock::Time t (1541934671, 0);
1027 boost::optional<std::string> s = t.format_date ();
1028
1029 BOOST_CHECK_EQUAL("11.11.2018", *s);
1030 }
1031
2795e39c
PG		 1032 BOOST_AUTO_TEST_CASE(FromString_iso8601_full)
1033 {
1034 const std::string in1 ("0001-01-01T00:00:00Z+0000");
1035 const std::string in2 ("2018-11-11T11:11:11Z+0000");
1036
1037 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1038 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1039
cf960f73
PG		 1040# if LONG_BIT == 32
1041 BOOST_CHECK(!t1);
1042# else
2795e39c 1043 BOOST_CHECK(t1);
2795e39c 1044 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
cf960f73
PG		 1045# endif
1046
1047 BOOST_CHECK(t2);
2795e39c
PG		 1048 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
1049 }
1050
1051 BOOST_AUTO_TEST_CASE(FromString_iso8601_full_negyear)
1052 {
1053 const std::string in1 ("-0001-01-01T00:00:00Z+0000");
1054 const std::string in2 ("-2018-11-11T11:11:11Z+0000");
1055
1056 boost::optional<I2n::clock::Time> t1 = I2n::clock::time_of_iso8601 (in1);
1057 boost::optional<I2n::clock::Time> t2 = I2n::clock::time_of_iso8601 (in2);
1058
cf960f73
PG		 1059# if LONG_BIT == 32
1060 BOOST_CHECK(!t1);
1061 BOOST_CHECK(!t2);
1062# else
2795e39c
PG		 1063 BOOST_CHECK(t1);
1064 BOOST_CHECK(t2);
2795e39c
PG		 1065 BOOST_CHECK_EQUAL(*t1->format_iso8601 (), in1);
1066 BOOST_CHECK_EQUAL(*t2->format_iso8601 (), in2);
cf960f73 1067# endif
2795e39c
PG		 1068 }
1069
1070 BOOST_AUTO_TEST_CASE(FromString_iso8601_partial)
1071 {
1072 const std::string in1 ("2018-11-11T11:11:11");
1073 const std::string in2 ("2018-11-11");
cf960f73
PG		 1074
1075 setenv ("TZ", "UTC", 1);
1076 tzset();
2795e39c
PG		 1077
1078 boost::optional<I2n::clock::Time> t1 =
1079 I2n::clock::time_of_iso8601 (in1, true, true, false);
1080 boost::optional<I2n::clock::Time> t2 =
1081 I2n::clock::time_of_iso8601 (in2, true, false, false);
2795e39c
PG		 1082
1083 BOOST_CHECK(t1);
1084 BOOST_CHECK(t2);
2795e39c
PG		 1085 /*
1086 * We test for the difference here which is zero if the number is
1087 * correct but causes the difference from the expected value to be
1088 * printed in case the test fails.
1089 */
1090 BOOST_CHECK_EQUAL(*t1->format_iso8601 (true, true, true, false), in1);
1091 BOOST_CHECK_EQUAL(*t2->format_iso8601 (true, true, false, false), in2);
cf960f73
PG		 1092 }
1093
1094 BOOST_AUTO_TEST_CASE(FromString_iso8601_32bit_time_t_err)
1095 {
1096 const std::string timeless ("11:11:11");
1097 boost::optional<I2n::clock::Time> untimely = boost::none;
1098
1099 untimely = I2n::clock::time_of_iso8601 (timeless, false, true, false);
1100
1101# if LONG_BIT == 32
1102 BOOST_CHECK(!untimely);
1103# else
1104 BOOST_CHECK(untimely);
1105 BOOST_CHECK_EQUAL(*untimely->format_iso8601 (true, false, true, false),
1106 timeless);
1107# endif
1108 }
1109
1110 BOOST_AUTO_TEST_CASE(Ctor_32bit_time_t_err)
1111 {
1112 boost::optional<std::string> threw = boost::none;
1113
1114 struct tm tm;
1115 memset (&tm, 0, sizeof (tm));
1116
1117 tm.tm_sec = 11;
1118 tm.tm_min = 11;
1119 tm.tm_hour = 11;
1120 tm.tm_mday = 11;
1121 tm.tm_mon = 10;
1122 tm.tm_year = -789;
1123 tm.tm_gmtoff = 0;
1124
1125 try {
1126 I2n::clock::Time untimely (tm);
1127 } catch (I2n::clock::conversion_error &exn) {
1128 threw = std::string (exn);
1129 }
1130
1131
1132# if LONG_BIT == 32
1133 BOOST_CHECK_EQUAL(*threw,
1134 "errno=0 [mktime: from struct tm {Sun Nov 11 11:11:11 1111}]");
1135# else
1136 BOOST_CHECK(!threw);
1137# endif
2795e39c
PG		 1138 }
1139
c42fd3b3
PG		 1140 BOOST_AUTO_TEST_CASE(containers_list)
1141 {
1142 std::list<I2n::clock::Time> ts;
1143
1144 ts.push_back (I2n::clock::zero ());
1145 ts.push_back (I2n::clock::zero ());
1146
1147 BOOST_CHECK_EQUAL(ts.size (), 2);
1148 }
1149
1150 BOOST_AUTO_TEST_CASE(containers_vec)
1151 {
1152 std::vector<I2n::clock::Time> ts;
1153
1154 ts.push_back (I2n::clock::zero ());
1155 ts.push_back (I2n::clock::zero ());
1156
1157 BOOST_CHECK_EQUAL(ts.size (), 2);
1158 }
1159
1160 BOOST_AUTO_TEST_CASE(containers_set)
1161 {
1162 std::set<I2n::clock::Time> ts;
1163
1164 ts.insert (I2n::clock::zero ());
1165 ts.insert (I2n::clock::Time (42, 2187));
1166 ts.insert (I2n::clock::zero ());
1167
1168 BOOST_CHECK_EQUAL(ts.size (), 2);
1169 }
1170
1171 BOOST_AUTO_TEST_CASE(containers_list_mean)
1172 {
1173 std::list<I2n::clock::Time> ts;
1174
1175 ts.push_back (I2n::clock::Time (42, 42));
1176 ts.push_back (I2n::clock::Time (1337, 1337));
1177
1178 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1179 I2n::clock::Time (689, 500000689));
1180 }
1181
1182 BOOST_AUTO_TEST_CASE(containers_list_mean_zero)
1183 {
1184 std::list<I2n::clock::Time> ts;
1185
1186 ts.push_back (I2n::clock::Time (0, 0));
1187 ts.push_back (I2n::clock::Time (0, 0));
1188 ts.push_back (I2n::clock::Time (0, 0));
1189 ts.push_back (I2n::clock::Time (0, 0));
1190
1191 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1192 I2n::clock::zero ());
1193 }
1194
1195 BOOST_AUTO_TEST_CASE(containers_list_mean_empty)
1196 {
1197 std::list<I2n::clock::Time> ts;
1198
1199 BOOST_CHECK_EQUAL(I2n::clock::mean (ts), I2n::clock::Time (0, 0));
1200 }
1201
1202 BOOST_AUTO_TEST_CASE(containers_set_mean)
1203 {
1204 std::set<I2n::clock::Time> ts;
1205
1206 ts.insert (I2n::clock::Time (42));
1207 ts.insert (I2n::clock::Time (1337));
1208 ts.insert (I2n::clock::Time (2187));
1209
1210 BOOST_CHECK_EQUAL(I2n::clock::mean (ts),
1211 I2n::clock::Time (1188, 666666666));
1212 }
1213
1214 BOOST_AUTO_TEST_CASE(containers_set_median_empty)
1215 {
1216 std::set<I2n::clock::Time> ts;
1217
1218 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0, 0));
1219 }
1220
1221 BOOST_AUTO_TEST_CASE(containers_set_median_one)
1222 {
1223 std::set<I2n::clock::Time> ts;
1224
1225 ts.insert (I2n::clock::Time (42, 0));
1226
1227 BOOST_CHECK_EQUAL(I2n::clock::median (ts),
1228 I2n::clock::Time (42, 0));
1229 }
1230
1231 BOOST_AUTO_TEST_CASE(containers_set_median_multi)
1232 {
1233 std::set<I2n::clock::Time> ts;
1234
1235 ts.insert (I2n::clock::Time (42));
1236 ts.insert (I2n::clock::Time (1337));
1237 ts.insert (I2n::clock::Time (2187));
1238
1239 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1240 }
1241
1242 BOOST_AUTO_TEST_CASE(containers_vec_median_multi)
1243 {
1244 std::vector<I2n::clock::Time> ts;
1245
1246 ts.push_back (I2n::clock::Time (42));
1247 ts.push_back (I2n::clock::Time (1337));
1248 ts.push_back (I2n::clock::Time (2187));
1249
1250 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (1337));
1251 }
1252
1253 BOOST_AUTO_TEST_CASE(containers_list_median_multi)
1254 {
1255 std::list<I2n::clock::Time> ts;
1256
1257 ts.push_back (I2n::clock::Time (42));
1258 ts.push_back (I2n::clock::Time (1337));
1259 ts.push_back (I2n::clock::Time (2187));
cf960f73
PG		 1260 ts.push_back (I2n::clock::Time (0xdead));
1261 ts.push_back (I2n::clock::Time (0xbeef));
c42fd3b3 1262
cf960f73
PG		 1263 BOOST_CHECK_EQUAL(I2n::clock::median (ts),
1264 I2n::clock::Time (2187));
c42fd3b3
PG		 1265 }
1266
1267 BOOST_AUTO_TEST_CASE(containers_list_median_multi_evensize)
1268 {
1269 std::list<I2n::clock::Time> ts;
1270
1271 ts.push_back (I2n::clock::Time (42));
1272 ts.push_back (I2n::clock::Time (1337));
1273 ts.push_back (I2n::clock::Time (2187));
1274 ts.push_back (I2n::clock::Time (0xf00d));
cf960f73
PG		 1275 ts.push_back (I2n::clock::Time (0xfeed));
1276 ts.push_back (I2n::clock::Time (0xdeadf0e));
c42fd3b3
PG		 1277
1278 BOOST_CHECK_EQUAL(I2n::clock::median (ts), I2n::clock::Time (0xf00d));
1279 }
1280
e36ca33c 1281BOOST_AUTO_TEST_SUITE_END() /* [Clock] */
dad9e26f 1282
9fe0853b 1283BOOST_AUTO_TEST_SUITE_END()
libi2ncommon: Common functions used in Intra2net programs