contrib/ntp/tests/libntp/timevalops.c

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