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 20static u_int32 my_tick_to_tsf(u_int32 ticks); 21static u_int32 my_tsf_to_tick(u_int32 tsf); 22 23 24// that's it... 25typedef struct { 26 long usec; 27 u_int32 frac; 28} lfpfracdata ; 29 30struct timeval timeval_init( time_t hi, long lo); 31const bool timeval_isValid(struct timeval V); 32l_fp l_fp_init(int32 i, u_int32 f); 33bool AssertTimevalClose(const struct timeval m, const struct timeval n, const struct timeval limit); 34bool AssertFpClose(const l_fp m, const l_fp n, const l_fp limit); 35 36void setUp(void); 37void test_Helpers1(void); 38void test_Normalise(void); 39void test_SignNoFrac(void); 40void test_SignWithFrac(void); 41void test_CmpFracEQ(void); 42void test_CmpFracGT(void); 43void test_CmpFracLT(void); 44void test_AddFullNorm(void); 45void test_AddFullOflow1(void); 46void test_AddUsecNorm(void); 47void test_AddUsecOflow1(void); 48void test_SubFullNorm(void); 49void test_SubFullOflow(void); 50void test_SubUsecNorm(void); 51void test_SubUsecOflow(void); 52void test_Neg(void); 53void test_AbsNoFrac(void); 54void test_AbsWithFrac(void); 55void test_Helpers2(void); 56void test_ToLFPbittest(void); 57void test_ToLFPrelPos(void); 58void test_ToLFPrelNeg(void); 59void test_ToLFPabs(void); 60void test_FromLFPbittest(void); 61void test_FromLFPrelPos(void); 62void test_FromLFPrelNeg(void); 63void test_LFProundtrip(void); 64void test_ToString(void); 65 66 67//**********************************MY CUSTOM FUNCTIONS*********************** 68 69 70void 71setUp(void) 72{ 73 init_lib(); 74 75 return; 76} 77 78 79struct timeval 80timeval_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 91const bool 92timeval_isValid(struct timeval V) 93{ 94 95 return V.tv_usec >= 0 && V.tv_usec < 1000000; 96} 97 98 99l_fp 100l_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 111bool 112AssertTimevalClose(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 129bool 130AssertFpClose(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 154static 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 172u_int32 173my_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 190u_int32 191my_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 210void 211test_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 234void 235test_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 253void 254test_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 271void 272test_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//---------------------------------------------------------------------- 291void 292test_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 311void 312test_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 331void 332test_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 354void 355test_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 374void 375test_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 394void 395test_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 412void 413test_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 433void 434test_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 453void 454test_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 473void 474test_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 491void 492test_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 512void 513test_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 534void 535test_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 551void 552test_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 572void 573test_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 608void 609test_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 627void 628test_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 646void 647test_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 665void 666test_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 687void 688test_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 711void 712test_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 730void 731test_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 750void 751test_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 774void 775test_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 -*- 805