contrib/ntp/tests/libntp/timespecops.c

   1 #include "config.h"
   2
   3 #include "ntp_types.h"
   4 #include "ntp_fp.h"
   5 #include "timespecops.h"
   6
   7 #include "unity.h"
   8
   9 #include <math.h>
  10 #include <string.h>
  11
  12
  13 #define TEST_ASSERT_EQUAL_timespec(a, b) {                              \
  14     TEST_ASSERT_EQUAL_MESSAGE(a.tv_sec, b.tv_sec, "Field tv_sec");      \
  15     TEST_ASSERT_EQUAL_MESSAGE(a.tv_nsec, b.tv_nsec, "Field tv_nsec");   \
  16 }
  17
  18
  19 #define TEST_ASSERT_EQUAL_l_fp(a, b) {                                  \
  20     TEST_ASSERT_EQUAL_MESSAGE(a.l_i, b.l_i, "Field l_i");               \
  21     TEST_ASSERT_EQUAL_UINT_MESSAGE(a.l_uf, b.l_uf, "Field l_uf");       \
  22 }
  23
  24
  25 static u_int32 my_tick_to_tsf(u_int32 ticks);
  26 static u_int32 my_tsf_to_tick(u_int32 tsf);
  27
  28
  29 // that's it...
  30 struct lfpfracdata {
  31         long    nsec;
  32         u_int32 frac;
  33 };
  34
  35
  36 void setUp(void);
  37 void test_Helpers1(void);
  38 void test_Normalise(void);
  39 void test_SignNoFrac(void);
  40 void test_SignWithFrac(void);
  41 void test_CmpFracEQ(void);
  42 void test_CmpFracGT(void);
  43 void test_CmpFracLT(void);
  44 void test_AddFullNorm(void);
  45 void test_AddFullOflow1(void);
  46 void test_AddNsecNorm(void);
  47 void test_AddNsecOflow1(void);
  48 void test_SubFullNorm(void);
  49 void test_SubFullOflow(void);
  50 void test_SubNsecNorm(void);
  51 void test_SubNsecOflow(void);
  52 void test_Neg(void);
  53 void test_AbsNoFrac(void);
  54 void test_AbsWithFrac(void);
  55 void test_Helpers2(void);
  56 void test_ToLFPbittest(void);
  57 void test_ToLFPrelPos(void);
  58 void test_ToLFPrelNeg(void);
  59 void test_ToLFPabs(void);
  60 void test_FromLFPbittest(void);
  61 void test_FromLFPrelPos(void);
  62 void test_FromLFPrelNeg(void);
  63 void test_LFProundtrip(void);
  64 void test_ToString(void);
  65
  66 typedef int bool;
  67
  68 const bool      timespec_isValid(struct timespec V);
  69 struct timespec timespec_init(time_t hi, long lo);
  70 l_fp            l_fp_init(int32 i, u_int32 f);
  71 bool            AssertFpClose(const l_fp m, const l_fp n, const l_fp limit);
  72 bool            AssertTimespecClose(const struct timespec m,
  73                                     const struct timespec n,
  74                                     const struct timespec limit);
  75
  76
  77 //***************************MY CUSTOM FUNCTIONS***************************
  78
  79
  80 void
  81 setUp(void)
  82 {
  83         init_lib();
  84
  85         return;
  86 }
  87
  88
  89 const bool
  90 timespec_isValid(struct timespec V)
  91 {
  92
  93         return V.tv_nsec >= 0 && V.tv_nsec < 1000000000;
  94 }
  95
  96
  97 struct timespec
  98 timespec_init(time_t hi, long lo)
  99 {
 100         struct timespec V;
 101
 102         V.tv_sec = hi;
 103         V.tv_nsec = lo;
 104
 105         return V;
 106 }
 107
 108
 109 l_fp
 110 l_fp_init(int32 i, u_int32 f)
 111 {
 112         l_fp temp;
 113
 114         temp.l_i  = i;
 115         temp.l_uf = f;
 116
 117         return temp;
 118 }
 119
 120
 121 bool
 122 AssertFpClose(const l_fp m, const l_fp n, const l_fp limit)
 123 {
 124         l_fp diff;
 125
 126         if (L_ISGEQ(&m, &n)) {
 127                 diff = m;
 128                 L_SUB(&diff, &n);
 129         } else {
 130                 diff = n;
 131                 L_SUB(&diff, &m);
 132         }
 133         if (L_ISGEQ(&limit, &diff)) {
 134                 return TRUE;
 135         }
 136         else {
 137                 printf("m_expr which is %s \nand\nn_expr which is %s\nare not close; diff=%susec\n", lfptoa(&m, 10), lfptoa(&n, 10), lfptoa(&diff, 10));
 138                 return FALSE;
 139         }
 140 }
 141
 142
 143 bool
 144 AssertTimespecClose(const struct timespec m, const struct timespec n,
 145         const struct timespec limit)
 146 {
 147         struct timespec diff;
 148
 149         diff = abs_tspec(sub_tspec(m, n));
 150         if (cmp_tspec(limit, diff) >= 0)
 151                 return TRUE;
 152         else
 153         {
 154                 printf("m_expr which is %ld.%lu \nand\nn_expr which is %ld.%lu\nare not close; diff=%ld.%lunsec\n", m.tv_sec, m.tv_nsec, n.tv_sec, n.tv_nsec, diff.tv_sec, diff.tv_nsec);
 155                 return FALSE;
 156         }
 157 }
 158
 159 //-----------------------------------------------
 160
 161 static const struct lfpfracdata fdata[] = {
 162         {         0, 0x00000000 }, {   2218896, 0x00916ae6 },
 163         {  16408100, 0x0433523d }, { 125000000, 0x20000000 },
 164         { 250000000, 0x40000000 }, { 287455871, 0x4996b53d },
 165         { 375000000, 0x60000000 }, { 500000000, 0x80000000 },
 166         { 518978897, 0x84dbcd0e }, { 563730222, 0x90509fb3 },
 167         { 563788007, 0x9054692c }, { 583289882, 0x95527c57 },
 168         { 607074509, 0x9b693c2a }, { 625000000, 0xa0000000 },
 169         { 645184059, 0xa52ac851 }, { 676497788, 0xad2ef583 },
 170         { 678910895, 0xadcd1abb }, { 679569625, 0xadf84663 },
 171         { 690926741, 0xb0e0932d }, { 705656483, 0xb4a5e73d },
 172         { 723553854, 0xb93ad34c }, { 750000000, 0xc0000000 },
 173         { 763550253, 0xc3780785 }, { 775284917, 0xc6791284 },
 174         { 826190764, 0xd3813ce8 }, { 875000000, 0xe0000000 },
 175         { 956805507, 0xf4f134a9 }, { 982570733, 0xfb89c16c }
 176         };
 177
 178
 179 u_int32
 180 my_tick_to_tsf(u_int32 ticks)
 181 {
 182         // convert nanoseconds to l_fp fractional units, using double
 183         // precision float calculations or, if available, 64bit integer
 184         // arithmetic. This should give the precise fraction, rounded to
 185         // the nearest representation.
 186
 187 #ifdef HAVE_U_INT64
 188         return (u_int32)((( ((u_int64)(ticks)) << 32) + 500000000) / 1000000000);
 189 #else
 190         return (u_int32)((double(ticks)) * 4.294967296 + 0.5);
 191 #endif
 192         // And before you ask: if ticks >= 1000000000, the result is
 193         // truncated nonsense, so don't use it out-of-bounds.
 194 }
 195
 196
 197 u_int32
 198 my_tsf_to_tick(u_int32 tsf)
 199 {
 200
 201         // Inverse operation: converts fraction to microseconds.
 202 #ifdef HAVE_U_INT64
 203         return (u_int32)(( ((u_int64)(tsf)) * 1000000000 + 0x80000000) >> 32);
 204 #else
 205         return (u_int32)(double(tsf) / 4.294967296 + 0.5);
 206 #endif
 207         // Beware: The result might be 10^9 due to rounding!
 208 }
 209
 210
 211
 212 // ---------------------------------------------------------------------
 213 // test support stuff -- part 1
 214 // ---------------------------------------------------------------------
 215
 216 void
 217 test_Helpers1(void)
 218 {
 219         struct timespec x;
 220
 221         for (x.tv_sec = -2; x.tv_sec < 3; x.tv_sec++) {
 222                 x.tv_nsec = -1;
 223                 TEST_ASSERT_FALSE(timespec_isValid(x));
 224                 x.tv_nsec = 0;
 225                 TEST_ASSERT_TRUE(timespec_isValid(x));
 226                 x.tv_nsec = 999999999;
 227                 TEST_ASSERT_TRUE(timespec_isValid(x));
 228                 x.tv_nsec = 1000000000;
 229                 TEST_ASSERT_FALSE(timespec_isValid(x));
 230         }
 231
 232         return;
 233 }
 234
 235
 236 //----------------------------------------------------------------------
 237 // test normalisation
 238 //----------------------------------------------------------------------
 239
 240 void
 241 test_Normalise(void)
 242 {
 243         long ns;
 244
 245         for ( ns = -2000000000; ns <= 2000000000; ns += 10000000) {
 246                 struct timespec x = timespec_init(0, ns);
 247
 248                 x = normalize_tspec(x);
 249                 TEST_ASSERT_TRUE(timespec_isValid(x));
 250         }
 251
 252         return;
 253 }
 254
 255 //----------------------------------------------------------------------
 256 // test classification
 257 //----------------------------------------------------------------------
 258
 259 void
 260 test_SignNoFrac(void)
 261 {
 262         // sign test, no fraction
 263         int i;
 264
 265         for (i = -4; i <= 4; ++i) {
 266                 struct timespec a = timespec_init(i, 0);
 267                 int E = (i > 0) - (i < 0);
 268                 int r = test_tspec(a);
 269
 270                 TEST_ASSERT_EQUAL(E, r);
 271         }
 272
 273         return;
 274 }
 275
 276
 277 void
 278 test_SignWithFrac(void)
 279 {
 280         // sign test, with fraction
 281         int i;
 282
 283         for (i = -4; i <= 4; ++i) {
 284                 struct timespec a = timespec_init(i, 10);
 285                 int E = (i >= 0) - (i < 0);
 286                 int r = test_tspec(a);
 287
 288                 TEST_ASSERT_EQUAL(E, r);
 289         }
 290
 291         return;
 292 }
 293
 294 //----------------------------------------------------------------------
 295 // test compare
 296 //----------------------------------------------------------------------
 297 void
 298 test_CmpFracEQ(void)
 299 {
 300         // fractions are equal
 301         int i, j;
 302         for (i = -4; i <= 4; ++i)
 303                 for (j = -4; j <= 4; ++j) {
 304                         struct timespec a = timespec_init( i , 200);
 305                         struct timespec b = timespec_init( j , 200);
 306                         int   E = (i > j) - (i < j);
 307                         int   r = cmp_tspec_denorm(a, b);
 308
 309                         TEST_ASSERT_EQUAL(E, r);
 310                 }
 311
 312         return;
 313 }
 314
 315
 316 void
 317 test_CmpFracGT(void)
 318 {
 319         // fraction a bigger fraction b
 320         int i, j;
 321
 322         for (i = -4; i <= 4; ++i)
 323                 for (j = -4; j <= 4; ++j) {
 324                         struct timespec a = timespec_init(i, 999999800);
 325                         struct timespec b = timespec_init(j, 200);
 326                         int   E = (i >= j) - (i < j);
 327                         int   r = cmp_tspec_denorm(a, b);
 328
 329                         TEST_ASSERT_EQUAL(E, r);
 330                 }
 331
 332         return;
 333 }
 334
 335
 336 void
 337 test_CmpFracLT(void)
 338 {
 339         // fraction a less fraction b
 340         int i, j;
 341
 342         for (i = -4; i <= 4; ++i)
 343                 for (j = -4; j <= 4; ++j) {
 344                         struct timespec a = timespec_init(i, 200);
 345                         struct timespec b = timespec_init(j, 999999800);
 346                         int   E = (i > j) - (i <= j);
 347                         int   r = cmp_tspec_denorm(a, b);
 348
 349                         TEST_ASSERT_EQUAL(E, r);
 350                 }
 351
 352         return;
 353 }
 354
 355 //----------------------------------------------------------------------
 356 // Test addition (sum)
 357 //----------------------------------------------------------------------
 358
 359 void
 360 test_AddFullNorm(void)
 361 {
 362         int i, j;
 363
 364         for (i = -4; i <= 4; ++i)
 365                 for (j = -4; j <= 4; ++j) {
 366                         struct timespec a = timespec_init(i, 200);
 367                         struct timespec b = timespec_init(j, 400);
 368                         struct timespec E = timespec_init(i + j, 200 + 400);
 369                         struct timespec c;
 370
 371                         c = add_tspec(a, b);
 372                         TEST_ASSERT_EQUAL_timespec(E, c);
 373                 }
 374
 375         return;
 376 }
 377
 378
 379 void
 380 test_AddFullOflow1(void)
 381 {
 382         int i, j;
 383
 384         for (i = -4; i <= 4; ++i)
 385                 for (j = -4; j <= 4; ++j) {
 386                         struct timespec a = timespec_init(i, 200);
 387                         struct timespec b = timespec_init(j, 999999900);
 388                         struct timespec E = timespec_init(i + j + 1, 100);
 389                         struct timespec c;
 390
 391                         c = add_tspec(a, b);
 392                         TEST_ASSERT_EQUAL_timespec(E, c);
 393                 }
 394
 395         return;
 396 }
 397
 398
 399 void
 400 test_AddNsecNorm(void) {
 401         int i;
 402
 403         for (i = -4; i <= 4; ++i) {
 404                 struct timespec a = timespec_init(i, 200);
 405                 struct timespec E = timespec_init(i, 600);
 406                 struct timespec c;
 407
 408                 c = add_tspec_ns(a, 600 - 200);
 409                 TEST_ASSERT_EQUAL_timespec(E, c);
 410         }
 411
 412         return;
 413 }
 414
 415
 416 void
 417 test_AddNsecOflow1(void)
 418 {
 419         int i;
 420
 421         for (i = -4; i <= 4; ++i) {
 422                 struct timespec a = timespec_init(i, 200);
 423                 struct timespec E = timespec_init(i + 1, 100);
 424                 struct timespec c;
 425
 426                 c = add_tspec_ns(a, NANOSECONDS - 100);
 427                 TEST_ASSERT_EQUAL_timespec(E, c);
 428         }
 429
 430         return;
 431 }
 432
 433 //----------------------------------------------------------------------
 434 // test subtraction (difference)
 435 //----------------------------------------------------------------------
 436
 437 void
 438 test_SubFullNorm(void)
 439 {
 440         int i, j;
 441
 442         for (i = -4; i <= 4; ++i)
 443                 for (j = -4; j <= 4; ++j) {
 444                         struct timespec a = timespec_init( i , 600);
 445                         struct timespec b = timespec_init( j , 400);
 446                         struct timespec E = timespec_init(i-j, 200);
 447                         struct timespec c;
 448
 449                         c = sub_tspec(a, b);
 450                         TEST_ASSERT_EQUAL_timespec(E, c);
 451                 }
 452
 453         return;
 454 }
 455
 456
 457 void
 458 test_SubFullOflow(void)
 459 {
 460         int i, j;
 461
 462         for (i = -4; i <= 4; ++i)
 463                 for (j = -4; j <= 4; ++j) {
 464                         struct timespec a = timespec_init(i, 100);
 465                         struct timespec b = timespec_init(j, 999999900);
 466                         struct timespec E = timespec_init(i - j - 1, 200);
 467                         struct timespec c;
 468
 469                         c = sub_tspec(a, b);
 470                         TEST_ASSERT_EQUAL_timespec(E, c);
 471                 }
 472
 473         return;
 474 }
 475
 476
 477 void
 478 test_SubNsecNorm(void)
 479 {
 480         int i;
 481
 482         for (i = -4; i <= 4; ++i) {
 483                 struct timespec a = timespec_init(i, 600);
 484                 struct timespec E = timespec_init(i, 200);
 485                 struct timespec c;
 486
 487                 c = sub_tspec_ns(a, 600 - 200);
 488                 TEST_ASSERT_EQUAL_timespec(E, c);
 489         }
 490
 491         return;
 492 }
 493
 494
 495 void
 496 test_SubNsecOflow(void)
 497 {
 498         int i;
 499
 500         for (i = -4; i <= 4; ++i) {
 501                 struct timespec a = timespec_init( i , 100);
 502                 struct timespec E = timespec_init(i-1, 200);
 503                 struct timespec c;
 504
 505                 c = sub_tspec_ns(a, NANOSECONDS - 100);
 506                 TEST_ASSERT_EQUAL_timespec(E, c);
 507         }
 508
 509         return;
 510 }
 511
 512 //----------------------------------------------------------------------
 513 // test negation
 514 //----------------------------------------------------------------------
 515
 516
 517 void
 518 test_Neg(void)
 519 {
 520         int i;
 521
 522         for (i = -4; i <= 4; ++i) {
 523                 struct timespec a = timespec_init(i, 100);
 524                 struct timespec b;
 525                 struct timespec c;
 526
 527                 b = neg_tspec(a);
 528                 c = add_tspec(a, b);
 529                 TEST_ASSERT_EQUAL(0, test_tspec(c));
 530         }
 531
 532         return;
 533 }
 534
 535 //----------------------------------------------------------------------
 536 // test abs value
 537 //----------------------------------------------------------------------
 538
 539 void
 540 test_AbsNoFrac(void)
 541 {
 542         int i;
 543
 544         for (i = -4; i <= 4; ++i) {
 545                 struct timespec a = timespec_init(i , 0);
 546                 struct timespec b;
 547
 548                 b = abs_tspec(a);
 549                 TEST_ASSERT_EQUAL((i != 0), test_tspec(b));
 550         }
 551
 552         return;
 553 }
 554
 555
 556 void
 557 test_AbsWithFrac(void)
 558 {
 559         int i;
 560
 561         for (i = -4; i <= 4; ++i) {
 562                 struct timespec a = timespec_init(i, 100);
 563                 struct timespec b;
 564
 565                 b = abs_tspec(a);
 566                 TEST_ASSERT_EQUAL(1, test_tspec(b));
 567         }
 568
 569         return;
 570 }
 571
 572 // ---------------------------------------------------------------------
 573 // test support stuff -- part 2
 574 // ---------------------------------------------------------------------
 575
 576 void
 577 test_Helpers2(void)
 578 {
 579         struct timespec limit = timespec_init(0, 2);
 580         struct timespec x, y;
 581         long i;
 582
 583         for (x.tv_sec = -2; x.tv_sec < 3; x.tv_sec++)
 584                 for (x.tv_nsec = 1;
 585                      x.tv_nsec < 1000000000;
 586                      x.tv_nsec += 499999999) {
 587                         for (i = -4; i < 5; ++i) {
 588                                 y = x;
 589                                 y.tv_nsec += i;
 590                                 if (i >= -2 && i <= 2) {
 591                                         TEST_ASSERT_TRUE(AssertTimespecClose(x, y, limit));
 592                                 }
 593                                 else
 594                                 {
 595                                         TEST_ASSERT_FALSE(AssertTimespecClose(x, y, limit));
 596                                 }
 597                         }
 598                 }
 599
 600         return;
 601 }
 602
 603 //----------------------------------------------------------------------
 604 // conversion to l_fp
 605 //----------------------------------------------------------------------
 606
 607 void
 608 test_ToLFPbittest(void)
 609 {
 610         l_fp lfpClose =  l_fp_init(0, 1);
 611         u_int32 i;
 612
 613         for (i = 0; i < 1000000000; i+=1000) {
 614                 struct timespec a = timespec_init(1, i);
 615                 l_fp E= l_fp_init(1, my_tick_to_tsf(i));
 616                 l_fp r;
 617
 618                 r = tspec_intv_to_lfp(a);
 619                 TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose));
 620         }
 621
 622         return;
 623 }
 624
 625
 626 void
 627 test_ToLFPrelPos(void)
 628 {
 629         int i;
 630
 631         for (i = 0; i < COUNTOF(fdata); ++i) {
 632                 struct timespec a = timespec_init(1, fdata[i].nsec);
 633                 l_fp E = l_fp_init(1, fdata[i].frac);
 634                 l_fp r;
 635
 636                 r = tspec_intv_to_lfp(a);
 637                 TEST_ASSERT_EQUAL_l_fp(E, r);
 638         }
 639
 640         return;
 641 }
 642
 643
 644 void
 645 test_ToLFPrelNeg(void)
 646 {
 647         int i;
 648
 649         for (i = 0; i < COUNTOF(fdata); ++i) {
 650                 struct timespec a = timespec_init(-1, fdata[i].nsec);
 651                 l_fp E = l_fp_init(~0, fdata[i].frac);
 652                 l_fp r;
 653
 654                 r = tspec_intv_to_lfp(a);
 655                 TEST_ASSERT_EQUAL_l_fp(E, r);
 656         }
 657
 658         return;
 659 }
 660
 661
 662 void
 663 test_ToLFPabs(void)
 664 {
 665         int i;
 666
 667         for (i = 0; i < COUNTOF(fdata); ++i) {
 668                 struct timespec a = timespec_init(1, fdata[i].nsec);
 669                 l_fp E = l_fp_init(1 + JAN_1970, fdata[i].frac);
 670                 l_fp r;
 671
 672                 r = tspec_stamp_to_lfp(a);
 673                 TEST_ASSERT_EQUAL_l_fp(E, r);
 674         }
 675
 676         return;
 677 }
 678
 679 //----------------------------------------------------------------------
 680 // conversion from l_fp
 681 //----------------------------------------------------------------------
 682
 683 void
 684 test_FromLFPbittest(void)
 685 {
 686         struct timespec limit = timespec_init(0, 2);
 687
 688         // Not *exactly* a bittest, because 2**32 tests would take a
 689         // really long time even on very fast machines! So we do test
 690         // every 1000 fractional units.
 691         u_int32 tsf;
 692         for (tsf = 0; tsf < ~((u_int32)(1000)); tsf += 1000) {
 693                 struct timespec E = timespec_init(1, my_tsf_to_tick(tsf));
 694                 l_fp a = l_fp_init(1, tsf);
 695                 struct timespec r;
 696
 697                 r = lfp_intv_to_tspec(a);
 698                 // The conversion might be off by one nanosecond when
 699                 // comparing to calculated value.
 700                 TEST_ASSERT_TRUE(AssertTimespecClose(E, r, limit));
 701         }
 702
 703         return;
 704 }
 705
 706
 707 void
 708 test_FromLFPrelPos(void)
 709 {
 710         struct timespec limit = timespec_init(0, 2);
 711         int i;
 712
 713         for (i = 0; i < COUNTOF(fdata); ++i) {
 714                 l_fp a = l_fp_init(1, fdata[i].frac);
 715                 struct timespec E = timespec_init(1, fdata[i].nsec);
 716                 struct timespec r;
 717
 718                 r = lfp_intv_to_tspec(a);
 719                 TEST_ASSERT_TRUE(AssertTimespecClose(E, r, limit));
 720         }
 721
 722         return;
 723 }
 724
 725
 726 void
 727 test_FromLFPrelNeg(void)
 728 {
 729         struct timespec limit = timespec_init(0, 2);
 730         int i;
 731
 732         for (i = 0; i < COUNTOF(fdata); ++i) {
 733                 l_fp a = l_fp_init(~0, fdata[i].frac);
 734                 struct timespec E = timespec_init(-1, fdata[i].nsec);
 735                 struct timespec r;
 736
 737                 r = lfp_intv_to_tspec(a);
 738                 TEST_ASSERT_TRUE(AssertTimespecClose(E, r, limit));
 739         }
 740
 741         return;
 742 }
 743
 744
 745 // nsec -> frac -> nsec roundtrip, using a prime start and increment
 746 void
 747 test_LFProundtrip(void)
 748 {
 749         int32_t t;
 750         u_int32 i;
 751
 752         for (t = -1; t < 2; ++t)
 753                 for (i = 4999; i < 1000000000; i += 10007) {
 754                         struct timespec E = timespec_init(t, i);
 755                         l_fp a;
 756                         struct timespec r;
 757
 758                         a = tspec_intv_to_lfp(E);
 759                         r = lfp_intv_to_tspec(a);
 760                         TEST_ASSERT_EQUAL_timespec(E, r);
 761                 }
 762
 763         return;
 764 }
 765
 766 //----------------------------------------------------------------------
 767 // string formatting
 768 //----------------------------------------------------------------------
 769
 770 void
 771 test_ToString(void)
 772 {
 773         static const struct {
 774                 time_t          sec;
 775                 long            nsec;
 776                 const char *    repr;
 777         } data [] = {
 778                 { 0, 0,  "0.000000000" },
 779                 { 2, 0,  "2.000000000" },
 780                 {-2, 0, "-2.000000000" },
 781                 { 0, 1,  "0.000000001" },
 782                 { 0,-1, "-0.000000001" },
 783                 { 1,-1,  "0.999999999" },
 784                 {-1, 1, "-0.999999999" },
 785                 {-1,-1, "-1.000000001" },
 786         };
 787         int i;
 788
 789         for (i = 0; i < COUNTOF(data); ++i) {
 790                 struct timespec a = timespec_init(data[i].sec, data[i].nsec);
 791                 const char * E = data[i].repr;
 792                 const char * r = tspectoa(a);
 793                 TEST_ASSERT_EQUAL_STRING(E, r);
 794         }
 795
 796         return;
 797 }
 798
 799 // -*- EOF -*-