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