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