contrib/ntp/tests/libntp/g_timevalops.cpp

   1 #include "g_libntptest.h"
   2 #include "g_timestructs.h"
   3
   4 extern "C" {
   5 #include <math.h>
   6 #include "timevalops.h"
   7 }
   8
   9 #include <string>
  10 #include <sstream>
  11
  12 using namespace timeStruct;
  13
  14 class timevalTest : public libntptest {
  15 protected:
  16         static u_int32 my_tick_to_tsf(u_int32 ticks);
  17         static u_int32 my_tsf_to_tick(u_int32 tsf);
  18
  19         // that's it...
  20         struct lfpfracdata {
  21                 long    usec;
  22                 u_int32 frac;
  23         };
  24         static const lfpfracdata fdata[];
  25 };
  26
  27 u_int32
  28 timevalTest::my_tick_to_tsf(
  29         u_int32 ticks
  30         )
  31 {
  32         // convert microseconds to l_fp fractional units, using double
  33         // precision float calculations or, if available, 64bit integer
  34         // arithmetic. This should give the precise fraction, rounded to
  35         // the nearest representation.
  36 #ifdef HAVE_U_INT64
  37         return u_int32(((u_int64(ticks) << 32) + 500000) / 1000000);
  38 #else
  39         return u_int32(double(ticks) * 4294.967296 + 0.5);
  40 #endif
  41         // And before you ask: if ticks >= 1000000, the result is
  42         // truncated nonsense, so don't use it out-of-bounds.
  43 }
  44
  45 u_int32
  46 timevalTest::my_tsf_to_tick(
  47         u_int32 tsf
  48         )
  49 {
  50         // Inverse operation: converts fraction to microseconds.
  51 #ifdef HAVE_U_INT64
  52         return u_int32((u_int64(tsf) * 1000000 + 0x80000000) >> 32);
  53 #else
  54         return u_int32(double(tsf) / 4294.967296 + 0.5);
  55 #endif
  56         // Beware: The result might be 10^6 due to rounding!
  57 }
  58
  59 const timevalTest::lfpfracdata timevalTest::fdata [] = {
  60         {      0, 0x00000000 }, {   7478, 0x01ea1405 },
  61         {  22077, 0x05a6d699 }, { 125000, 0x20000000 },
  62         { 180326, 0x2e29d841 }, { 207979, 0x353e1c9b },
  63         { 250000, 0x40000000 }, { 269509, 0x44fe8ab5 },
  64         { 330441, 0x5497c808 }, { 333038, 0x5541fa76 },
  65         { 375000, 0x60000000 }, { 394734, 0x650d4995 },
  66         { 446327, 0x72427c7c }, { 500000, 0x80000000 },
  67         { 517139, 0x846338b4 }, { 571953, 0x926b8306 },
  68         { 587353, 0x965cc426 }, { 625000, 0xa0000000 },
  69         { 692136, 0xb12fd32c }, { 750000, 0xc0000000 },
  70         { 834068, 0xd5857aff }, { 848454, 0xd9344806 },
  71         { 854222, 0xdaae4b02 }, { 861465, 0xdc88f862 },
  72         { 875000, 0xe0000000 }, { 910661, 0xe921144d },
  73         { 922162, 0xec12cf10 }, { 942190, 0xf1335d25 }
  74 };
  75
  76
  77 // ---------------------------------------------------------------------
  78 // test support stuff - part1
  79 // ---------------------------------------------------------------------
  80
  81 TEST_F(timevalTest, Helpers1) {
  82         timeval_wrap x;
  83
  84         for (x.V.tv_sec = -2; x.V.tv_sec < 3; x.V.tv_sec++) {
  85                 x.V.tv_usec = -1;
  86                 ASSERT_FALSE(x.valid());
  87                 x.V.tv_usec = 0;
  88                 ASSERT_TRUE(x.valid());
  89                 x.V.tv_usec = 999999;
  90                 ASSERT_TRUE(x.valid());
  91                 x.V.tv_usec = 1000000;
  92                 ASSERT_FALSE(x.valid());
  93         }
  94 }
  95
  96 //----------------------------------------------------------------------
  97 // test normalisation
  98 //----------------------------------------------------------------------
  99
 100 TEST_F(timevalTest, Normalise) {
 101         for (long ns = -2000000000; ns <= 2000000000; ns += 10000000) {
 102                 timeval_wrap x(0, ns);
 103
 104                 x = normalize_tval(x);
 105                 ASSERT_TRUE(x.valid());
 106         }
 107 }
 108
 109 //----------------------------------------------------------------------
 110 // test classification
 111 //----------------------------------------------------------------------
 112
 113 TEST_F(timevalTest, SignNoFrac) {
 114         // sign test, no fraction
 115         for (int i = -4; i <= 4; ++i) {
 116                 timeval_wrap a(i, 0);
 117                 int          E = (i > 0) - (i < 0);
 118                 int          r = test_tval(a);
 119
 120                 ASSERT_EQ(E, r);
 121         }
 122 }
 123
 124 TEST_F(timevalTest, SignWithFrac) {
 125         // sign test, with fraction
 126         for (int i = -4; i <= 4; ++i) {
 127                 timeval_wrap a(i, 10);
 128                 int          E = (i >= 0) - (i < 0);
 129                 int          r = test_tval(a);
 130
 131                 ASSERT_EQ(E, r);
 132         }
 133 }
 134
 135 //----------------------------------------------------------------------
 136 // test compare
 137 //----------------------------------------------------------------------
 138 TEST_F(timevalTest, CmpFracEQ) {
 139         // fractions are equal
 140         for (int i = -4; i <= 4; ++i)
 141                 for (int j = -4; j <= 4; ++j) {
 142                         timeval_wrap a(i, 200);
 143                         timeval_wrap b(j, 200);
 144                         int          E = (i > j) - (i < j);
 145                         int          r = cmp_tval_denorm(a, b);
 146
 147                         ASSERT_EQ(E, r);
 148                 }
 149 }
 150
 151 TEST_F(timevalTest, CmpFracGT) {
 152         // fraction a bigger fraction b
 153         for (int i = -4; i <= 4; ++i)
 154                 for (int j = -4; j <= 4; ++j) {
 155                         timeval_wrap a( i , 999800);
 156                         timeval_wrap b( j , 200);
 157                         int          E = (i >= j) - (i < j);
 158                         int          r = cmp_tval_denorm(a, b);
 159
 160                         ASSERT_EQ(E, r);
 161                 }
 162 }
 163
 164 TEST_F(timevalTest, CmpFracLT) {
 165         // fraction a less fraction b
 166         for (int i = -4; i <= 4; ++i)
 167                 for (int j = -4; j <= 4; ++j) {
 168                         timeval_wrap a(i, 200);
 169                         timeval_wrap b(j, 999800);
 170                         int          E = (i > j) - (i <= j);
 171                         int          r = cmp_tval_denorm(a, b);
 172
 173                         ASSERT_EQ(E, r);
 174                 }
 175 }
 176
 177 //----------------------------------------------------------------------
 178 // Test addition (sum)
 179 //----------------------------------------------------------------------
 180
 181 TEST_F(timevalTest, AddFullNorm) {
 182         for (int i = -4; i <= 4; ++i)
 183                 for (int j = -4; j <= 4; ++j) {
 184                         timeval_wrap a(i, 200);
 185                         timeval_wrap b(j, 400);
 186                         timeval_wrap E(i + j, 200 + 400);
 187                         timeval_wrap c;
 188
 189                         c = add_tval(a, b);
 190                         ASSERT_EQ(E, c);
 191                 }
 192 }
 193
 194 TEST_F(timevalTest, AddFullOflow1) {
 195         for (int i = -4; i <= 4; ++i)
 196                 for (int j = -4; j <= 4; ++j) {
 197                         timeval_wrap a(i, 200);
 198                         timeval_wrap b(j, 999900);
 199                         timeval_wrap E(i + j + 1, 100);
 200                         timeval_wrap c;
 201
 202                         c = add_tval(a, b);
 203                         ASSERT_EQ(E, c);
 204                 }
 205 }
 206
 207 TEST_F(timevalTest, AddUsecNorm) {
 208         for (int i = -4; i <= 4; ++i) {
 209                 timeval_wrap a(i, 200);
 210                 timeval_wrap E(i, 600);
 211                 timeval_wrap c;
 212
 213                 c = add_tval_us(a, 600 - 200);
 214                 ASSERT_EQ(E, c);
 215         }
 216 }
 217
 218 TEST_F(timevalTest, AddUsecOflow1) {
 219         for (int i = -4; i <= 4; ++i) {
 220                 timeval_wrap a(i, 200);
 221                 timeval_wrap E(i + 1, 100);
 222                 timeval_wrap c;
 223
 224                 c = add_tval_us(a, MICROSECONDS - 100);
 225                 ASSERT_EQ(E, c);
 226         }
 227 }
 228
 229 //----------------------------------------------------------------------
 230 // test subtraction (difference)
 231 //----------------------------------------------------------------------
 232
 233 TEST_F(timevalTest, SubFullNorm) {
 234         for (int i = -4; i <= 4; ++i)
 235                 for (int j = -4; j <= 4; ++j) {
 236                         timeval_wrap a(i, 600);
 237                         timeval_wrap b(j, 400);
 238                         timeval_wrap E(i - j, 600 - 400);
 239                         timeval_wrap c;
 240
 241                         c = sub_tval(a, b);
 242                         ASSERT_EQ(E, c);
 243                 }
 244 }
 245
 246 TEST_F(timevalTest, SubFullOflow) {
 247         for (int i = -4; i <= 4; ++i)
 248                 for (int j = -4; j <= 4; ++j) {
 249                         timeval_wrap a(i, 100);
 250                         timeval_wrap b(j, 999900);
 251                         timeval_wrap E(i - j - 1, 200);
 252                         timeval_wrap c;
 253
 254                         c = sub_tval(a, b);
 255                         ASSERT_EQ(E, c);
 256                 }
 257 }
 258
 259 TEST_F(timevalTest, SubUsecNorm) {
 260         for (int i = -4; i <= 4; ++i) {
 261                 timeval_wrap a(i, 600);
 262                 timeval_wrap E(i, 200);
 263                 timeval_wrap c;
 264
 265                 c = sub_tval_us(a, 600 - 200);
 266                 ASSERT_EQ(E, c);
 267         }
 268 }
 269
 270 TEST_F(timevalTest, SubUsecOflow) {
 271         for (int i = -4; i <= 4; ++i) {
 272                 timeval_wrap a(i, 100);
 273                 timeval_wrap E(i - 1, 200);
 274                 timeval_wrap c;
 275
 276                 c = sub_tval_us(a, MICROSECONDS - 100);
 277                 ASSERT_EQ(E, c);
 278         }
 279 }
 280
 281 //----------------------------------------------------------------------
 282 // test negation
 283 //----------------------------------------------------------------------
 284
 285 TEST_F(timevalTest, Neg) {
 286         for (int i = -4; i <= 4; ++i) {
 287                 timeval_wrap a(i, 100);
 288                 timeval_wrap b;
 289                 timeval_wrap c;
 290
 291                 b = neg_tval(a);
 292                 c = add_tval(a, b);
 293                 ASSERT_EQ(0, test_tval(c));
 294         }
 295 }
 296
 297 //----------------------------------------------------------------------
 298 // test abs value
 299 //----------------------------------------------------------------------
 300
 301 TEST_F(timevalTest, AbsNoFrac) {
 302         for (int i = -4; i <= 4; ++i) {
 303                 timeval_wrap a(i, 0);
 304                 timeval_wrap b;
 305
 306                 b = abs_tval(a);
 307                 ASSERT_EQ((i != 0), test_tval(b));
 308         }
 309 }
 310
 311 TEST_F(timevalTest, AbsWithFrac) {
 312         for (int i = -4; i <= 4; ++i) {
 313                 timeval_wrap a(i, 100);
 314                 timeval_wrap b;
 315
 316                 b = abs_tval(a);
 317                 ASSERT_EQ(1, test_tval(b));
 318         }
 319 }
 320
 321 // ---------------------------------------------------------------------
 322 // test support stuff -- part 2
 323 // ---------------------------------------------------------------------
 324
 325 TEST_F(timevalTest, Helpers2) {
 326         AssertTimevalClose isClose(0, 2);
 327         timeval_wrap x, y;
 328
 329         for (x.V.tv_sec = -2; x.V.tv_sec < 3; x.V.tv_sec++)
 330                 for (x.V.tv_usec = 1;
 331                      x.V.tv_usec < 1000000;
 332                      x.V.tv_usec += 499999) {
 333                         for (long i = -4; i < 5; i++) {
 334                                 y = x;
 335                                 y.V.tv_usec += i;
 336                                 if (i >= -2 && i <= 2)
 337                                         ASSERT_PRED_FORMAT2(isClose, x, y);
 338                                 else
 339                                         ASSERT_PRED_FORMAT2(!isClose, x, y);
 340                         }
 341                 }
 342 }
 343
 344 // and the global predicate instances we're using here
 345 static AssertFpClose FpClose(0, 1);
 346 static AssertTimevalClose TimevalClose(0, 1);
 347
 348 //----------------------------------------------------------------------
 349 // conversion to l_fp
 350 //----------------------------------------------------------------------
 351
 352 TEST_F(timevalTest, ToLFPbittest) {
 353         for (u_int32 i = 0; i < 1000000; i++) {
 354                 timeval_wrap a(1, i);
 355                 l_fp_wrap    E(1, my_tick_to_tsf(i));
 356                 l_fp_wrap    r;
 357
 358                 r = tval_intv_to_lfp(a);
 359                 ASSERT_PRED_FORMAT2(FpClose, E, r);
 360         }
 361 }
 362
 363 TEST_F(timevalTest, ToLFPrelPos) {
 364         for (int i = 0; i < COUNTOF(fdata); i++) {
 365                 timeval_wrap a(1, fdata[i].usec);
 366                 l_fp_wrap    E(1, fdata[i].frac);
 367                 l_fp_wrap    r;
 368
 369                 r = tval_intv_to_lfp(a);
 370                 ASSERT_PRED_FORMAT2(FpClose, E, r);
 371         }
 372 }
 373
 374 TEST_F(timevalTest, ToLFPrelNeg) {
 375         for (int i = 0; i < COUNTOF(fdata); i++) {
 376                 timeval_wrap a(-1, fdata[i].usec);
 377                 l_fp_wrap    E(~0, fdata[i].frac);
 378                 l_fp_wrap    r;
 379
 380                 r = tval_intv_to_lfp(a);
 381                 ASSERT_PRED_FORMAT2(FpClose, E, r);
 382         }
 383 }
 384
 385 TEST_F(timevalTest, ToLFPabs) {
 386         for (int i = 0; i < COUNTOF(fdata); i++) {
 387                 timeval_wrap a(1, fdata[i].usec);
 388                 l_fp_wrap    E(1 + JAN_1970, fdata[i].frac);
 389                 l_fp_wrap    r;
 390
 391                 r = tval_stamp_to_lfp(a);
 392                 ASSERT_PRED_FORMAT2(FpClose, E, r);
 393         }
 394 }
 395
 396 //----------------------------------------------------------------------
 397 // conversion from l_fp
 398 //----------------------------------------------------------------------
 399
 400 TEST_F(timevalTest, FromLFPbittest) {
 401         // Not *exactly* a bittest, because 2**32 tests would take a
 402         // really long time even on very fast machines! So we do test
 403         // every 1000 fractional units.
 404         for (u_int32 tsf = 0; tsf < ~u_int32(1000); tsf += 1000) {
 405                 timeval_wrap E(1, my_tsf_to_tick(tsf));
 406                 l_fp_wrap    a(1, tsf);
 407                 timeval_wrap r;
 408
 409                 r = lfp_intv_to_tval(a);
 410                 // The conversion might be off by one microsecond when
 411                 // comparing to calculated value.
 412                 ASSERT_PRED_FORMAT2(TimevalClose, E, r);
 413         }
 414 }
 415
 416 TEST_F(timevalTest, FromLFPrelPos) {
 417         for (int i = 0; i < COUNTOF(fdata); i++) {
 418                 l_fp_wrap    a(1, fdata[i].frac);
 419                 timeval_wrap E(1, fdata[i].usec);
 420                 timeval_wrap r;
 421
 422                 r = lfp_intv_to_tval(a);
 423                 ASSERT_PRED_FORMAT2(TimevalClose, E, r);
 424         }
 425 }
 426
 427 TEST_F(timevalTest, FromLFPrelNeg) {
 428         for (int i = 0; i < COUNTOF(fdata); i++) {
 429                 l_fp_wrap    a(~0, fdata[i].frac);
 430                 timeval_wrap E(-1, fdata[i].usec);
 431                 timeval_wrap r;
 432
 433                 r = lfp_intv_to_tval(a);
 434                 ASSERT_PRED_FORMAT2(TimevalClose, E, r);
 435         }
 436 }
 437
 438 // usec -> frac -> usec roundtrip, using a prime start and increment
 439 TEST_F(timevalTest, LFProundtrip) {
 440         for (int32_t t = -1; t < 2; ++t)
 441                 for (u_int32 i = 5; i < 1000000; i+=11) {
 442                         timeval_wrap E(t, i);
 443                         l_fp_wrap    a;
 444                         timeval_wrap r;
 445
 446                         a = tval_intv_to_lfp(E);
 447                         r = lfp_intv_to_tval(a);
 448                         ASSERT_EQ(E, r);
 449                 }
 450 }
 451
 452 //----------------------------------------------------------------------
 453 // string formatting
 454 //----------------------------------------------------------------------
 455
 456 TEST_F(timevalTest, ToString) {
 457         static const struct {
 458                 time_t       sec;
 459                 long         usec;
 460                 const char * repr;
 461         } data [] = {
 462                 { 0, 0,  "0.000000" },
 463                 { 2, 0,  "2.000000" },
 464                 {-2, 0, "-2.000000" },
 465                 { 0, 1,  "0.000001" },
 466                 { 0,-1, "-0.000001" },
 467                 { 1,-1,  "0.999999" },
 468                 {-1, 1, "-0.999999" },
 469                 {-1,-1, "-1.000001" },
 470         };
 471         for (int i = 0; i < COUNTOF(data); ++i) {
 472                 timeval_wrap a(data[i].sec, data[i].usec);
 473                 std::string  E(data[i].repr);
 474                 std::string  r(tvaltoa(a));
 475
 476                 ASSERT_EQ(E, r);
 477         }
 478 }
 479
 480 // -*- EOF -*-