1290001Sglebius#include "config.h" 2290001Sglebius 3290001Sglebius//some unused features are still in the wrapper, unconverted 4290001Sglebius 5290001Sglebius#include "ntp_types.h" 6290001Sglebius#include "ntp_fp.h" 7290001Sglebius 8290001Sglebius#include "timevalops.h" 9290001Sglebius 10290001Sglebius#include <math.h> 11290001Sglebius#include "unity.h" 12290001Sglebius 13290001Sglebius 14293896Sglebius#define TEST_ASSERT_EQUAL_timeval(a, b) { \ 15293896Sglebius TEST_ASSERT_EQUAL_MESSAGE(a.tv_sec, b.tv_sec, "Field tv_sec"); \ 16290001Sglebius TEST_ASSERT_EQUAL_MESSAGE(a.tv_usec, b.tv_usec, "Field tv_usec"); \ 17290001Sglebius} 18290001Sglebius 19290001Sglebius 20290001Sglebiusstatic u_int32 my_tick_to_tsf(u_int32 ticks); 21290001Sglebiusstatic u_int32 my_tsf_to_tick(u_int32 tsf); 22290001Sglebius 23290001Sglebius 24290001Sglebius// that's it... 25290001Sglebiustypedef struct { 26290001Sglebius long usec; 27290001Sglebius u_int32 frac; 28290001Sglebius} lfpfracdata ; 29290001Sglebius 30290001Sglebiusstruct timeval timeval_init( time_t hi, long lo); 31290001Sglebiusconst bool timeval_isValid(struct timeval V); 32290001Sglebiusl_fp l_fp_init(int32 i, u_int32 f); 33290001Sglebiusbool AssertTimevalClose(const struct timeval m, const struct timeval n, const struct timeval limit); 34290001Sglebiusbool AssertFpClose(const l_fp m, const l_fp n, const l_fp limit); 35290001Sglebius 36293896Sglebiusvoid setUp(void); 37290001Sglebiusvoid test_Helpers1(void); 38290001Sglebiusvoid test_Normalise(void); 39290001Sglebiusvoid test_SignNoFrac(void); 40290001Sglebiusvoid test_SignWithFrac(void); 41290001Sglebiusvoid test_CmpFracEQ(void); 42290001Sglebiusvoid test_CmpFracGT(void); 43290001Sglebiusvoid test_CmpFracLT(void); 44290001Sglebiusvoid test_AddFullNorm(void); 45290001Sglebiusvoid test_AddFullOflow1(void); 46290001Sglebiusvoid test_AddUsecNorm(void); 47290001Sglebiusvoid test_AddUsecOflow1(void); 48290001Sglebiusvoid test_SubFullNorm(void); 49290001Sglebiusvoid test_SubFullOflow(void); 50290001Sglebiusvoid test_SubUsecNorm(void); 51290001Sglebiusvoid test_SubUsecOflow(void); 52290001Sglebiusvoid test_Neg(void); 53290001Sglebiusvoid test_AbsNoFrac(void); 54290001Sglebiusvoid test_AbsWithFrac(void); 55290001Sglebiusvoid test_Helpers2(void); 56290001Sglebiusvoid test_ToLFPbittest(void); 57290001Sglebiusvoid test_ToLFPrelPos(void); 58290001Sglebiusvoid test_ToLFPrelNeg(void); 59290001Sglebiusvoid test_ToLFPabs(void); 60290001Sglebiusvoid test_FromLFPbittest(void); 61290001Sglebiusvoid test_FromLFPrelPos(void); 62290001Sglebiusvoid test_FromLFPrelNeg(void); 63290001Sglebiusvoid test_LFProundtrip(void); 64290001Sglebiusvoid test_ToString(void); 65290001Sglebius 66290001Sglebius 67293896Sglebius//**********************************MY CUSTOM FUNCTIONS*********************** 68290001Sglebius 69290001Sglebius 70293896Sglebiusvoid 71293896SglebiussetUp(void) 72293896Sglebius{ 73293896Sglebius init_lib(); 74290001Sglebius 75293896Sglebius return; 76293896Sglebius} 77293896Sglebius 78293896Sglebius 79290001Sglebiusstruct timeval 80293896Sglebiustimeval_init(time_t hi, long lo) 81293896Sglebius{ 82290001Sglebius struct timeval V; 83293896Sglebius 84290001Sglebius V.tv_sec = hi; 85290001Sglebius V.tv_usec = lo; 86293896Sglebius 87290001Sglebius return V; 88290001Sglebius} 89290001Sglebius 90290001Sglebius 91290001Sglebiusconst bool 92293896Sglebiustimeval_isValid(struct timeval V) 93293896Sglebius{ 94293896Sglebius 95290001Sglebius return V.tv_usec >= 0 && V.tv_usec < 1000000; 96290001Sglebius} 97290001Sglebius 98290001Sglebius 99290001Sglebiusl_fp 100293896Sglebiusl_fp_init(int32 i, u_int32 f) 101293896Sglebius{ 102290001Sglebius l_fp temp; 103293896Sglebius 104290001Sglebius temp.l_i = i; 105290001Sglebius temp.l_uf = f; 106290001Sglebius 107290001Sglebius return temp; 108290001Sglebius} 109290001Sglebius 110290001Sglebius 111290001Sglebiusbool 112293896SglebiusAssertTimevalClose(const struct timeval m, const struct timeval n, const struct timeval limit) 113293896Sglebius{ 114290001Sglebius struct timeval diff; 115290001Sglebius 116290001Sglebius diff = abs_tval(sub_tval(m, n)); 117290001Sglebius if (cmp_tval(limit, diff) >= 0) 118290001Sglebius return TRUE; 119290001Sglebius else 120290001Sglebius { 121290001Sglebius 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); 122290001Sglebius //I don't have variables m_expr and n_expr in unity, those are command line arguments which only getst has!!! 123293896Sglebius 124290001Sglebius return FALSE; 125290001Sglebius } 126290001Sglebius} 127290001Sglebius 128290001Sglebius 129290001Sglebiusbool 130293896SglebiusAssertFpClose(const l_fp m, const l_fp n, const l_fp limit) 131293896Sglebius{ 132290001Sglebius l_fp diff; 133290001Sglebius 134290001Sglebius if (L_ISGEQ(&m, &n)) { 135290001Sglebius diff = m; 136290001Sglebius L_SUB(&diff, &n); 137290001Sglebius } else { 138290001Sglebius diff = n; 139290001Sglebius L_SUB(&diff, &m); 140290001Sglebius } 141293896Sglebius if (L_ISGEQ(&limit, &diff)) { 142290001Sglebius return TRUE; 143290001Sglebius } 144290001Sglebius else { 145290001Sglebius 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)); 146290001Sglebius //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); 147290001Sglebius return FALSE; 148290001Sglebius } 149290001Sglebius} 150290001Sglebius 151290001Sglebius 152290001Sglebius//--------------------------------------------------- 153290001Sglebius 154290001Sglebiusstatic const lfpfracdata fdata[] = { 155290001Sglebius { 0, 0x00000000 }, { 7478, 0x01ea1405 }, 156290001Sglebius { 22077, 0x05a6d699 }, { 125000, 0x20000000 }, 157290001Sglebius { 180326, 0x2e29d841 }, { 207979, 0x353e1c9b }, 158290001Sglebius { 250000, 0x40000000 }, { 269509, 0x44fe8ab5 }, 159290001Sglebius { 330441, 0x5497c808 }, { 333038, 0x5541fa76 }, 160290001Sglebius { 375000, 0x60000000 }, { 394734, 0x650d4995 }, 161290001Sglebius { 446327, 0x72427c7c }, { 500000, 0x80000000 }, 162290001Sglebius { 517139, 0x846338b4 }, { 571953, 0x926b8306 }, 163290001Sglebius { 587353, 0x965cc426 }, { 625000, 0xa0000000 }, 164290001Sglebius { 692136, 0xb12fd32c }, { 750000, 0xc0000000 }, 165290001Sglebius { 834068, 0xd5857aff }, { 848454, 0xd9344806 }, 166290001Sglebius { 854222, 0xdaae4b02 }, { 861465, 0xdc88f862 }, 167290001Sglebius { 875000, 0xe0000000 }, { 910661, 0xe921144d }, 168290001Sglebius { 922162, 0xec12cf10 }, { 942190, 0xf1335d25 } 169290001Sglebius}; 170290001Sglebius 171290001Sglebius 172290001Sglebiusu_int32 173293896Sglebiusmy_tick_to_tsf(u_int32 ticks) 174293896Sglebius{ 175290001Sglebius // convert microseconds to l_fp fractional units, using double 176290001Sglebius // precision float calculations or, if available, 64bit integer 177290001Sglebius // arithmetic. This should give the precise fraction, rounded to 178290001Sglebius // the nearest representation. 179293896Sglebius 180290001Sglebius#ifdef HAVE_U_INT64 181290001Sglebius return (u_int32)((( ((u_int64)(ticks)) << 32) + 500000) / 1000000); //I put too much () when casting just to be safe 182290001Sglebius#else 183290001Sglebius return (u_int32)( ((double)(ticks)) * 4294.967296 + 0.5); 184290001Sglebius#endif 185290001Sglebius // And before you ask: if ticks >= 1000000, the result is 186290001Sglebius // truncated nonsense, so don't use it out-of-bounds. 187290001Sglebius} 188290001Sglebius 189290001Sglebius 190290001Sglebiusu_int32 191293896Sglebiusmy_tsf_to_tick(u_int32 tsf) 192293896Sglebius{ 193290001Sglebius // Inverse operation: converts fraction to microseconds. 194290001Sglebius#ifdef HAVE_U_INT64 195290001Sglebius return (u_int32)( ((u_int64)(tsf) * 1000000 + 0x80000000) >> 32); //CHECK ME!!! 196290001Sglebius#else 197290001Sglebius return (u_int32)(double(tsf) / 4294.967296 + 0.5); 198290001Sglebius#endif 199290001Sglebius // Beware: The result might be 10^6 due to rounding! 200290001Sglebius} 201290001Sglebius 202290001Sglebius 203293896Sglebius//*******************************END OF CUSTOM FUNCTIONS********************* 204290001Sglebius 205290001Sglebius 206290001Sglebius// --------------------------------------------------------------------- 207290001Sglebius// test support stuff - part1 208290001Sglebius// --------------------------------------------------------------------- 209290001Sglebius 210290001Sglebiusvoid 211293896Sglebiustest_Helpers1(void) 212293896Sglebius{ 213290001Sglebius struct timeval x; 214290001Sglebius 215290001Sglebius for (x.tv_sec = -2; x.tv_sec < 3; x.tv_sec++) { 216290001Sglebius x.tv_usec = -1; 217290001Sglebius TEST_ASSERT_FALSE(timeval_isValid(x)); 218290001Sglebius x.tv_usec = 0; 219290001Sglebius TEST_ASSERT_TRUE(timeval_isValid(x)); 220290001Sglebius x.tv_usec = 999999; 221290001Sglebius TEST_ASSERT_TRUE(timeval_isValid(x)); 222290001Sglebius x.tv_usec = 1000000; 223290001Sglebius TEST_ASSERT_FALSE(timeval_isValid(x)); 224290001Sglebius } 225293896Sglebius 226293896Sglebius return; 227290001Sglebius} 228290001Sglebius 229290001Sglebius 230290001Sglebius//---------------------------------------------------------------------- 231290001Sglebius// test normalisation 232290001Sglebius//---------------------------------------------------------------------- 233290001Sglebius 234290001Sglebiusvoid 235293896Sglebiustest_Normalise(void) 236293896Sglebius{ 237290001Sglebius long ns; 238293896Sglebius 239290001Sglebius for (ns = -2000000000; ns <= 2000000000; ns += 10000000) { 240290001Sglebius struct timeval x = timeval_init(0, ns); 241293896Sglebius 242290001Sglebius x = normalize_tval(x); 243290001Sglebius TEST_ASSERT_TRUE(timeval_isValid(x)); 244290001Sglebius } 245293896Sglebius 246293896Sglebius return; 247290001Sglebius} 248290001Sglebius 249290001Sglebius//---------------------------------------------------------------------- 250290001Sglebius// test classification 251290001Sglebius//---------------------------------------------------------------------- 252290001Sglebius 253290001Sglebiusvoid 254293896Sglebiustest_SignNoFrac(void) 255293896Sglebius{ 256290001Sglebius int i; 257293896Sglebius 258290001Sglebius // sign test, no fraction 259290001Sglebius for (i = -4; i <= 4; ++i) { 260290001Sglebius struct timeval a = timeval_init(i, 0); 261290001Sglebius int E = (i > 0) - (i < 0); 262290001Sglebius int r = test_tval(a); 263290001Sglebius 264290001Sglebius TEST_ASSERT_EQUAL(E, r); 265290001Sglebius } 266293896Sglebius 267293896Sglebius return; 268290001Sglebius} 269290001Sglebius 270290001Sglebius 271290001Sglebiusvoid 272293896Sglebiustest_SignWithFrac(void) 273293896Sglebius{ 274290001Sglebius // sign test, with fraction 275290001Sglebius int i; 276293896Sglebius 277290001Sglebius for (i = -4; i <= 4; ++i) { 278290001Sglebius struct timeval a = timeval_init(i, 10); 279290001Sglebius int E = (i >= 0) - (i < 0); 280290001Sglebius int r = test_tval(a); 281290001Sglebius 282290001Sglebius TEST_ASSERT_EQUAL(E, r); 283290001Sglebius } 284293896Sglebius 285293896Sglebius return; 286290001Sglebius} 287290001Sglebius 288290001Sglebius//---------------------------------------------------------------------- 289290001Sglebius// test compare 290290001Sglebius//---------------------------------------------------------------------- 291290001Sglebiusvoid 292293896Sglebiustest_CmpFracEQ(void) 293293896Sglebius{ 294290001Sglebius int i, j; 295293896Sglebius 296290001Sglebius // fractions are equal 297290001Sglebius for (i = -4; i <= 4; ++i) 298290001Sglebius for (j = -4; j <= 4; ++j) { 299290001Sglebius struct timeval a = timeval_init(i, 200); 300290001Sglebius struct timeval b = timeval_init(j, 200); 301290001Sglebius int E = (i > j) - (i < j); 302290001Sglebius int r = cmp_tval_denorm(a, b); 303290001Sglebius 304290001Sglebius TEST_ASSERT_EQUAL(E, r); 305290001Sglebius } 306293896Sglebius 307293896Sglebius return; 308290001Sglebius} 309290001Sglebius 310290001Sglebius 311290001Sglebiusvoid 312293896Sglebiustest_CmpFracGT(void) 313293896Sglebius{ 314290001Sglebius // fraction a bigger fraction b 315290001Sglebius int i, j; 316293896Sglebius 317290001Sglebius for (i = -4; i <= 4; ++i) 318290001Sglebius for (j = -4; j <= 4; ++j) { 319290001Sglebius struct timeval a = timeval_init( i , 999800); 320290001Sglebius struct timeval b = timeval_init( j , 200); 321290001Sglebius int E = (i >= j) - (i < j); 322290001Sglebius int r = cmp_tval_denorm(a, b); 323290001Sglebius 324290001Sglebius TEST_ASSERT_EQUAL(E, r); 325290001Sglebius } 326293896Sglebius 327293896Sglebius return; 328290001Sglebius} 329290001Sglebius 330290001Sglebius 331290001Sglebiusvoid 332293896Sglebiustest_CmpFracLT(void) 333293896Sglebius{ 334290001Sglebius // fraction a less fraction b 335290001Sglebius int i, j; 336293896Sglebius 337290001Sglebius for (i = -4; i <= 4; ++i) 338290001Sglebius for (j = -4; j <= 4; ++j) { 339290001Sglebius struct timeval a = timeval_init(i, 200); 340290001Sglebius struct timeval b = timeval_init(j, 999800); 341290001Sglebius int E = (i > j) - (i <= j); 342290001Sglebius int r = cmp_tval_denorm(a, b); 343290001Sglebius 344290001Sglebius TEST_ASSERT_EQUAL(E, r); 345290001Sglebius } 346293896Sglebius 347293896Sglebius return; 348290001Sglebius} 349290001Sglebius 350290001Sglebius//---------------------------------------------------------------------- 351290001Sglebius// Test addition (sum) 352290001Sglebius//---------------------------------------------------------------------- 353290001Sglebius 354290001Sglebiusvoid 355293896Sglebiustest_AddFullNorm(void) 356293896Sglebius{ 357290001Sglebius int i, j; 358293896Sglebius 359290001Sglebius for (i = -4; i <= 4; ++i) 360290001Sglebius for (j = -4; j <= 4; ++j) { 361290001Sglebius struct timeval a = timeval_init(i, 200); 362290001Sglebius struct timeval b = timeval_init(j, 400); 363290001Sglebius struct timeval E = timeval_init(i + j, 200 + 400); 364290001Sglebius struct timeval c; 365290001Sglebius 366290001Sglebius c = add_tval(a, b); 367290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 368290001Sglebius } 369293896Sglebius 370293896Sglebius return; 371290001Sglebius} 372290001Sglebius 373290001Sglebius 374290001Sglebiusvoid 375293896Sglebiustest_AddFullOflow1(void) 376293896Sglebius{ 377290001Sglebius int i, j; 378293896Sglebius 379290001Sglebius for (i = -4; i <= 4; ++i) 380290001Sglebius for (j = -4; j <= 4; ++j) { 381290001Sglebius struct timeval a = timeval_init(i, 200); 382290001Sglebius struct timeval b = timeval_init(j, 999900); 383290001Sglebius struct timeval E = timeval_init(i + j + 1, 100); 384290001Sglebius struct timeval c; 385290001Sglebius 386290001Sglebius c = add_tval(a, b); 387290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 388290001Sglebius } 389293896Sglebius 390293896Sglebius return; 391290001Sglebius} 392290001Sglebius 393290001Sglebius 394290001Sglebiusvoid 395293896Sglebiustest_AddUsecNorm(void) 396293896Sglebius{ 397290001Sglebius int i; 398293896Sglebius 399290001Sglebius for (i = -4; i <= 4; ++i) { 400290001Sglebius struct timeval a = timeval_init(i, 200); 401290001Sglebius struct timeval E = timeval_init(i, 600); 402290001Sglebius struct timeval c; 403290001Sglebius 404290001Sglebius c = add_tval_us(a, 600 - 200); 405290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 406290001Sglebius } 407293896Sglebius 408293896Sglebius return; 409290001Sglebius} 410290001Sglebius 411290001Sglebius 412290001Sglebiusvoid 413293896Sglebiustest_AddUsecOflow1(void) 414293896Sglebius{ 415290001Sglebius int i; 416293896Sglebius 417290001Sglebius for (i = -4; i <= 4; ++i) { 418290001Sglebius struct timeval a = timeval_init(i, 200); 419290001Sglebius struct timeval E = timeval_init(i + 1, 100); 420290001Sglebius struct timeval c; 421290001Sglebius 422290001Sglebius c = add_tval_us(a, MICROSECONDS - 100); 423290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 424290001Sglebius } 425293896Sglebius 426293896Sglebius return; 427290001Sglebius} 428290001Sglebius 429290001Sglebius//---------------------------------------------------------------------- 430290001Sglebius// test subtraction (difference) 431290001Sglebius//---------------------------------------------------------------------- 432290001Sglebius 433290001Sglebiusvoid 434293896Sglebiustest_SubFullNorm(void) 435293896Sglebius{ 436290001Sglebius int i, j; 437293896Sglebius 438290001Sglebius for (i = -4; i <= 4; ++i) 439290001Sglebius for (j = -4; j <= 4; ++j) { 440290001Sglebius struct timeval a = timeval_init(i, 600); 441290001Sglebius struct timeval b = timeval_init(j, 400); 442290001Sglebius struct timeval E = timeval_init(i - j, 600 - 400); 443290001Sglebius struct timeval c; 444290001Sglebius 445290001Sglebius c = sub_tval(a, b); 446290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 447290001Sglebius } 448293896Sglebius 449293896Sglebius return; 450290001Sglebius} 451290001Sglebius 452290001Sglebius 453290001Sglebiusvoid 454293896Sglebiustest_SubFullOflow(void) 455293896Sglebius{ 456290001Sglebius int i, j; 457293896Sglebius 458290001Sglebius for (i = -4; i <= 4; ++i) 459290001Sglebius for (j = -4; j <= 4; ++j) { 460290001Sglebius struct timeval a = timeval_init(i, 100); 461290001Sglebius struct timeval b = timeval_init(j, 999900); 462290001Sglebius struct timeval E = timeval_init(i - j - 1, 200); 463290001Sglebius struct timeval c; 464290001Sglebius 465290001Sglebius c = sub_tval(a, b); 466290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 467290001Sglebius } 468293896Sglebius 469293896Sglebius return; 470290001Sglebius} 471290001Sglebius 472290001Sglebius 473290001Sglebiusvoid 474293896Sglebiustest_SubUsecNorm(void) 475293896Sglebius{ 476290001Sglebius int i = -4; 477293896Sglebius 478290001Sglebius for (i = -4; i <= 4; ++i) { 479290001Sglebius struct timeval a = timeval_init(i, 600); 480290001Sglebius struct timeval E = timeval_init(i, 200); 481290001Sglebius struct timeval c; 482290001Sglebius 483290001Sglebius c = sub_tval_us(a, 600 - 200); 484290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 485290001Sglebius } 486293896Sglebius 487293896Sglebius return; 488290001Sglebius} 489290001Sglebius 490290001Sglebius 491290001Sglebiusvoid 492293896Sglebiustest_SubUsecOflow(void) 493293896Sglebius{ 494290001Sglebius int i = -4; 495293896Sglebius 496290001Sglebius for (i = -4; i <= 4; ++i) { 497290001Sglebius struct timeval a = timeval_init(i, 100); 498290001Sglebius struct timeval E = timeval_init(i - 1, 200); 499290001Sglebius struct timeval c; 500290001Sglebius 501290001Sglebius c = sub_tval_us(a, MICROSECONDS - 100); 502290001Sglebius TEST_ASSERT_EQUAL_timeval(E, c); 503290001Sglebius } 504293896Sglebius 505293896Sglebius return; 506290001Sglebius} 507290001Sglebius 508290001Sglebius//---------------------------------------------------------------------- 509290001Sglebius// test negation 510290001Sglebius//---------------------------------------------------------------------- 511290001Sglebius 512290001Sglebiusvoid 513293896Sglebiustest_Neg(void) 514293896Sglebius{ 515290001Sglebius int i = -4; 516293896Sglebius 517290001Sglebius for (i = -4; i <= 4; ++i) { 518290001Sglebius struct timeval a = timeval_init(i, 100); 519290001Sglebius struct timeval b; 520290001Sglebius struct timeval c; 521290001Sglebius 522290001Sglebius b = neg_tval(a); 523290001Sglebius c = add_tval(a, b); 524290001Sglebius TEST_ASSERT_EQUAL(0, test_tval(c)); 525290001Sglebius } 526293896Sglebius 527293896Sglebius return; 528290001Sglebius} 529290001Sglebius 530290001Sglebius//---------------------------------------------------------------------- 531290001Sglebius// test abs value 532290001Sglebius//---------------------------------------------------------------------- 533290001Sglebius 534290001Sglebiusvoid 535293896Sglebiustest_AbsNoFrac(void) 536293896Sglebius{ 537290001Sglebius int i = -4; 538293896Sglebius 539290001Sglebius for (i = -4; i <= 4; ++i) { 540290001Sglebius struct timeval a = timeval_init(i, 0); 541290001Sglebius struct timeval b; 542290001Sglebius 543290001Sglebius b = abs_tval(a); 544290001Sglebius TEST_ASSERT_EQUAL((i != 0), test_tval(b)); 545290001Sglebius } 546293896Sglebius 547293896Sglebius return; 548290001Sglebius} 549290001Sglebius 550290001Sglebius 551290001Sglebiusvoid 552293896Sglebiustest_AbsWithFrac(void) 553293896Sglebius{ 554290001Sglebius int i = -4; 555293896Sglebius 556290001Sglebius for (i = -4; i <= 4; ++i) { 557290001Sglebius struct timeval a = timeval_init(i, 100); 558290001Sglebius struct timeval b; 559290001Sglebius 560290001Sglebius b = abs_tval(a); 561290001Sglebius TEST_ASSERT_EQUAL(1, test_tval(b)); 562290001Sglebius } 563293896Sglebius 564293896Sglebius return; 565290001Sglebius} 566290001Sglebius 567290001Sglebius// --------------------------------------------------------------------- 568290001Sglebius// test support stuff -- part 2 569290001Sglebius// --------------------------------------------------------------------- 570290001Sglebius 571290001Sglebius 572290001Sglebiusvoid 573293896Sglebiustest_Helpers2(void) 574293896Sglebius{ 575290001Sglebius struct timeval limit = timeval_init(0, 2); 576290001Sglebius struct timeval x, y; 577293896Sglebius long i; 578290001Sglebius 579293896Sglebius for (x.tv_sec = -2; x.tv_sec < 3; x.tv_sec++) { 580290001Sglebius for (x.tv_usec = 1; 581290001Sglebius x.tv_usec < 1000000; 582290001Sglebius x.tv_usec += 499999) { 583290001Sglebius for (i = -4; i < 5; ++i) { 584290001Sglebius y = x; 585290001Sglebius y.tv_usec += i; 586293896Sglebius if (i >= -2 && i <= 2) { 587290001Sglebius TEST_ASSERT_TRUE(AssertTimevalClose(x, y, limit));//ASSERT_PRED_FORMAT2(isClose, x, y); 588290001Sglebius } 589290001Sglebius else { 590290001Sglebius TEST_ASSERT_FALSE(AssertTimevalClose(x, y, limit)); 591290001Sglebius } 592290001Sglebius } 593290001Sglebius } 594290001Sglebius } 595293896Sglebius 596293896Sglebius return; 597290001Sglebius} 598290001Sglebius 599290001Sglebius// and the global predicate instances we're using here 600290001Sglebius 601290001Sglebius//static l_fp lfpClose = l_fp_init(0, 1); //static AssertFpClose FpClose(0, 1); 602290001Sglebius//static struct timeval timevalClose = timeval_init(0, 1); //static AssertTimevalClose TimevalClose(0, 1); 603290001Sglebius 604290001Sglebius//---------------------------------------------------------------------- 605290001Sglebius// conversion to l_fp 606290001Sglebius//---------------------------------------------------------------------- 607290001Sglebius 608290001Sglebiusvoid 609293896Sglebiustest_ToLFPbittest(void) 610293896Sglebius{ 611293896Sglebius l_fp lfpClose = l_fp_init(0, 1); 612290001Sglebius 613290001Sglebius u_int32 i = 0; 614290001Sglebius for (i = 0; i < 1000000; ++i) { 615290001Sglebius struct timeval a = timeval_init(1, i); 616290001Sglebius l_fp E = l_fp_init(1, my_tick_to_tsf(i)); 617290001Sglebius l_fp r; 618290001Sglebius 619290001Sglebius r = tval_intv_to_lfp(a); 620290001Sglebius TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose)); //ASSERT_PRED_FORMAT2(FpClose, E, r); 621290001Sglebius } 622293896Sglebius 623293896Sglebius return; 624290001Sglebius} 625290001Sglebius 626290001Sglebius 627290001Sglebiusvoid 628293896Sglebiustest_ToLFPrelPos(void) 629293896Sglebius{ 630290001Sglebius l_fp lfpClose = l_fp_init(0, 1); 631293896Sglebius int i = 0; 632290001Sglebius 633290001Sglebius for (i = 0; i < COUNTOF(fdata); ++i) { 634290001Sglebius struct timeval a = timeval_init(1, fdata[i].usec); 635290001Sglebius l_fp E = l_fp_init(1, fdata[i].frac); 636290001Sglebius l_fp r; 637290001Sglebius 638290001Sglebius r = tval_intv_to_lfp(a); 639290001Sglebius TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose)); 640290001Sglebius } 641293896Sglebius 642293896Sglebius return; 643290001Sglebius} 644290001Sglebius 645290001Sglebius 646290001Sglebiusvoid 647293896Sglebiustest_ToLFPrelNeg(void) 648293896Sglebius{ 649290001Sglebius l_fp lfpClose = l_fp_init(0, 1); 650290001Sglebius int i = 0; 651293896Sglebius 652290001Sglebius for (i = 0; i < COUNTOF(fdata); ++i) { 653290001Sglebius struct timeval a = timeval_init(-1, fdata[i].usec); 654290001Sglebius l_fp E = l_fp_init(~0, fdata[i].frac); 655290001Sglebius l_fp r; 656290001Sglebius 657290001Sglebius r = tval_intv_to_lfp(a); 658290001Sglebius TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose)); 659290001Sglebius } 660293896Sglebius 661293896Sglebius return; 662290001Sglebius} 663290001Sglebius 664290001Sglebius 665290001Sglebiusvoid 666293896Sglebiustest_ToLFPabs(void) 667293896Sglebius{ 668290001Sglebius l_fp lfpClose = l_fp_init(0, 1); 669293896Sglebius int i = 0; 670290001Sglebius 671290001Sglebius for (i = 0; i < COUNTOF(fdata); ++i) { 672290001Sglebius struct timeval a = timeval_init(1, fdata[i].usec); 673290001Sglebius l_fp E = l_fp_init(1 + JAN_1970, fdata[i].frac); 674290001Sglebius l_fp r; 675290001Sglebius 676290001Sglebius r = tval_stamp_to_lfp(a); 677290001Sglebius TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose)); 678290001Sglebius } 679293896Sglebius 680293896Sglebius return; 681290001Sglebius} 682290001Sglebius 683290001Sglebius//---------------------------------------------------------------------- 684290001Sglebius// conversion from l_fp 685290001Sglebius//---------------------------------------------------------------------- 686290001Sglebius 687290001Sglebiusvoid 688293896Sglebiustest_FromLFPbittest(void) 689293896Sglebius{ 690290001Sglebius struct timeval timevalClose = timeval_init(0, 1); 691290001Sglebius // Not *exactly* a bittest, because 2**32 tests would take a 692290001Sglebius // really long time even on very fast machines! So we do test 693290001Sglebius // every 1000 fractional units. 694290001Sglebius u_int32 tsf = 0; 695293896Sglebius 696290001Sglebius for (tsf = 0; tsf < ~((u_int32)(1000)); tsf += 1000) { 697290001Sglebius struct timeval E = timeval_init(1, my_tsf_to_tick(tsf)); 698290001Sglebius l_fp a = l_fp_init(1, tsf); 699290001Sglebius struct timeval r; 700290001Sglebius 701290001Sglebius r = lfp_intv_to_tval(a); 702290001Sglebius // The conversion might be off by one microsecond when 703290001Sglebius // comparing to calculated value. 704290001Sglebius TEST_ASSERT_TRUE(AssertTimevalClose(E, r, timevalClose)); 705290001Sglebius } 706293896Sglebius 707293896Sglebius return; 708290001Sglebius} 709290001Sglebius 710290001Sglebius 711290001Sglebiusvoid 712293896Sglebiustest_FromLFPrelPos(void) 713293896Sglebius{ 714290001Sglebius struct timeval timevalClose = timeval_init(0, 1); 715293896Sglebius int i = 0; 716293896Sglebius 717290001Sglebius for (i = 0; i < COUNTOF(fdata); ++i) { 718290001Sglebius l_fp a = l_fp_init(1, fdata[i].frac); 719290001Sglebius struct timeval E = timeval_init(1, fdata[i].usec); 720290001Sglebius struct timeval r; 721290001Sglebius 722290001Sglebius r = lfp_intv_to_tval(a); 723290001Sglebius TEST_ASSERT_TRUE(AssertTimevalClose(E, r, timevalClose)); 724290001Sglebius } 725293896Sglebius 726293896Sglebius return; 727290001Sglebius} 728290001Sglebius 729290001Sglebius 730290001Sglebiusvoid 731293896Sglebiustest_FromLFPrelNeg(void) 732293896Sglebius{ 733290001Sglebius struct timeval timevalClose = timeval_init(0, 1); 734290001Sglebius int i = 0; 735293896Sglebius 736290001Sglebius for (i = 0; i < COUNTOF(fdata); ++i) { 737290001Sglebius l_fp a = l_fp_init(~0, fdata[i].frac); 738290001Sglebius struct timeval E = timeval_init(-1, fdata[i].usec); 739290001Sglebius struct timeval r; 740290001Sglebius 741290001Sglebius r = lfp_intv_to_tval(a); 742290001Sglebius TEST_ASSERT_TRUE(AssertTimevalClose(E, r, timevalClose)); 743290001Sglebius } 744293896Sglebius 745293896Sglebius return; 746290001Sglebius} 747290001Sglebius 748290001Sglebius 749290001Sglebius// usec -> frac -> usec roundtrip, using a prime start and increment 750290001Sglebiusvoid 751293896Sglebiustest_LFProundtrip(void) 752293896Sglebius{ 753290001Sglebius int32_t t = -1; 754290001Sglebius u_int32 i = 5; 755293896Sglebius 756290001Sglebius for (t = -1; t < 2; ++t) 757290001Sglebius for (i = 5; i < 1000000; i += 11) { 758290001Sglebius struct timeval E = timeval_init(t, i); 759290001Sglebius l_fp a; 760290001Sglebius struct timeval r; 761290001Sglebius 762290001Sglebius a = tval_intv_to_lfp(E); 763290001Sglebius r = lfp_intv_to_tval(a); 764290001Sglebius TEST_ASSERT_EQUAL_timeval(E, r); 765290001Sglebius } 766293896Sglebius 767293896Sglebius return; 768290001Sglebius} 769290001Sglebius 770290001Sglebius//---------------------------------------------------------------------- 771290001Sglebius// string formatting 772290001Sglebius//---------------------------------------------------------------------- 773290001Sglebius 774290001Sglebiusvoid 775293896Sglebiustest_ToString(void) 776293896Sglebius{ 777290001Sglebius static const struct { 778290001Sglebius time_t sec; 779290001Sglebius long usec; 780290001Sglebius const char * repr; 781290001Sglebius } data [] = { 782290001Sglebius { 0, 0, "0.000000" }, 783290001Sglebius { 2, 0, "2.000000" }, 784290001Sglebius {-2, 0, "-2.000000" }, 785290001Sglebius { 0, 1, "0.000001" }, 786290001Sglebius { 0,-1, "-0.000001" }, 787290001Sglebius { 1,-1, "0.999999" }, 788290001Sglebius {-1, 1, "-0.999999" }, 789290001Sglebius {-1,-1, "-1.000001" }, 790290001Sglebius }; 791290001Sglebius int i; 792293896Sglebius 793290001Sglebius for (i = 0; i < COUNTOF(data); ++i) { 794290001Sglebius struct timeval a = timeval_init(data[i].sec, data[i].usec); 795290001Sglebius const char * E = data[i].repr; 796290001Sglebius const char * r = tvaltoa(a); 797290001Sglebius 798290001Sglebius TEST_ASSERT_EQUAL_STRING(E, r); 799290001Sglebius } 800293896Sglebius 801293896Sglebius return; 802290001Sglebius} 803290001Sglebius 804290001Sglebius// -*- EOF -*- 805