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