developer.intra2net.com Git - libi2ncommon/blob - test/test_timefunc.cpp

   1 /*
   2 The software in this package is distributed under the GNU General
   3 Public License version 2 (with a special exception described below).
   4
   5 A copy of GNU General Public License (GPL) is included in this distribution,
   6 in the file COPYING.GPL.
   7
   8 As a special exception, if other files instantiate templates or use macros
   9 or inline functions from this file, or you compile this file and link it
  10 with other works to produce a work based on this file, this file
  11 does not by itself cause the resulting work to be covered
  12 by the GNU General Public License.
  13
  14 However the source code for this file must still be made available
  15 in accordance with section (3) of the GNU General Public License.
  16
  17 This exception does not invalidate any other reasons why a work based
  18 on this file might be covered by the GNU General Public License.
  19 */
  20 /** @file
  21  * @brief unit test for time related functions.
  22  *
  23  * @copyright Copyright &copy; 2001-2008 by Intra2net AG
  24  *
  25  */
  26
  27 #define BOOST_TEST_DYN_LINK
  28 #include <boost/test/unit_test.hpp>
  29
  30 #include <timefunc.hxx>
  31 #include <filefunc.hxx>
  32
  33 #include <unistd.h>
  34 #include <set>
  35
  36 using namespace std;
  37 using namespace I2n;
  38 using namespace I2n::Time;
  39
  40 class TestTimeFuncFixture
  41 {
  42 protected:
  43    typedef std::list< std::string > StringList;
  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
  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
  70 public:
  71     TestTimeFuncFixture()
  72     {
  73     }
  74
  75     ~TestTimeFuncFixture()
  76     {
  77         remove_check_files();
  78     }
  79 };
  80
  81 BOOST_FIXTURE_TEST_SUITE(TestTimeFunc, TestTimeFuncFixture)
  82
  83 BOOST_AUTO_TEST_CASE(AddIntervalsDisjoint)
  84 {
  85     Intervals intervals;
  86
  87     intervals.add( Interval( 10, 100 ) );
  88     intervals.add( Interval( 600, 620 ) );
  89
  90     BOOST_CHECK_EQUAL( false, intervals.empty() );
  91     BOOST_CHECK_EQUAL( 2u, intervals.size() );
  92
  93     BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
  94     BOOST_CHECK_EQUAL( 100u, intervals.front().upper_bound() );
  95
  96     BOOST_CHECK_EQUAL( 600u, intervals.back().lower_bound() );
  97     BOOST_CHECK_EQUAL( 620u, intervals.back().upper_bound() );
  98 } // eo AddIntervalsDisjoint()
  99
 100
 101
 102 BOOST_AUTO_TEST_CASE(AddIntervalsInclude)
 103 {
 104     Intervals intervals;
 105
 106     intervals.add( Interval( 10, 100 ) );
 107     intervals.add( Interval( 10, 80 ) );
 108
 109     BOOST_CHECK_EQUAL( false, intervals.empty() );
 110     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 111
 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()
 116
 117
 118
 119 BOOST_AUTO_TEST_CASE(AddIntervalsEmbrace)
 120 {
 121     Intervals intervals;
 122
 123     intervals.add( Interval( 10, 100 ) );
 124     intervals.add( Interval( 5, 120 ) );
 125
 126     BOOST_CHECK_EQUAL( false, intervals.empty() );
 127     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 128
 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()
 133
 134
 135
 136 BOOST_AUTO_TEST_CASE(AddIntervalsJoin1)
 137 {
 138     Intervals intervals;
 139
 140     intervals.add( Interval( 10, 100 ) );
 141     intervals.add( Interval( 60, 120 ) );
 142
 143     BOOST_CHECK_EQUAL( false, intervals.empty() );
 144     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 145
 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()
 150
 151
 152
 153 BOOST_AUTO_TEST_CASE(AddIntervalsJoin1b)
 154 {
 155     Intervals intervals;
 156
 157     intervals.add( Interval( 10, 100 ) );
 158     intervals.add( Interval( 100, 120 ) );
 159
 160     BOOST_CHECK_EQUAL( false, intervals.empty() );
 161     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 162
 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()
 167
 168
 169
 170 BOOST_AUTO_TEST_CASE(AddIntervalsJoin2)
 171 {
 172     Intervals intervals;
 173
 174     intervals.add( Interval( 10, 100 ) );
 175     intervals.add( Interval( 200, 250 ) );
 176
 177     BOOST_CHECK_EQUAL( false, intervals.empty() );
 178     BOOST_CHECK_EQUAL( 2u, intervals.size() );
 179
 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() );
 184
 185     // now add the gap; the intervals should collapse to one covering all:
 186     intervals.add( Interval(100, 200) );
 187
 188     BOOST_CHECK_EQUAL( false, intervals.empty() );
 189     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 190
 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()
 195
 196
 197
 198 BOOST_AUTO_TEST_CASE(SubIntervalsDisjoint)
 199 {
 200     Intervals intervals;
 201
 202     intervals.add( Interval(10, 100) );
 203     intervals.sub( Interval(0, 10) );
 204
 205     BOOST_CHECK_EQUAL( false, intervals.empty() );
 206     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 207
 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()
 212
 213
 214
 215 BOOST_AUTO_TEST_CASE(SubIntervalsExact)
 216 {
 217     Intervals intervals;
 218
 219     intervals.add( Interval(10, 100) );
 220     intervals.sub( Interval(10, 100) );
 221
 222     BOOST_CHECK_EQUAL( true, intervals.empty() );
 223     BOOST_CHECK_EQUAL( 0u, intervals.size() );
 224 } // eo SubIntervalsExact()
 225
 226
 227
 228 BOOST_AUTO_TEST_CASE(SubIntervalsSplit1)
 229 {
 230     Intervals intervals;
 231
 232     intervals.add( Interval(10, 100) );
 233     intervals.sub( Interval(20, 40) );
 234
 235     BOOST_CHECK_EQUAL( false, intervals.empty() );
 236     BOOST_CHECK_EQUAL( 2u, intervals.size() );
 237
 238     BOOST_CHECK_EQUAL( 10u, intervals.front().lower_bound() );
 239     BOOST_CHECK_EQUAL( 20u, intervals.front().upper_bound() );
 240
 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()
 246
 247
 248 BOOST_AUTO_TEST_CASE(SubIntervalsCutFront)
 249 {
 250     Intervals intervals;
 251
 252     intervals.add( Interval(10, 100) );
 253     intervals.sub( Interval(10, 20) );
 254
 255     BOOST_CHECK_EQUAL( false, intervals.empty() );
 256     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 257
 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()
 262
 263
 264 BOOST_AUTO_TEST_CASE(SubIntervalsCutBack)
 265 {
 266     Intervals intervals;
 267
 268     intervals.add( Interval(10, 100) );
 269     intervals.sub( Interval(87, 100) );
 270
 271     BOOST_CHECK_EQUAL( false, intervals.empty() );
 272     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 273
 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()
 278
 279
 280
 281 BOOST_AUTO_TEST_CASE(SubIntervalsCutMore)
 282 {
 283     Intervals intervals;
 284
 285     intervals.add( Interval( 10, 100) );
 286     intervals.add( Interval(110, 200) );
 287     intervals.add( Interval(210, 300) );
 288
 289     // this should remove the first 2 intervals and cut the third:
 290     intervals.sub( Interval(8, 220) );
 291
 292     BOOST_CHECK_EQUAL( false, intervals.empty() );
 293     BOOST_CHECK_EQUAL( 1u, intervals.size() );
 294
 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()
 299
 300
 301 BOOST_AUTO_TEST_CASE(IntervalComparisons)
 302 {
 303     Intervals intervals1;
 304     Intervals intervals2;
 305
 306     intervals1.add( Interval( 10, 120) );
 307
 308     intervals2.add( Interval( 10, 110 ) );
 309     intervals2.add( Interval( 100, 120 ) );
 310
 311     BOOST_CHECK_EQUAL( 1u, intervals2.size() );
 312
 313     BOOST_CHECK( intervals1 == intervals2 );
 314     BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
 315     BOOST_CHECK_EQUAL( true, intervals2.contains( intervals1 ));
 316
 317     intervals2.sub( Interval( 40, 50) );
 318
 319     BOOST_CHECK( intervals1 != intervals2 );
 320     BOOST_CHECK_EQUAL( true, intervals1.contains( intervals2 ));
 321     BOOST_CHECK_EQUAL( false, intervals2.contains( intervals1 ));
 322 } // eo IntervalComparisons()
 323
 324
 325
 326 BOOST_AUTO_TEST_CASE(MonotonicClock)
 327 {
 328     long sec0, nsec0;
 329     long sec1, nsec1;
 330
 331     bool res = monotonic_clock_gettime(sec0,nsec0);
 332     BOOST_CHECK_EQUAL( true, res );
 333
 334     usleep(250000);
 335     res= monotonic_clock_gettime(sec1,nsec1);
 336     BOOST_CHECK_EQUAL( true, res);
 337
 338     long delta_sec = sec1 - sec0;
 339     long delta_nsec= nsec1 - nsec0;
 340
 341     long delta_millisec= ( delta_nsec / 1000000L) + delta_sec * 1000L;
 342
 343     BOOST_CHECK( delta_millisec >= 250 - /*fuzz*/ 1);
 344     BOOST_CHECK( delta_millisec < 300 );
 345 } // eo MonotonicClock()
 346
 347 BOOST_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 }
 353
 354 BOOST_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 }
 360
 361 BOOST_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 }
 367
 368 BOOST_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 }
 374
 375 BOOST_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 }
 381
 382 BOOST_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 }
 388
 389 BOOST_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 }
 395
 396 BOOST_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 }
 402
 403 BOOST_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 }
 409
 410 BOOST_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 }
 416
 417 BOOST_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 }
 423
 424 BOOST_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 }
 430
 431 BOOST_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 }
 437
 438 BOOST_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 }
 444
 445 BOOST_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
 452 BOOST_AUTO_TEST_CASE(DateToSeconds1)
 453 {
 454     // no DST
 455     BOOST_CHECK_EQUAL(1325372400, date_to_seconds("2012-01-01"));
 456 }
 457
 458 BOOST_AUTO_TEST_CASE(DateToSeconds2)
 459 {
 460     // DST
 461     BOOST_CHECK_EQUAL(1341093600, date_to_seconds("2012-07-01"));
 462 }
 463
 464 BOOST_AUTO_TEST_SUITE(Clock)
 465
 466     BOOST_AUTO_TEST_CASE(ctor_simple)
 467     {
 468         I2n::clock::Time t;
 469
 470         BOOST_CHECK_EQUAL(t.get_sec  (), 0);
 471         BOOST_CHECK_EQUAL(t.get_nsec (), 0);
 472     }
 473
 474     BOOST_AUTO_TEST_CASE(ctor_type)
 475     {
 476         I2n::clock::Time t (I2n::clock::type::real);
 477
 478         BOOST_CHECK_EQUAL(t.get_sec  (), 0);
 479         BOOST_CHECK_EQUAL(t.get_nsec (), 0);
 480     }
 481
 482     BOOST_AUTO_TEST_CASE(ctor_variant)
 483     {
 484         I2n::clock::Time t (I2n::clock::type::cpu,
 485                             I2n::clock::type::thread);
 486
 487         BOOST_CHECK_EQUAL(t.get_sec  (), 0);
 488         BOOST_CHECK_EQUAL(t.get_nsec (), 0);
 489     }
 490
 491     BOOST_AUTO_TEST_CASE(initializer_now)
 492     {
 493         boost::optional<I2n::clock::Time> t = I2n::clock::now ();
 494
 495         BOOST_CHECK(t);
 496         BOOST_CHECK_GT(t->get_sec (), 0);
 497         BOOST_CHECK_EQUAL(t->err, 0);
 498     }
 499
 500     BOOST_AUTO_TEST_CASE(initializer_zero)
 501     {
 502         I2n::clock::Time stundenull = I2n::clock::zero ();
 503
 504         BOOST_CHECK_EQUAL(stundenull.get_sec  (), 0);
 505         BOOST_CHECK_EQUAL(stundenull.get_nsec (), 0);
 506         BOOST_CHECK_EQUAL(stundenull.err, 0);
 507     }
 508
 509     BOOST_AUTO_TEST_CASE(member_set_now)
 510     {
 511         I2n::clock::Time t;
 512
 513         BOOST_CHECK(t.set ());
 514
 515         BOOST_CHECK_NE(t.get_sec (), 0);
 516     }
 517
 518     BOOST_AUTO_TEST_CASE(member_set_value)
 519     {
 520         I2n::clock::Time t;
 521
 522         t.set (42, 42);
 523
 524         BOOST_CHECK_EQUAL(t.get_sec  (), 42);
 525         BOOST_CHECK_EQUAL(t.get_nsec (), 42);
 526     }
 527
 528     BOOST_AUTO_TEST_CASE(member_set_value_type)
 529     {
 530         I2n::clock::Time t;
 531
 532         t.set (42, 42, I2n::clock::type::real, I2n::clock::type::exact);
 533
 534         BOOST_CHECK_EQUAL(t.get_sec  (), 42);
 535         BOOST_CHECK_EQUAL(t.get_nsec (), 42);
 536     }
 537
 538     BOOST_AUTO_TEST_CASE(member_add_parts)
 539     {
 540         I2n::clock::Time t;
 541
 542         t.set (42, 42);
 543         t.add (2187, 2187);
 544
 545         BOOST_CHECK_EQUAL(t.get_sec  (), 2229);
 546         BOOST_CHECK_EQUAL(t.get_nsec (), 2229);
 547     }
 548
 549     BOOST_AUTO_TEST_CASE(member_sub_parts)
 550     {
 551         I2n::clock::Time t;
 552
 553         t.set (2, 0L);
 554         t.subtract (1, 1L);
 555
 556         BOOST_CHECK_EQUAL(t.get_sec  (), 0);
 557         BOOST_CHECK_EQUAL(t.get_nsec (), 999999999);
 558     }
 559
 560     BOOST_AUTO_TEST_CASE(member_sub_Time)
 561     {
 562         I2n::clock::Time t1;
 563         I2n::clock::Time t2;
 564
 565         t1.set (42, 42L);
 566         t2.set (42,  0L);
 567
 568         t1.subtract (t2);
 569
 570         BOOST_CHECK_EQUAL(t1.get_sec  (),  0);
 571         BOOST_CHECK_EQUAL(t1.get_nsec (), 42L);
 572     }
 573
 574     BOOST_AUTO_TEST_CASE(member_diff)
 575     {
 576         static const time_t five = 5 * 365 * 24 * 3600;
 577
 578         I2n::clock::Time t1 (42, 1337);
 579         I2n::clock::Time t2 = t1 + five;;
 580         I2n::clock::Time t3 = t1 - five;;
 581
 582         BOOST_CHECK_EQUAL(t2, I2n::clock::Time ((time_t)42 + five, 1337));
 583         BOOST_CHECK_EQUAL(t3, I2n::clock::Time ((time_t)42 - five, 1337));
 584         BOOST_CHECK_EQUAL(t1.difference (t3), t3.difference (t1));
 585         BOOST_CHECK_EQUAL(t3.difference (t3), t3.difference (t3));
 586     }
 587
 588     BOOST_AUTO_TEST_CASE(op_copyassign)
 589     {
 590         I2n::clock::Time t1;
 591         I2n::clock::Time t2;
 592
 593         BOOST_CHECK(t1.set ());
 594
 595         t2 = t1;
 596
 597         BOOST_CHECK_EQUAL(t1.get_sec  (), t2.get_sec  ());
 598         BOOST_CHECK_EQUAL(t1.get_nsec (), t2.get_nsec ());
 599     }
 600
 601     BOOST_AUTO_TEST_CASE(op_equal)
 602     {
 603         I2n::clock::Time t1;
 604         I2n::clock::Time t2;
 605
 606         BOOST_CHECK(t1.set ());
 607         t2 = t1;
 608
 609         BOOST_CHECK_EQUAL(t1, t2);
 610     }
 611
 612     BOOST_AUTO_TEST_CASE(op_add_Time)
 613     {
 614         I2n::clock::Time t1;
 615         I2n::clock::Time t2;
 616         I2n::clock::Time tsum;
 617
 618         t1.set (2187, 2187);
 619         t2.set (1337, 1337);
 620         tsum = t1 + t2;
 621
 622         BOOST_CHECK_EQUAL(tsum.get_sec  (), 3524);
 623         BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
 624     }
 625
 626     BOOST_AUTO_TEST_CASE(op_add_Time_carry)
 627     {
 628         I2n::clock::Time t1;
 629         I2n::clock::Time t2;
 630         I2n::clock::Time tsum;
 631
 632         t1.set (2187, 2187);
 633         t2.set (1300, 37L * 1000 * 1000 * 1000 + 1337);
 634
 635         tsum = t1 + t2;
 636
 637         BOOST_CHECK_EQUAL(tsum.get_sec  (), 3524);
 638         BOOST_CHECK_EQUAL(tsum.get_nsec (), 3524);
 639     }
 640
 641     BOOST_AUTO_TEST_CASE(op_add_time_t)
 642     {
 643         I2n::clock::Time t1 (2187, 2187);
 644         time_t           t2 = 1337;
 645         I2n::clock::Time tsum;
 646
 647         tsum = t1 + t2;
 648
 649         BOOST_CHECK_EQUAL(tsum.get_sec  (), 3524);
 650         BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
 651     }
 652
 653     BOOST_AUTO_TEST_CASE(op_add_time_t_external)
 654     {
 655         time_t           t1 = 1337;
 656         I2n::clock::Time t2 (2187, 2187);
 657         I2n::clock::Time tsum;
 658
 659         tsum = t1 + t2;
 660
 661         BOOST_CHECK_EQUAL(tsum.get_sec  (), 3524);
 662         BOOST_CHECK_EQUAL(tsum.get_nsec (), 2187);
 663     }
 664
 665     BOOST_AUTO_TEST_CASE(op_incr_Time)
 666     {
 667         I2n::clock::Time t1 (2187, 2187);
 668         I2n::clock::Time t2 (1337, 1337);
 669
 670         t1 += t2;
 671
 672         BOOST_CHECK_EQUAL(t1.get_sec  (), 3524);
 673         BOOST_CHECK_EQUAL(t1.get_nsec (), 3524);
 674     }
 675
 676     BOOST_AUTO_TEST_CASE(op_incr_time_t)
 677     {
 678         I2n::clock::Time t1 (2187, 2187);
 679         time_t           t2 = 1337;
 680
 681         t1 += t2;
 682
 683         BOOST_CHECK_EQUAL(t1.get_sec  (), 3524);
 684         BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
 685     }
 686
 687     BOOST_AUTO_TEST_CASE(op_subtract_Time)
 688     {
 689         I2n::clock::Time t1;
 690         I2n::clock::Time t2;
 691         I2n::clock::Time tdiff;
 692
 693         t1.set (2187, 2187);
 694         t2.set (1337, 1337);
 695         tdiff = t1 - t2;
 696
 697         BOOST_CHECK_EQUAL(tdiff.get_sec  (), 850);
 698         BOOST_CHECK_EQUAL(tdiff.get_nsec (), 850);
 699     }
 700
 701     BOOST_AUTO_TEST_CASE(op_subtract_time_t)
 702     {
 703         I2n::clock::Time t1 (2187, 2187);
 704         time_t           t2 = 1337;
 705         I2n::clock::Time tdiff;
 706
 707         tdiff = t1 - t2;
 708
 709         BOOST_CHECK_EQUAL(tdiff.get_sec  (), 850);
 710         BOOST_CHECK_EQUAL(tdiff.get_nsec (), 2187);
 711     }
 712
 713     BOOST_AUTO_TEST_CASE(op_subtract_time_t_external)
 714     {
 715         time_t           t1 = 1337;
 716         I2n::clock::Time t2 (2187, 2187);
 717         I2n::clock::Time tdiff;
 718
 719         tdiff = t1 - t2;
 720
 721         BOOST_CHECK_EQUAL(tdiff.get_sec  (), -851);
 722         BOOST_CHECK_EQUAL(tdiff.get_nsec (), 999997813);
 723     }
 724
 725     BOOST_AUTO_TEST_CASE(op_decr_Time)
 726     {
 727         I2n::clock::Time t1 (2187, 2187);
 728         I2n::clock::Time t2 (1337, 1337);
 729
 730         t1 -= t2;
 731
 732         BOOST_CHECK_EQUAL(t1.get_sec  (), 850);
 733         BOOST_CHECK_EQUAL(t1.get_nsec (), 850);
 734     }
 735
 736     BOOST_AUTO_TEST_CASE(op_decr_time_t)
 737     {
 738         I2n::clock::Time t1 (2187, 2187);
 739         time_t           t2 = 1337;
 740
 741         t1 -= t2;
 742
 743         BOOST_CHECK_EQUAL(t1.get_sec  (), 850);
 744         BOOST_CHECK_EQUAL(t1.get_nsec (), 2187);
 745     }
 746
 747     BOOST_AUTO_TEST_CASE(op_mult_scale)
 748     {
 749         I2n::clock::Time t1;
 750         I2n::clock::Time t2;
 751
 752         t1.set (1, 1);
 753         t2 = t1 * 42;
 754
 755         BOOST_CHECK_EQUAL(t2.get_sec  (), 42);
 756         BOOST_CHECK_EQUAL(t2.get_nsec (), 42);
 757     }
 758
 759     BOOST_AUTO_TEST_CASE(op_mult_mutate)
 760     {
 761         I2n::clock::Time t1 (  42, 42);
 762         I2n::clock::Time t2 (1337,  0);
 763
 764         t1 *=   2;
 765         t2 *= -10;
 766
 767         BOOST_CHECK_EQUAL(t1.get_sec  (),     84);
 768         BOOST_CHECK_EQUAL(t1.get_nsec (),     84);
 769         BOOST_CHECK_EQUAL(t2.get_sec  (), -13370);
 770     }
 771
 772     BOOST_AUTO_TEST_CASE(op_mult_scale_carry)
 773     {
 774         I2n::clock::Time t1;
 775         I2n::clock::Time t2;
 776
 777         t1.set (1, 500 * 1000 * 1000);
 778         t2 = t1 * 3;
 779
 780         BOOST_CHECK_EQUAL(t2.get_sec  (),  4);
 781         BOOST_CHECK_EQUAL(t2.get_nsec (),  500 * 1000 * 1000);
 782     }
 783
 784     BOOST_AUTO_TEST_CASE(op_equals)
 785     {
 786         I2n::clock::Time t1;
 787         I2n::clock::Time t2;
 788
 789         t1.set (50, 50);
 790         t2.set (50, 50);
 791
 792         BOOST_CHECK_EQUAL(t1, t2);
 793     }
 794
 795     BOOST_AUTO_TEST_CASE(compare_equal)
 796     {
 797         I2n::clock::Time t1;
 798         I2n::clock::Time t2;
 799
 800         t1.set (42, 42);
 801         t2.set (42, 42);
 802
 803         BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), 0);
 804     }
 805
 806     BOOST_AUTO_TEST_CASE(compare_equal_type)
 807     {
 808         I2n::clock::Time t1 (42, 42, I2n::clock::type::real);
 809         I2n::clock::Time t2 (42, 42, I2n::clock::type::cpu);
 810         I2n::clock::Time t3 (42,  0, I2n::clock::type::real);
 811         I2n::clock::Time t4 (42, 42, I2n::clock::type::real);
 812
 813         BOOST_CHECK_NE(t1, t2);
 814         BOOST_CHECK_NE(t1, t3);
 815         BOOST_CHECK_EQUAL(t1, t4);
 816     }
 817
 818     BOOST_AUTO_TEST_CASE(compare_ne_sec)
 819     {
 820         I2n::clock::Time t1;
 821         I2n::clock::Time t2;
 822
 823         t1.set (  42, 42);
 824         t2.set (1337, 42);
 825
 826         BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
 827         BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1),  1);
 828     }
 829
 830     BOOST_AUTO_TEST_CASE(compare_ne_nsec)
 831     {
 832         I2n::clock::Time t1;
 833         I2n::clock::Time t2;
 834
 835         t1.set (42,   42);
 836         t2.set (42, 1337);
 837
 838         BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2), -1);
 839         BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1),  1);
 840     }
 841
 842     BOOST_AUTO_TEST_CASE(compare_ne_both)
 843     {
 844         I2n::clock::Time t1;
 845         I2n::clock::Time t2;
 846
 847         t1.set (42, 2187);
 848         t2.set (23, 1337);
 849
 850         BOOST_CHECK_EQUAL(I2n::clock::compare (t1, t2),  1);
 851         BOOST_CHECK_EQUAL(I2n::clock::compare (t2, t1), -1);
 852     }
 853
 854     BOOST_AUTO_TEST_CASE(op_ineq_sec)
 855     {
 856         I2n::clock::Time t1 (1337);
 857         I2n::clock::Time t2 (2187);
 858
 859         BOOST_CHECK_LT(t1, t2);
 860         BOOST_CHECK_GT(t2, t1);
 861     }
 862
 863     BOOST_AUTO_TEST_CASE(op_ineq_nsec)
 864     {
 865         I2n::clock::Time t1 (1337, 23);
 866         I2n::clock::Time t2 (1337, 42);
 867
 868         BOOST_CHECK_LT(t1, t2);
 869         BOOST_CHECK_GT(t2, t1);
 870     }
 871
 872     BOOST_AUTO_TEST_CASE(op_ineq_both)
 873     {
 874         I2n::clock::Time t1 (2187, 23);
 875         I2n::clock::Time t2 (1337, 42);
 876
 877         BOOST_CHECK_LT(t2, t1);
 878         BOOST_CHECK_GT(t1, t2);
 879     }
 880
 881     BOOST_AUTO_TEST_CASE(op_eq_time_t)
 882     {
 883         boost::optional<I2n::clock::Time> t1  = I2n::clock::now ();
 884         const time_t                      t2  = time (NULL); /* race here */
 885
 886         *t1 -= (time_t)42;
 887
 888         BOOST_CHECK_NE(*t1,  t2);
 889         BOOST_CHECK_LT(*t1,  t2);
 890         BOOST_CHECK_GT( t2, *t1);
 891     }
 892
 893     BOOST_AUTO_TEST_CASE(containers_list)
 894     {
 895         std::list<I2n::clock::Time> ts;
 896
 897         ts.push_back (I2n::clock::zero ());
 898         ts.push_back (I2n::clock::zero ());
 899
 900         BOOST_CHECK_EQUAL(ts.size (), 2);
 901     }
 902
 903     BOOST_AUTO_TEST_CASE(containers_vec)
 904     {
 905         std::vector<I2n::clock::Time> ts;
 906
 907         ts.push_back (I2n::clock::zero ());
 908         ts.push_back (I2n::clock::zero ());
 909
 910         BOOST_CHECK_EQUAL(ts.size (), 2);
 911     }
 912
 913     BOOST_AUTO_TEST_CASE(containers_set)
 914     {
 915         std::set<I2n::clock::Time> ts;
 916
 917         ts.insert (I2n::clock::zero ());
 918         ts.insert (I2n::clock::Time (42, 2187));
 919         ts.insert (I2n::clock::zero ());
 920
 921         BOOST_CHECK_EQUAL(ts.size (), 2);
 922     }
 923
 924 BOOST_AUTO_TEST_SUITE_END() /* [Clock] */
 925
 926 BOOST_AUTO_TEST_SUITE_END()