LCOV - code coverage report
Current view: top level - tests - catch_timespec_operations.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 306 306 100.0 %
Date: 2022-02-13 10:56:14 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Copyright (c) 2018-2022  Made to Order Software Corp.  All Rights Reserved
       2             : //
       3             : // https://snapwebsites.org/project/snapdev
       4             : // contact@m2osw.com
       5             : //
       6             : // This program is free software; you can redistribute it and/or modify
       7             : // it under the terms of the GNU General Public License as published by
       8             : // the Free Software Foundation; either version 2 of the License, or
       9             : // (at your option) any later version.
      10             : //
      11             : // This program is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : //
      16             : // You should have received a copy of the GNU General Public License along
      17             : // with this program; if not, write to the Free Software Foundation, Inc.,
      18             : // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      19             : 
      20             : /** \file
      21             :  * \brief Verify that the timespec operators function.
      22             :  *
      23             :  * This file implements test for the timespec operator functions.
      24             :  */
      25             : 
      26             : // self
      27             : //
      28             : #include    <snapdev/timespec_operations.h>
      29             : 
      30             : #include    "catch_main.h"
      31             : 
      32             : 
      33             : // C++ lib
      34             : //
      35             : #include    <iomanip>
      36             : 
      37             : 
      38             : // last include
      39             : //
      40             : #include    <snapdev/poison.h>
      41             : 
      42             : 
      43             : 
      44             : 
      45             : 
      46             : 
      47             : 
      48          13 : CATCH_TEST_CASE("timespec-operations", "[math]")
      49             : {
      50          22 :     CATCH_START_SECTION("timespec-operations: simple add")
      51             :     {
      52           1 :         snapdev::timespec_ex a(timespec{  5L, 345L });
      53             : 
      54           1 :         snapdev::timespec_ex b;
      55           1 :         timespec raw{ 13L, 701L };
      56           1 :         b = raw;
      57             : 
      58           1 :         CATCH_REQUIRE(a.valid());
      59           1 :         CATCH_REQUIRE(b.valid());
      60           1 :         CATCH_REQUIRE_FALSE(a.negative());
      61           1 :         CATCH_REQUIRE_FALSE(b.negative());
      62             : 
      63           1 :         snapdev::timespec_ex c(a + b);
      64             : 
      65           1 :         a += b;
      66             : 
      67           1 :         CATCH_REQUIRE(a.tv_sec == 5L + 13L);
      68           1 :         CATCH_REQUIRE(a.tv_nsec == 345L + 701L);
      69             : 
      70           1 :         CATCH_REQUIRE(b.tv_sec == 13L);
      71           1 :         CATCH_REQUIRE(b.tv_nsec == 701L);
      72             : 
      73           1 :         CATCH_REQUIRE(c.tv_sec == 5L + 13L);
      74           1 :         CATCH_REQUIRE(c.tv_nsec == 345L + 701L);
      75           1 :         CATCH_REQUIRE(a == c);
      76           1 :         CATCH_REQUIRE(c == a);
      77             : 
      78           1 :         timespec d{ 3L, 55L };
      79             : 
      80           1 :         a += d;
      81             : 
      82           1 :         CATCH_REQUIRE(a.tv_sec == 5L + 13L + 3L);
      83           1 :         CATCH_REQUIRE(a.tv_nsec == 345L + 701L + 55L);
      84             : 
      85           1 :         a += 301L;
      86             : 
      87           1 :         CATCH_REQUIRE(a.tv_sec == 5L + 13L + 3L);
      88           1 :         CATCH_REQUIRE(a.tv_nsec == 345L + 701L + 55L + 301L);
      89             : 
      90           1 :         a -= 1'000'000'259L;
      91             : 
      92           1 :         CATCH_REQUIRE(a.tv_sec == 5L + 13L + 3L - 1L);
      93           1 :         CATCH_REQUIRE(a.tv_nsec == 345L + 701L + 55L + 301L - 259L);
      94             :     }
      95             :     CATCH_END_SECTION()
      96             : 
      97          22 :     CATCH_START_SECTION("timespec-operations: simple subtract")
      98             :     {
      99           1 :         snapdev::timespec_ex a(timespec{ 25L, 1'345L });
     100           1 :         snapdev::timespec_ex b(timespec{ 13L,   701L });
     101             : 
     102           1 :         CATCH_REQUIRE(a.valid());
     103           1 :         CATCH_REQUIRE(b.valid());
     104             : 
     105           1 :         snapdev::timespec_ex c(a - b);
     106           1 :         snapdev::timespec_ex d(-b);
     107           1 :         snapdev::timespec_ex e(a + d);
     108           1 :         snapdev::timespec_ex f(a - 1'000L);   // -1us
     109             : 
     110           1 :         a -= b;
     111             : 
     112           1 :         CATCH_REQUIRE(a.tv_sec == 25L - 13L);
     113           1 :         CATCH_REQUIRE(a.tv_nsec == 1'345L - 701L);
     114             : 
     115           1 :         CATCH_REQUIRE(b.tv_sec == 13L);
     116           1 :         CATCH_REQUIRE(b.tv_nsec == 701L);
     117             : 
     118           1 :         CATCH_REQUIRE(c.tv_sec == 25L - 13L);
     119           1 :         CATCH_REQUIRE(c.tv_nsec == 1'345L - 701L);
     120           1 :         CATCH_REQUIRE(a == c);
     121           1 :         CATCH_REQUIRE(c == a);
     122           1 :         CATCH_REQUIRE(a == e);
     123           1 :         CATCH_REQUIRE(e == c);
     124             : 
     125           1 :         CATCH_REQUIRE(f.tv_sec == 25L);
     126           1 :         CATCH_REQUIRE(f.tv_nsec == 1'345L - 1'000L);
     127             :     }
     128             :     CATCH_END_SECTION()
     129             : 
     130          22 :     CATCH_START_SECTION("timespec-operations: add \"minus one day\"")
     131             :     {
     132           1 :         snapdev::timespec_ex now(timespec{ 1629652541L, 345L });
     133           1 :         snapdev::timespec_ex backward(timespec{ -86400L, 0L }); // -1 day
     134             : 
     135           1 :         CATCH_REQUIRE(!!now);
     136           1 :         CATCH_REQUIRE_FALSE(!backward);
     137           1 :         CATCH_REQUIRE(backward.negative());
     138             : 
     139           1 :         now += backward;
     140             : 
     141           1 :         CATCH_REQUIRE(now.tv_sec == 1629652541L - 86400L);
     142           1 :         CATCH_REQUIRE(now.tv_nsec == 345L);
     143             : 
     144           1 :         CATCH_REQUIRE(backward.tv_sec == -86400L);
     145           1 :         CATCH_REQUIRE(backward.tv_nsec == 0L);
     146             :     }
     147             :     CATCH_END_SECTION()
     148             : 
     149          22 :     CATCH_START_SECTION("timespec-operations: add with nano overflow")
     150             :     {
     151           1 :         snapdev::timespec_ex now(timespec{ 1629652541L, 913'788'345L });
     152           1 :         snapdev::timespec_ex backward(timespec{ 86400L, 500'000'000L }); // +1 day and 0.5 seconds
     153             : 
     154           1 :         CATCH_REQUIRE(!!now);
     155           1 :         CATCH_REQUIRE(!!backward);
     156             : 
     157           1 :         now += backward;
     158             : 
     159           1 :         CATCH_REQUIRE(now.tv_sec == 1629652541L + 86400L + 1L);  // +1 for the overflow
     160           1 :         CATCH_REQUIRE(now.tv_nsec == 913'788'345L + 500'000'000L - 1'000'000'000L);
     161             : 
     162           1 :         CATCH_REQUIRE(backward.tv_sec == 86400L);
     163           1 :         CATCH_REQUIRE(backward.tv_nsec == 500'000'000L);
     164             :     }
     165             :     CATCH_END_SECTION()
     166             : 
     167          22 :     CATCH_START_SECTION("timespec-operations: subtract with nano underflow")
     168             :     {
     169           1 :         snapdev::timespec_ex a(13L,   701L);
     170           1 :         snapdev::timespec_ex b(25L, 1'345L);
     171             : 
     172           1 :         CATCH_REQUIRE(a.valid());
     173           1 :         CATCH_REQUIRE(b.valid());
     174             : 
     175           1 :         a -= b;
     176             : 
     177           1 :         CATCH_REQUIRE(a.tv_sec == 13L - 25L - 1L);
     178           1 :         CATCH_REQUIRE(a.tv_nsec == 701L - 1'345L + 1'000'000'000L);
     179             : 
     180           1 :         CATCH_REQUIRE(b.tv_sec == 25L);
     181           1 :         CATCH_REQUIRE(b.tv_nsec == 1'345L);
     182             :     }
     183             :     CATCH_END_SECTION()
     184             : 
     185          22 :     CATCH_START_SECTION("timespec-operations: -1, 0, +1")
     186             :     {
     187           1 :         snapdev::timespec_ex a = {};
     188             : 
     189           1 :         CATCH_REQUIRE(!a);
     190           1 :         CATCH_REQUIRE_FALSE(a.negative());
     191             : 
     192           1 :         --a;
     193             : 
     194           1 :         CATCH_REQUIRE_FALSE(!a);
     195           1 :         CATCH_REQUIRE(a.negative());
     196           1 :         CATCH_REQUIRE(a.tv_sec == -1L);
     197           1 :         CATCH_REQUIRE(a.tv_nsec == 999'999'999L);
     198             : 
     199           1 :         ++a;
     200             : 
     201           1 :         CATCH_REQUIRE(!a);
     202           1 :         CATCH_REQUIRE(a.tv_sec == 0L);
     203           1 :         CATCH_REQUIRE(a.tv_nsec == 0L);
     204             : 
     205           1 :         ++a;
     206             : 
     207           1 :         CATCH_REQUIRE(!!a);
     208           1 :         CATCH_REQUIRE_FALSE(a.negative());
     209           1 :         CATCH_REQUIRE(a.tv_sec == 0L);
     210           1 :         CATCH_REQUIRE(a.tv_nsec == 1L);
     211             : 
     212           1 :         --a;
     213             : 
     214           1 :         CATCH_REQUIRE(!a);
     215           1 :         CATCH_REQUIRE(a.tv_sec == 0L);
     216           1 :         CATCH_REQUIRE(a.tv_nsec == 0L);
     217             :     }
     218             :     CATCH_END_SECTION()
     219             : 
     220          22 :     CATCH_START_SECTION("timespec-operations: add nanos")
     221             :     {
     222           1 :         snapdev::timespec_ex now(1629652541L, 913'788'345L);
     223           1 :         std::int64_t nsec(500'000'000L);
     224             : 
     225           1 :         CATCH_REQUIRE(!!now);
     226             : 
     227           1 :         snapdev::timespec_ex sum(now + nsec);
     228             : 
     229           1 :         now += nsec;
     230             : 
     231           1 :         CATCH_REQUIRE(now.tv_sec == 1629652541L + 1L);  // +1 for the overflow
     232           1 :         CATCH_REQUIRE(now.tv_nsec == 913'788'345L + 500'000'000L - 1'000'000'000L);
     233             : 
     234           1 :         CATCH_REQUIRE(now == sum);
     235           1 :         CATCH_REQUIRE_FALSE(now != sum);
     236           1 :         CATCH_REQUIRE_FALSE(now < sum);
     237           1 :         CATCH_REQUIRE(now <= sum);
     238           1 :         CATCH_REQUIRE_FALSE(now > sum);
     239           1 :         CATCH_REQUIRE(now >= sum);
     240             : 
     241           1 :         CATCH_REQUIRE(nsec == 500'000'000L);
     242             : 
     243           1 :         nsec += 86400L * 1'000'000'000L;
     244             : 
     245           1 :         snapdev::timespec_ex total(sum + nsec);
     246             : 
     247           1 :         now += nsec;
     248             : 
     249           1 :         CATCH_REQUIRE(now.tv_sec == 1629652541L + 1L + 86400L);  // +1 for the overflow above
     250           1 :         CATCH_REQUIRE(now.tv_nsec == 913'788'345L + 500'000'000L - 1'000'000'000L + 500'000'000L);
     251             : 
     252           1 :         CATCH_REQUIRE(nsec == 500'000'000L + 86400L * 1'000'000'000L);
     253             : 
     254           1 :         CATCH_REQUIRE_FALSE(now == sum);
     255           1 :         CATCH_REQUIRE(now != sum);
     256           1 :         CATCH_REQUIRE_FALSE(now < sum);
     257           1 :         CATCH_REQUIRE_FALSE(now <= sum);
     258           1 :         CATCH_REQUIRE(now > sum);
     259           1 :         CATCH_REQUIRE(now >= sum);
     260             : 
     261           1 :         CATCH_REQUIRE(now == total);
     262           1 :         CATCH_REQUIRE_FALSE(now != total);
     263           1 :         CATCH_REQUIRE_FALSE(now < total);
     264           1 :         CATCH_REQUIRE(now <= total);
     265           1 :         CATCH_REQUIRE_FALSE(now > total);
     266           1 :         CATCH_REQUIRE(now >= total);
     267             : 
     268           1 :         snapdev::timespec_ex pre(++total);
     269             : 
     270           1 :         CATCH_REQUIRE(pre == total);
     271           1 :         CATCH_REQUIRE_FALSE(pre != total);
     272           1 :         CATCH_REQUIRE_FALSE(pre < total);
     273           1 :         CATCH_REQUIRE(pre <= total);
     274           1 :         CATCH_REQUIRE_FALSE(pre > total);
     275           1 :         CATCH_REQUIRE(pre >= total);
     276             : 
     277           1 :         CATCH_REQUIRE_FALSE(now == total);
     278           1 :         CATCH_REQUIRE(now != total);
     279           1 :         CATCH_REQUIRE(now < total);
     280           1 :         CATCH_REQUIRE(now <= total);
     281           1 :         CATCH_REQUIRE_FALSE(now > total);
     282           1 :         CATCH_REQUIRE_FALSE(now >= total);
     283             : 
     284           1 :         snapdev::timespec_ex post(now++);
     285             : 
     286           1 :         CATCH_REQUIRE_FALSE(post == total);
     287           1 :         CATCH_REQUIRE(post != total);
     288           1 :         CATCH_REQUIRE(post < total);
     289           1 :         CATCH_REQUIRE(post <= total);
     290           1 :         CATCH_REQUIRE_FALSE(post > total);
     291           1 :         CATCH_REQUIRE_FALSE(post >= total);
     292             : 
     293           1 :         CATCH_REQUIRE(now == total);
     294           1 :         CATCH_REQUIRE_FALSE(now != total);
     295           1 :         CATCH_REQUIRE_FALSE(now < total);
     296           1 :         CATCH_REQUIRE(now <= total);
     297           1 :         CATCH_REQUIRE_FALSE(now > total);
     298           1 :         CATCH_REQUIRE(now >= total);
     299             : 
     300           1 :         pre = --total;
     301             : 
     302           1 :         CATCH_REQUIRE(pre == total);
     303           1 :         CATCH_REQUIRE_FALSE(pre != total);
     304           1 :         CATCH_REQUIRE_FALSE(pre < total);
     305           1 :         CATCH_REQUIRE(pre <= total);
     306           1 :         CATCH_REQUIRE_FALSE(pre > total);
     307           1 :         CATCH_REQUIRE(pre >= total);
     308             : 
     309           1 :         CATCH_REQUIRE_FALSE(now == total);
     310           1 :         CATCH_REQUIRE(now != total);
     311           1 :         CATCH_REQUIRE_FALSE(now < total);
     312           1 :         CATCH_REQUIRE_FALSE(now <= total);
     313           1 :         CATCH_REQUIRE(now > total);
     314           1 :         CATCH_REQUIRE(now >= total);
     315             : 
     316           1 :         post = now--;
     317             : 
     318           1 :         CATCH_REQUIRE_FALSE(post == total);
     319           1 :         CATCH_REQUIRE(post != total);
     320           1 :         CATCH_REQUIRE_FALSE(post < total);
     321           1 :         CATCH_REQUIRE_FALSE(post <= total);
     322           1 :         CATCH_REQUIRE(post > total);
     323           1 :         CATCH_REQUIRE(post >= total);
     324             : 
     325           1 :         CATCH_REQUIRE(now == total);
     326           1 :         CATCH_REQUIRE_FALSE(now != total);
     327           1 :         CATCH_REQUIRE_FALSE(now < total);
     328           1 :         CATCH_REQUIRE(now <= total);
     329           1 :         CATCH_REQUIRE_FALSE(now > total);
     330           1 :         CATCH_REQUIRE(now >= total);
     331             : 
     332             :     }
     333             :     CATCH_END_SECTION()
     334             : 
     335          22 :     CATCH_START_SECTION("timespec-operations: load/save")
     336             :     {
     337           1 :         snapdev::timespec_ex now(1629652549L, 913'788'345L);
     338             : 
     339           1 :         std::int64_t nsec(now.to_nsec());
     340             : 
     341           1 :         CATCH_REQUIRE(nsec == 1629652549L * 1'000'000'000L + 913'788'345L);
     342             : 
     343           1 :         snapdev::timespec_ex save;
     344           1 :         CATCH_REQUIRE(!save);
     345           1 :         CATCH_REQUIRE(save.valid());
     346           1 :         save = nsec;
     347             : 
     348           1 :         CATCH_REQUIRE(nsec == 1629652549L * 1'000'000'000L + 913'788'345L);
     349           1 :         CATCH_REQUIRE(save.tv_sec == 1629652549L);
     350           1 :         CATCH_REQUIRE(save.tv_nsec == 913'788'345L);
     351             : 
     352           1 :         double seconds(33.0);
     353           1 :         save = seconds;
     354           1 :         CATCH_REQUIRE(save.tv_sec == 33L);
     355           1 :         CATCH_REQUIRE(save.tv_nsec == 0L);
     356             : 
     357           1 :         double precise_time(save.to_sec());
     358           1 :         bool precise_result(precise_time >= 33.0 && precise_time <= 33.0);
     359           1 :         CATCH_REQUIRE(precise_result);
     360             : 
     361           1 :         seconds = 81.325611932;
     362           1 :         save = seconds;
     363           1 :         CATCH_REQUIRE(save.tv_sec == 81L);
     364           1 :         CATCH_REQUIRE(save.tv_nsec == 325'611'932L);
     365             : 
     366           1 :         precise_time = save.to_sec();
     367           1 :         precise_result = precise_time >= 81.325611932 && precise_time <= 81.325611932;
     368           1 :         CATCH_REQUIRE(precise_result);
     369           1 :         CATCH_REQUIRE(save == 81.325611932);
     370           1 :         CATCH_REQUIRE_FALSE(save == 83.5);
     371           1 :         CATCH_REQUIRE(save != 83.5);
     372           1 :         CATCH_REQUIRE_FALSE(save != 81.325611932);
     373           1 :         CATCH_REQUIRE(save < 83.5);
     374           1 :         CATCH_REQUIRE(save <= 81.33);
     375           1 :         CATCH_REQUIRE(save <= 81.325611932);
     376           1 :         CATCH_REQUIRE(save > 71.5);
     377           1 :         CATCH_REQUIRE(save >= 81.324);
     378           1 :         CATCH_REQUIRE(save >= 81.325611932);
     379             : 
     380           1 :         snapdev::timespec_ex plus(save + 3.000101);
     381           1 :         precise_time = plus.to_sec();
     382           1 :         precise_result = precise_time >= 84.325712930 && precise_time <= 84.325712931; // we lose some precision here
     383             : //std::cerr << "precise = " << std::setprecision(20) << std::setw(9) << precise_time
     384             : //<< " expected " << 81.325611932 + 3.000101 << "\n";
     385           1 :         CATCH_REQUIRE(precise_result);
     386             : 
     387           1 :         save += 3.000101;
     388           1 :         precise_time = save.to_sec();
     389           1 :         precise_result = precise_time >= 84.325712930 && precise_time <= 84.325712931; // we lose some precision here
     390             : //std::cerr << "precise = " << std::setprecision(20) << std::setw(9) << precise_time
     391             : //<< " expected " << 81.325611932 + 3.000101 << "\n";
     392           1 :         CATCH_REQUIRE(precise_result);
     393           1 :         CATCH_REQUIRE(save == plus);
     394             : 
     395           1 :         snapdev::timespec_ex minus(save - 1.20050001);
     396           1 :         precise_time = minus.to_sec();
     397           1 :         precise_result = precise_time >= 83.125212920 && precise_time <= 83.125212921;
     398             : //std::cerr << "precise = " << std::setprecision(20) << std::setw(9) << precise_time
     399             : //<< " expected " << 81.325611932 + 3.000101 - 1.20050001 << "\n";
     400           1 :         CATCH_REQUIRE(precise_result);
     401             : 
     402           1 :         save -= 1.20050001;
     403           1 :         precise_time = save.to_sec();
     404           1 :         precise_result = precise_time >= 83.125212920 && precise_time <= 83.125212921;
     405             : //std::cerr << "precise = " << std::setprecision(20) << std::setw(9) << precise_time
     406             : //<< " expected " << 81.325611932 + 3.000101 - 1.20050001 << "\n";
     407           1 :         CATCH_REQUIRE(precise_result);
     408           1 :         CATCH_REQUIRE(save == minus);
     409             : 
     410           1 :         double neg(-701.445123421);
     411           1 :         save = neg;
     412           1 :         CATCH_REQUIRE(save.tv_sec == -702L);
     413           2 :         precise_result = save.tv_nsec >= -445'123'420L + 1'000'000'000L
     414           1 :                       || save.tv_nsec <= -445'123'422L + 1'000'000'000L;
     415           1 :         CATCH_REQUIRE(precise_result);
     416             :     }
     417             :     CATCH_END_SECTION()
     418             : 
     419          22 :     CATCH_START_SECTION("timespec-operations: negative + negative")
     420             :     {
     421           1 :         snapdev::timespec_ex pa(4511L, 913'788'345L);
     422           1 :         snapdev::timespec_ex pb( 311L, 301'225'198L);
     423             : 
     424           1 :         snapdev::timespec_ex na(-pa);
     425           1 :         snapdev::timespec_ex nb(-pb);
     426             : 
     427           1 :         snapdev::timespec_ex sum_ab(na + nb);
     428           1 :         snapdev::timespec_ex sum_ba(nb + na);
     429           1 :         snapdev::timespec_ex diff_ab(na - nb);
     430           1 :         snapdev::timespec_ex diff_ba(nb - na);
     431             : 
     432           1 :         CATCH_REQUIRE(sum_ab.tv_sec != -4511L + -311L);
     433           1 :         CATCH_REQUIRE(sum_ab.tv_sec == -4511L + -1L + -311L + -1L);
     434           1 :         CATCH_REQUIRE(sum_ab.tv_nsec != -913'788'345L + -301'225'198L);
     435           1 :         CATCH_REQUIRE(sum_ab.tv_nsec == (1'000'000'000 - 913'788'345L) + (1'000'000'000L - 301'225'198L));
     436             : 
     437           1 :         CATCH_REQUIRE(sum_ab       == (-4511L + -1L + -311L + -1L) * 1'000'000'000 + (1'000'000'000 - 913'788'345L) + (1'000'000'000L - 301'225'198L));
     438           1 :         CATCH_REQUIRE_FALSE(sum_ab != (-4511L + -1L + -311L + -1L) * 1'000'000'000 + (1'000'000'000 - 913'788'345L) + (1'000'000'000L - 301'225'198L));
     439           1 :         CATCH_REQUIRE_FALSE(sum_ab == (-4511L +  0L + -311L + -1L) * 1'000'000'000 + (1'000'000'000 - 913'788'345L) + (1'000'000'000L - 301'225'198L));
     440           1 :         CATCH_REQUIRE(sum_ab       != (-4511L + -1L + -311L + -1L) * 1'000'000'000 + (1'000'000'000 - 913'788'344L) + (1'000'000'000L - 301'225'198L));
     441             : 
     442           1 :         CATCH_REQUIRE(sum_ba.tv_sec != -311L + -4511L);
     443           1 :         CATCH_REQUIRE(sum_ba.tv_sec == -311L + -1L + -4511L + -1L);
     444           1 :         CATCH_REQUIRE(sum_ba.tv_nsec != -301'225'198L + -913'788'345L);
     445           1 :         CATCH_REQUIRE(sum_ba.tv_nsec == (1'000'000'000L - 301'225'198L) + (1'000'000'000 - 913'788'345L));
     446             : 
     447           1 :         CATCH_REQUIRE(diff_ab.tv_sec == -4511L + -1L + 311L);
     448           1 :         CATCH_REQUIRE(diff_ab.tv_nsec == (1'000'000'000 - 913'788'345L) + 301'225'198L);
     449             : 
     450           1 :         CATCH_REQUIRE(diff_ab       >= (-4511L + -1L + 311L) * 1'000'000'000 + (1'000'000'000 - 913'788'345L) + 301'225'198L);
     451           1 :         CATCH_REQUIRE_FALSE(diff_ab >  (-4511L + -1L + 311L) * 1'000'000'000 + (1'000'000'000 - 913'788'345L) + 301'225'198L);
     452           1 :         CATCH_REQUIRE(diff_ab       <= (-4511L + -1L + 311L) * 1'000'000'000 + (1'000'000'000 - 913'788'345L) + 301'225'198L);
     453           1 :         CATCH_REQUIRE_FALSE(diff_ab <  (-4511L + -1L + 311L) * 1'000'000'000 + (1'000'000'000 - 913'788'345L) + 301'225'198L);
     454             : 
     455           1 :         CATCH_REQUIRE(diff_ba.tv_sec == -311L + -1L + 4511L + 1L);
     456           1 :         CATCH_REQUIRE(diff_ba.tv_nsec == (((1'000'000'000 - 301'225'198L) + 913'788'345L) - 1'000'000'000));
     457             : 
     458           1 :         CATCH_REQUIRE(diff_ba       >= (-311L + -1L + 4511L + 1L) * 1'000'000'000 + (((1'000'000'000 - 301'225'198L) + 913'788'345L) - 1'000'000'000));
     459           1 :         CATCH_REQUIRE_FALSE(diff_ba >  (-311L + -1L + 4511L + 1L) * 1'000'000'000 + (((1'000'000'000 - 301'225'198L) + 913'788'345L) - 1'000'000'000));
     460           1 :         CATCH_REQUIRE(diff_ba       <= (-311L + -1L + 4511L + 1L) * 1'000'000'000 + (((1'000'000'000 - 301'225'198L) + 913'788'345L) - 1'000'000'000));
     461           1 :         CATCH_REQUIRE_FALSE(diff_ba <  (-311L + -1L + 4511L + 1L) * 1'000'000'000 + (((1'000'000'000 - 301'225'198L) + 913'788'345L) - 1'000'000'000));
     462             :     }
     463             :     CATCH_END_SECTION()
     464             : 
     465          22 :     CATCH_START_SECTION("timespec-operations: system time")
     466             :     {
     467           1 :         snapdev::timespec_ex now;
     468           1 :         timespec verify = {};
     469             : 
     470           1 :         now = snapdev::timespec_ex::gettime();
     471           1 :         clock_gettime(CLOCK_REALTIME, &verify);
     472             : 
     473           1 :         snapdev::timespec_ex diff(now - verify);
     474           1 :         snapdev::timespec_ex max_diff(100L);
     475             : 
     476           1 :         CATCH_REQUIRE(diff < max_diff);
     477             :     }
     478             :     CATCH_END_SECTION()
     479             : 
     480          22 :     CATCH_START_SECTION("timespec-operations: ostream")
     481             :     {
     482           1 :         snapdev::timespec_ex a(timespec{ 4511L, 913'788'345L });
     483             : 
     484           2 :         std::stringstream ss;
     485           1 :         ss << a;
     486             : 
     487           1 :         CATCH_REQUIRE(ss.str() == "4511.913788345");
     488             : 
     489           1 :         ss.str(std::string());
     490           1 :         a.tv_sec = 83207L;
     491           1 :         a.tv_nsec = 0;
     492           1 :         ss << a;
     493             : 
     494           1 :         CATCH_REQUIRE(ss.str() == "83207.000000000");
     495             : 
     496           1 :         ss.str(std::string());
     497           1 :         a.tv_sec = 0L;
     498           1 :         a.tv_nsec = 101;
     499           1 :         ss << a;
     500             : 
     501           1 :         CATCH_REQUIRE(ss.str() == "0.000000101");
     502             :     }
     503             :     CATCH_END_SECTION()
     504          17 : }
     505             : 
     506             : 
     507             : 
     508             : // vim: ts=4 sw=4 et

Generated by: LCOV version 1.13