/*      $NetBSD: timevalops.c,v 1.4 2024/08/18 20:47:27 christos Exp $  */

#include "config.h"

//some unused features are still in the wrapper, unconverted

#include "ntp_types.h"
#include "ntp_fp.h"

#include "timevalops.h"

#include <math.h>
#include "unity.h"


#define TEST_ASSERT_EQUAL_timeval(a, b) {                               \
   TEST_ASSERT_EQUAL_MESSAGE(a.tv_sec, b.tv_sec, "Field tv_sec");      \
   TEST_ASSERT_EQUAL_MESSAGE(a.tv_usec, b.tv_usec, "Field tv_usec");   \
}


static u_int32 my_tick_to_tsf(u_int32 ticks);
static u_int32 my_tsf_to_tick(u_int32 tsf);


// that's it...
typedef struct {
       long    usec;
       u_int32 frac;
} lfpfracdata ;

struct timeval timeval_init( time_t hi, long lo);
const bool timeval_isValid(struct timeval V);
l_fp l_fp_init(int32 i, u_int32 f);
bool AssertTimevalClose(const struct timeval m, const struct timeval n, const struct timeval limit);
bool AssertFpClose(const l_fp m, const l_fp n, const l_fp limit);

void setUp(void);
void test_Helpers1(void);
void test_Normalise(void);
void test_SignNoFrac(void);
void test_SignWithFrac(void);
void test_CmpFracEQ(void);
void test_CmpFracGT(void);
void test_CmpFracLT(void);
void test_AddFullNorm(void);
void test_AddFullOflow1(void);
void test_AddUsecNorm(void);
void test_AddUsecOflow1(void);
void test_SubFullNorm(void);
void test_SubFullOflow(void);
void test_SubUsecNorm(void);
void test_SubUsecOflow(void);
void test_Neg(void);
void test_AbsNoFrac(void);
void test_AbsWithFrac(void);
void test_Helpers2(void);
void test_ToLFPbittest(void);
void test_ToLFPrelPos(void);
void test_ToLFPrelNeg(void);
void test_ToLFPabs(void);
void test_FromLFPbittest(void);
void test_FromLFPrelPos(void);
void test_FromLFPrelNeg(void);
void test_LFProundtrip(void);
void test_ToString(void);


//**********************************MY CUSTOM FUNCTIONS***********************


void
setUp(void)
{
       init_lib();

       return;
}


struct timeval
timeval_init(time_t hi, long lo)
{
       struct timeval V;

       V.tv_sec = hi;
       V.tv_usec = lo;

       return V;
}


const bool
timeval_isValid(struct timeval V)
{

       return V.tv_usec >= 0 && V.tv_usec < 1000000;
}


l_fp
l_fp_init(int32 i, u_int32 f)
{
       l_fp temp;

       temp.l_i  = i;
       temp.l_uf = f;

       return temp;
}


bool
AssertTimevalClose(const struct timeval m, const struct timeval n, const struct timeval limit)
{
       struct timeval diff;

       diff = abs_tval(sub_tval(m, n));
       if (cmp_tval(limit, diff) >= 0)
               return TRUE;

       printf("m_expr which is %lld.%06lu \nand\n"
              "n_expr which is %lld.%06lu\nare not close; diff=%lld.%06luusec\n",
              (long long)m.tv_sec, (u_long)m.tv_usec,
              (long long)n.tv_sec, (u_long)n.tv_usec,
              (long long)diff.tv_sec, (u_long)diff.tv_usec);
       return FALSE;
}


bool
AssertFpClose(const l_fp m, const l_fp n, const l_fp limit)
{
       l_fp diff;

       if (L_ISGEQ(&m, &n)) {
               diff = m;
               L_SUB(&diff, &n);
       } else {
               diff = n;
               L_SUB(&diff, &m);
       }
       if (L_ISGEQ(&limit, &diff)) {
               return TRUE;
       }
       else {
               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));
               return FALSE;
       }
}


//---------------------------------------------------

static const lfpfracdata fdata[] = {
       {      0, 0x00000000 }, {   7478, 0x01ea1405 },
       {  22077, 0x05a6d699 }, { 125000, 0x20000000 },
       { 180326, 0x2e29d841 }, { 207979, 0x353e1c9b },
       { 250000, 0x40000000 }, { 269509, 0x44fe8ab5 },
       { 330441, 0x5497c808 }, { 333038, 0x5541fa76 },
       { 375000, 0x60000000 }, { 394734, 0x650d4995 },
       { 446327, 0x72427c7c }, { 500000, 0x80000000 },
       { 517139, 0x846338b4 }, { 571953, 0x926b8306 },
       { 587353, 0x965cc426 }, { 625000, 0xa0000000 },
       { 692136, 0xb12fd32c }, { 750000, 0xc0000000 },
       { 834068, 0xd5857aff }, { 848454, 0xd9344806 },
       { 854222, 0xdaae4b02 }, { 861465, 0xdc88f862 },
       { 875000, 0xe0000000 }, { 910661, 0xe921144d },
       { 922162, 0xec12cf10 }, { 942190, 0xf1335d25 }
};


u_int32
my_tick_to_tsf(u_int32 ticks)
{
       // convert microseconds to l_fp fractional units, using double
       // precision float calculations or, if available, 64bit integer
       // arithmetic. This should give the precise fraction, rounded to
       // the nearest representation.

#ifdef HAVE_U_INT64
       return (u_int32)((( ((u_int64)(ticks)) << 32) + 500000) / 1000000); //I put too much () when casting just to be safe
#else
       return (u_int32)( ((double)(ticks)) * 4294.967296 + 0.5);
#endif
       // And before you ask: if ticks >= 1000000, the result is
       // truncated nonsense, so don't use it out-of-bounds.
}


u_int32
my_tsf_to_tick(u_int32 tsf)
{
       // Inverse operation: converts fraction to microseconds.
#ifdef HAVE_U_INT64
       return (u_int32)( ((u_int64)(tsf) * 1000000 + 0x80000000) >> 32); //CHECK ME!!!
#else
       return (u_int32)(double(tsf) / 4294.967296 + 0.5);
#endif
       // Beware: The result might be 10^6 due to rounding!
}


//*******************************END OF CUSTOM FUNCTIONS*********************


// ---------------------------------------------------------------------
// test support stuff - part1
// ---------------------------------------------------------------------

void
test_Helpers1(void)
{
       struct timeval x;

       for (x.tv_sec = -2; x.tv_sec < 3; x.tv_sec++) {
               x.tv_usec = -1;
               TEST_ASSERT_FALSE(timeval_isValid(x));
               x.tv_usec = 0;
               TEST_ASSERT_TRUE(timeval_isValid(x));
               x.tv_usec = 999999;
               TEST_ASSERT_TRUE(timeval_isValid(x));
               x.tv_usec = 1000000;
               TEST_ASSERT_FALSE(timeval_isValid(x));
       }

       return;
}


//----------------------------------------------------------------------
// test normalisation
//----------------------------------------------------------------------

void
test_Normalise(void)
{
       long ns;

       for (ns = -2000000000; ns <= 2000000000; ns += 10000000) {
               struct timeval x = timeval_init(0, ns);

               x = normalize_tval(x);
               TEST_ASSERT_TRUE(timeval_isValid(x));
       }

       return;
}

//----------------------------------------------------------------------
// test classification
//----------------------------------------------------------------------

void
test_SignNoFrac(void)
{
       int i;

       // sign test, no fraction
       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 0);
               int          E = (i > 0) - (i < 0);
               int          r = test_tval(a);

               TEST_ASSERT_EQUAL(E, r);
       }

       return;
}


void
test_SignWithFrac(void)
{
       // sign test, with fraction
       int i;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 10);
               int          E = (i >= 0) - (i < 0);
               int          r = test_tval(a);

               TEST_ASSERT_EQUAL(E, r);
       }

       return;
}

//----------------------------------------------------------------------
// test compare
//----------------------------------------------------------------------
void
test_CmpFracEQ(void)
{
       int i, j;

       // fractions are equal
       for (i = -4; i <= 4; ++i)
               for (j = -4; j <= 4; ++j) {
                       struct timeval a = timeval_init(i, 200);
                       struct timeval b = timeval_init(j, 200);
                       int          E = (i > j) - (i < j);
                       int          r = cmp_tval_denorm(a, b);

                       TEST_ASSERT_EQUAL(E, r);
               }

       return;
}


void
test_CmpFracGT(void)
{
       // fraction a bigger fraction b
       int i, j;

       for (i = -4; i <= 4; ++i)
               for (j = -4; j <= 4; ++j) {
                       struct timeval a = timeval_init( i , 999800);
                       struct timeval b = timeval_init( j , 200);
                       int          E = (i >= j) - (i < j);
                       int          r = cmp_tval_denorm(a, b);

                       TEST_ASSERT_EQUAL(E, r);
               }

       return;
}


void
test_CmpFracLT(void)
{
       // fraction a less fraction b
       int i, j;

       for (i = -4; i <= 4; ++i)
               for (j = -4; j <= 4; ++j) {
                       struct timeval a = timeval_init(i, 200);
                       struct timeval b = timeval_init(j, 999800);
                       int          E = (i > j) - (i <= j);
                       int          r = cmp_tval_denorm(a, b);

                       TEST_ASSERT_EQUAL(E, r);
               }

       return;
}

//----------------------------------------------------------------------
// Test addition (sum)
//----------------------------------------------------------------------

void
test_AddFullNorm(void)
{
       int i, j;

       for (i = -4; i <= 4; ++i)
               for (j = -4; j <= 4; ++j) {
                       struct timeval a = timeval_init(i, 200);
                       struct timeval b = timeval_init(j, 400);
                       struct timeval E = timeval_init(i + j, 200 + 400);
                       struct timeval c;

                       c = add_tval(a, b);
                       TEST_ASSERT_EQUAL_timeval(E, c);
               }

       return;
}


void
test_AddFullOflow1(void)
{
       int i, j;

       for (i = -4; i <= 4; ++i)
               for (j = -4; j <= 4; ++j) {
                       struct timeval a = timeval_init(i, 200);
                       struct timeval b = timeval_init(j, 999900);
                       struct timeval E = timeval_init(i + j + 1, 100);
                       struct timeval c;

                       c = add_tval(a, b);
                       TEST_ASSERT_EQUAL_timeval(E, c);
               }

       return;
}


void
test_AddUsecNorm(void)
{
       int i;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 200);
               struct timeval E = timeval_init(i, 600);
               struct timeval c;

               c = add_tval_us(a, 600 - 200);
               TEST_ASSERT_EQUAL_timeval(E, c);
       }

       return;
}


void
test_AddUsecOflow1(void)
{
       int i;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 200);
               struct timeval E = timeval_init(i + 1, 100);
               struct timeval c;

               c = add_tval_us(a, MICROSECONDS - 100);
               TEST_ASSERT_EQUAL_timeval(E, c);
       }

       return;
}

//----------------------------------------------------------------------
// test subtraction (difference)
//----------------------------------------------------------------------

void
test_SubFullNorm(void)
{
       int i, j;

       for (i = -4; i <= 4; ++i)
               for (j = -4; j <= 4; ++j) {
                       struct timeval a = timeval_init(i, 600);
                       struct timeval b = timeval_init(j, 400);
                       struct timeval E = timeval_init(i - j, 600 - 400);
                       struct timeval c;

                       c = sub_tval(a, b);
                       TEST_ASSERT_EQUAL_timeval(E, c);
               }

       return;
}


void
test_SubFullOflow(void)
{
       int i, j;

       for (i = -4; i <= 4; ++i)
               for (j = -4; j <= 4; ++j) {
                       struct timeval a = timeval_init(i, 100);
                       struct timeval b = timeval_init(j, 999900);
                       struct timeval E = timeval_init(i - j - 1, 200);
                       struct timeval c;

                       c = sub_tval(a, b);
                       TEST_ASSERT_EQUAL_timeval(E, c);
               }

       return;
}


void
test_SubUsecNorm(void)
{
       int i = -4;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 600);
               struct timeval E = timeval_init(i, 200);
               struct timeval c;

               c = sub_tval_us(a, 600 - 200);
               TEST_ASSERT_EQUAL_timeval(E, c);
       }

       return;
}


void
test_SubUsecOflow(void)
{
       int i = -4;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 100);
               struct timeval E = timeval_init(i - 1, 200);
               struct timeval c;

               c = sub_tval_us(a, MICROSECONDS - 100);
               TEST_ASSERT_EQUAL_timeval(E, c);
       }

       return;
}

//----------------------------------------------------------------------
// test negation
//----------------------------------------------------------------------

void
test_Neg(void)
{
       int i = -4;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 100);
               struct timeval b;
               struct timeval c;

               b = neg_tval(a);
               c = add_tval(a, b);
               TEST_ASSERT_EQUAL(0, test_tval(c));
       }

       return;
}

//----------------------------------------------------------------------
// test abs value
//----------------------------------------------------------------------

void
test_AbsNoFrac(void)
{
       int i = -4;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 0);
               struct timeval b;

               b = abs_tval(a);
               TEST_ASSERT_EQUAL((i != 0), test_tval(b));
       }

       return;
}


void
test_AbsWithFrac(void)
{
       int i = -4;

       for (i = -4; i <= 4; ++i) {
               struct timeval a = timeval_init(i, 100);
               struct timeval b;

               b = abs_tval(a);
               TEST_ASSERT_EQUAL(1, test_tval(b));
       }

       return;
}

// ---------------------------------------------------------------------
// test support stuff -- part 2
// ---------------------------------------------------------------------


void
test_Helpers2(void)
{
       struct timeval limit = timeval_init(0, 2);
       struct timeval x, y;
       long i;

       for (x.tv_sec = -2; x.tv_sec < 3; x.tv_sec++) {
               for (x.tv_usec = 1;
                    x.tv_usec < 1000000;
                    x.tv_usec += 499999) {
                       for (i = -4; i < 5; ++i) {
                               y = x;
                               y.tv_usec += i;
                               if (i >= -2 && i <= 2) {
                                       TEST_ASSERT_TRUE(AssertTimevalClose(x, y, limit));//ASSERT_PRED_FORMAT2(isClose, x, y);
                               }
                               else {
                                       TEST_ASSERT_FALSE(AssertTimevalClose(x, y, limit));
                               }
                       }
               }
       }

       return;
}

// and the global predicate instances we're using here

//static l_fp lfpClose =  l_fp_init(0, 1); //static AssertFpClose FpClose(0, 1);
//static struct timeval timevalClose = timeval_init(0, 1); //static AssertTimevalClose TimevalClose(0, 1);

//----------------------------------------------------------------------
// conversion to l_fp
//----------------------------------------------------------------------

void
test_ToLFPbittest(void)
{
       l_fp lfpClose =  l_fp_init(0, 1);

       u_int32 i = 0;
       for (i = 0; i < 1000000; ++i) {
               struct timeval a = timeval_init(1, i);
               l_fp E = l_fp_init(1, my_tick_to_tsf(i));
               l_fp r;

               r = tval_intv_to_lfp(a);
               TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose));        //ASSERT_PRED_FORMAT2(FpClose, E, r);
       }

       return;
}


void
test_ToLFPrelPos(void)
{
       l_fp lfpClose =  l_fp_init(0, 1);
       int i = 0;

       for (i = 0; i < COUNTOF(fdata); ++i) {
               struct timeval a = timeval_init(1, fdata[i].usec);
               l_fp E = l_fp_init(1, fdata[i].frac);
               l_fp r;

               r = tval_intv_to_lfp(a);
               TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose));
       }

       return;
}


void
test_ToLFPrelNeg(void)
{
       l_fp lfpClose =  l_fp_init(0, 1);
       int i = 0;

       for (i = 0; i < COUNTOF(fdata); ++i) {
               struct timeval a = timeval_init(-1, fdata[i].usec);
               l_fp E = l_fp_init(~0, fdata[i].frac);
               l_fp    r;

               r = tval_intv_to_lfp(a);
               TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose));
       }

       return;
}


void
test_ToLFPabs(void)
{
       l_fp lfpClose =  l_fp_init(0, 1);
       int i = 0;

       for (i = 0; i < COUNTOF(fdata); ++i) {
               struct timeval a = timeval_init(1, fdata[i].usec);
               l_fp E = l_fp_init(1 + JAN_1970, fdata[i].frac);
               l_fp    r;

               r = tval_stamp_to_lfp(a);
               TEST_ASSERT_TRUE(AssertFpClose(E, r, lfpClose));
       }

       return;
}

//----------------------------------------------------------------------
// conversion from l_fp
//----------------------------------------------------------------------

void
test_FromLFPbittest(void)
{
       struct timeval timevalClose = timeval_init(0, 1);
       // Not *exactly* a bittest, because 2**32 tests would take a
       // really long time even on very fast machines! So we do test
       // every 1000 fractional units.
       u_int32 tsf = 0;

       for (tsf = 0; tsf < ~((u_int32)(1000)); tsf += 1000) {
               struct timeval E = timeval_init(1, my_tsf_to_tick(tsf));
               l_fp a = l_fp_init(1, tsf);
               struct timeval r;

               r = lfp_intv_to_tval(a);
               // The conversion might be off by one microsecond when
               // comparing to calculated value.
               TEST_ASSERT_TRUE(AssertTimevalClose(E, r, timevalClose));
       }

       return;
}


void
test_FromLFPrelPos(void)
{
       struct timeval timevalClose = timeval_init(0, 1);
       int i = 0;

       for (i = 0; i < COUNTOF(fdata); ++i) {
               l_fp a = l_fp_init(1, fdata[i].frac);
               struct timeval E = timeval_init(1, fdata[i].usec);
               struct timeval r;

               r = lfp_intv_to_tval(a);
               TEST_ASSERT_TRUE(AssertTimevalClose(E, r, timevalClose));
       }

       return;
}


void
test_FromLFPrelNeg(void)
{
       struct timeval timevalClose = timeval_init(0, 1);
       int i = 0;

       for (i = 0; i < COUNTOF(fdata); ++i) {
               l_fp a = l_fp_init(~0, fdata[i].frac);
               struct timeval E = timeval_init(-1, fdata[i].usec);
               struct timeval r;

               r = lfp_intv_to_tval(a);
               TEST_ASSERT_TRUE(AssertTimevalClose(E, r, timevalClose));
       }

       return;
}


// usec -> frac -> usec roundtrip, using a prime start and increment
void
test_LFProundtrip(void)
{
       int32_t t = -1;
       u_int32 i = 5;

       for (t = -1; t < 2; ++t)
               for (i = 5; i < 1000000; i += 11) {
                       struct timeval E = timeval_init(t, i);
                       l_fp a;
                       struct timeval r;

                       a = tval_intv_to_lfp(E);
                       r = lfp_intv_to_tval(a);
                       TEST_ASSERT_EQUAL_timeval(E, r);
               }

       return;
}

//----------------------------------------------------------------------
// string formatting
//----------------------------------------------------------------------

void
test_ToString(void)
{
       static const struct {
               time_t       sec;
               long         usec;
               const char * repr;
       } data [] = {
               { 0, 0,  "0.000000" },
               { 2, 0,  "2.000000" },
               {-2, 0, "-2.000000" },
               { 0, 1,  "0.000001" },
               { 0,-1, "-0.000001" },
               { 1,-1,  "0.999999" },
               {-1, 1, "-0.999999" },
               {-1,-1, "-1.000001" },
       };
       int i;

       for (i = 0; i < COUNTOF(data); ++i) {
               struct timeval a = timeval_init(data[i].sec, data[i].usec);
               const char *  E = data[i].repr;
               const char *  r = tvaltoa(a);

               TEST_ASSERT_EQUAL_STRING(E, r);
       }

       return;
}

// -*- EOF -*-

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.