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