added tests for timevalops.c, enhancements for timespecops.c tests

bk: 4d35dd66sihyMDWfic811qAaM-bgiA

diff --git a/tests/libntp/Makefile.am b/tests/libntp/Makefile.am
index 47c2ba27f8835cb59e7399b45088169648a023d8..3439f57578d8758437aa4dd3dbd2cd16109594ef 100644 (file)
--- a/tests/libntp/Makefile.am
+++ b/tests/libntp/Makefile.am
@@ -46,6 +46,7 @@ tests_SOURCES = $(top_srcdir)/sntp/tests_main.cpp     \
                statestr.cpp            \
                strtolfp.cpp            \
                tspecops.cpp            \
+               tvalops.cpp             \
                tsftomsu.cpp            \
                tstotv.cpp              \
                tvtots.cpp              \

diff --git a/tests/libntp/tspecops.cpp b/tests/libntp/tspecops.cpp
index 3819fcbe68f787d306130a10214d5a7a427f86d7..ab3caa95a65190b3c4d56a50d514a2eb9492d846 100644 (file)
--- a/tests/libntp/tspecops.cpp
+++ b/tests/libntp/tspecops.cpp
@@ -11,9 +11,29 @@ class timespecTest : public libntptest {
 protected:
        static const long NANOSECONDS;
        // that's it...
+       struct lfpfracdata {
+               long    nsec;
+               u_int32 frac;
+       };
+       static const lfpfracdata fdata[];
 };
 const long timespecTest::NANOSECONDS = 1000000000;
-
+const timespecTest::lfpfracdata timespecTest::fdata [] = {
+               {         0, 0x00000000 }, {   2218896, 0x00916ae6 },
+               {  16408100, 0x0433523d }, { 125000000, 0x20000000 },
+               { 250000000, 0x40000000 }, { 287455871, 0x4996b53d },
+               { 375000000, 0x60000000 }, { 500000000, 0x80000000 },
+               { 518978897, 0x84dbcd0e }, { 563730222, 0x90509fb3 },
+               { 563788007, 0x9054692c }, { 583289882, 0x95527c57 },
+               { 607074509, 0x9b693c2a }, { 625000000, 0xa0000000 },
+               { 645184059, 0xa52ac851 }, { 676497788, 0xad2ef583 },
+               { 678910895, 0xadcd1abb }, { 679569625, 0xadf84663 },
+               { 690926741, 0xb0e0932d }, { 705656483, 0xb4a5e73d },
+               { 723553854, 0xb93ad34c }, { 750000000, 0xc0000000 },
+               { 763550253, 0xc3780785 }, { 775284917, 0xc6791284 },
+               { 826190764, 0xd3813ce8 }, { 875000000, 0xe0000000 },
+               { 956805507, 0xf4f134a9 }, { 982570733, 0xfb89c16c }
+};
 
 struct TSPEC{
        struct timespec V;
@@ -36,7 +56,7 @@ struct TSPEC{
                { V = rhs; return *this; }
 };
 
-std::ostream&
+static std::ostream&
 operator << (std::ostream& os, const TSPEC &val)
 {
        os << timespec_tostr(&val.V);
@@ -266,29 +286,20 @@ TEST_F(timespecTest, AbsWithFrac) {
 }
 
 // conversion to l_fp
-TEST_F(timespecTest, ToLFPrel) {
-       static const struct {
-               long    nsec;
-               u_int32 frac;
-       } data [] = {
-               {         0, 0x00000000 }, {   2218896, 0x00916ae6 },
-               {  16408100, 0x0433523d }, { 125000000, 0x20000000 },
-               { 250000000, 0x40000000 }, { 287455871, 0x4996b53d },
-               { 375000000, 0x60000000 }, { 500000000, 0x80000000 },
-               { 518978897, 0x84dbcd0e }, { 563730222, 0x90509fb3 },
-               { 563788007, 0x9054692c }, { 583289882, 0x95527c57 },
-               { 607074509, 0x9b693c2a }, { 625000000, 0xa0000000 },
-               { 645184059, 0xa52ac851 }, { 676497788, 0xad2ef583 },
-               { 678910895, 0xadcd1abb }, { 679569625, 0xadf84663 },
-               { 690926741, 0xb0e0932d }, { 705656483, 0xb4a5e73d },
-               { 723553854, 0xb93ad34c }, { 750000000, 0xc0000000 },
-               { 763550253, 0xc3780785 }, { 775284917, 0xc6791284 },
-               { 826190764, 0xd3813ce8 }, { 875000000, 0xe0000000 },
-               { 956805507, 0xf4f134a9 }, { 982570733, 0xfb89c16c }
-       };
-       for (int i = 0; i < sizeof(data)/sizeof(*data); ++i) {
-               TSPEC a(1, data[i].nsec);
-               LFP   E(1, data[i].frac);
+TEST_F(timespecTest, ToLFPrelPos) {
+       for (int i = 0; i < sizeof(fdata)/sizeof(*fdata); ++i) {
+               TSPEC a(1, fdata[i].nsec);
+               LFP   E(1, fdata[i].frac);
+               LFP   r;
+               timespec_reltolfp(r, a);
+               ASSERT_EQ(E, r);
+       }
+}
+
+TEST_F(timespecTest, ToLFPrelNeg) {
+       for (int i = 0; i < sizeof(fdata)/sizeof(*fdata); ++i) {
+               TSPEC a(-1, fdata[i].nsec);
+               LFP   E(~0, fdata[i].frac);
                LFP   r;
                timespec_reltolfp(r, a);
                ASSERT_EQ(E, r);
@@ -296,28 +307,9 @@ TEST_F(timespecTest, ToLFPrel) {
 }
 
 TEST_F(timespecTest, ToLFPabs) {
-       static const struct {
-               long    nsec;
-               u_int32 frac;
-       } data [] = {
-               {         0, 0x00000000 }, {   2218896, 0x00916ae6 },
-               {  16408100, 0x0433523d }, { 125000000, 0x20000000 },
-               { 250000000, 0x40000000 }, { 287455871, 0x4996b53d },
-               { 375000000, 0x60000000 }, { 500000000, 0x80000000 },
-               { 518978897, 0x84dbcd0e }, { 563730222, 0x90509fb3 },
-               { 563788007, 0x9054692c }, { 583289882, 0x95527c57 },
-               { 607074509, 0x9b693c2a }, { 625000000, 0xa0000000 },
-               { 645184059, 0xa52ac851 }, { 676497788, 0xad2ef583 },
-               { 678910895, 0xadcd1abb }, { 679569625, 0xadf84663 },
-               { 690926741, 0xb0e0932d }, { 705656483, 0xb4a5e73d },
-               { 723553854, 0xb93ad34c }, { 750000000, 0xc0000000 },
-               { 763550253, 0xc3780785 }, { 775284917, 0xc6791284 },
-               { 826190764, 0xd3813ce8 }, { 875000000, 0xe0000000 },
-               { 956805507, 0xf4f134a9 }, { 982570733, 0xfb89c16c }
-       };
-       for (int i = 0; i < sizeof(data)/sizeof(*data); ++i) {
-               TSPEC a(1         , data[i].nsec);
-               LFP   E(1+JAN_1970, data[i].frac);
+       for (int i = 0; i < sizeof(fdata)/sizeof(*fdata); ++i) {
+               TSPEC a(1         , fdata[i].nsec);
+               LFP   E(1+JAN_1970, fdata[i].frac);
                LFP   r;
                timespec_abstolfp(r, a);
                ASSERT_EQ(E, r);

diff --git a/tests/libntp/tvalops.cpp b/tests/libntp/tvalops.cpp
new file mode 100644 (file)
index 0000000..6026a2a
--- /dev/null
+++ b/tests/libntp/tvalops.cpp
@@ -0,0 +1,342 @@
+#include "libntptest.h"
+
+extern "C" {
+#include "timevalops.h"
+}
+
+#include <string>
+#include <sstream>
+
+class timevalTest : public libntptest {
+protected:
+       static const long MICROSECONDS;
+       // that's it...
+       struct lfpfracdata {
+               long    usec;
+               u_int32 frac;
+       };
+       static const lfpfracdata fdata[];
+};
+
+const long timevalTest::MICROSECONDS = 1000000;
+const timevalTest::lfpfracdata timevalTest::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 }
+};
+
+
+struct TVAL{
+       struct timeval V;
+
+       TVAL()
+               { ZERO(V); }
+       TVAL(time_t hi, long lo)
+               { V.tv_sec = hi; V.tv_usec = lo; }
+       bool operator == (const TVAL &rhs) const
+               { return timeval_cmp(&V, &rhs.V) == 0; }
+       bool valid() const
+               { return timeval_isnormal(&V); }
+       operator struct timeval* () 
+               { return &V; }
+       operator struct timeval& ()
+               { return V;     }
+       TVAL &operator=(const TVAL &rhs)
+               { V = rhs.V; return *this; }
+       TVAL &operator=(const struct timeval &rhs)
+               { V = rhs; return *this; }
+};
+
+std::ostream&
+operator << (std::ostream& os, const TVAL &val)
+{
+       os << timeval_tostr(&val.V);
+       return os;
+}
+
+
+struct LFP {
+       l_fp V;
+
+       LFP()
+               { ZERO(V); }
+       LFP(u_int32 hi, u_int32 lo)
+               { V.l_ui = hi; V.l_uf = lo; }
+       bool operator == (const LFP &rhs) const
+               { return L_ISEQU(&V, &rhs.V); }
+       operator l_fp* () 
+               { return &V; }
+       operator l_fp& ()
+               { return V;     }
+       LFP &operator=(const LFP &rhs)
+               { V = rhs.V; return *this; }
+       LFP &operator=(const l_fp &rhs)
+               { V = rhs; return *this; }
+};
+
+static std::ostream&
+operator << (std::ostream& os, const LFP &val)
+{
+       os << ulfptoa(&val.V, 10);
+       return os;
+}
+
+
+// ---------------------------------------------------------------------
+// test support stuff
+// ---------------------------------------------------------------------
+
+TEST_F(timevalTest, Normalise) {
+       for (long ns = -2000000000; ns <= 2000000000; ns += 10000000) {
+               TVAL x(0, ns);
+               timeval_norm(x);
+               ASSERT_TRUE(x.valid());
+       }
+}
+
+TEST_F(timevalTest, SignNoFrac) {
+       // sign test, no fraction
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a(i, 0);
+               int E = (i>0) - (i<0);
+               int r = timeval_test(a);
+               ASSERT_EQ(E, r);
+       }
+}
+
+TEST_F(timevalTest, SignWithFrac) {
+       // sign test, with fraction
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a(i, 10);
+               int E = (i>=0) - (i<0);
+               int r = timeval_test(a);
+               ASSERT_EQ(E, r);
+       }
+}
+
+// test compare
+TEST_F(timevalTest, CmpFracEQ) {
+       // fractions are equal
+       for (int i = -4; i <= 4; ++i)
+               for (int j = -4; j <= 4; ++j) {
+                       TVAL a( i , 200);
+                       TVAL b( j , 200);
+                       int   E = (i > j) - (i < j);
+                       int   r = timeval_cmp(a, b);
+                       ASSERT_EQ(E, r);
+               }
+}
+
+TEST_F(timevalTest, CmpFracGT) {
+       // fraction a bigger fraction b
+       for (int i = -4; i <= 4; ++i)
+               for (int j = -4; j <= 4; ++j) {
+                       TVAL a( i , 999800);
+                       TVAL b( j , 200);
+                       int   E = (i >= j) - (i < j);
+                       int   r = timeval_cmp(a, b);
+                       ASSERT_EQ(E, r);
+               }
+}
+
+TEST_F(timevalTest, CmpFracLT) {
+       // fraction a less fraction b
+       for (int i = -4; i <= 4; ++i)
+               for (int j = -4; j <= 4; ++j) {
+                       TVAL a( i , 200);
+                       TVAL b( j , 999800);
+                       int   E = (i > j) - (i <= j);
+                       int   r = timeval_cmp(a, b);
+                       ASSERT_EQ(E, r);
+               }
+}
+
+// Test addition (sum)
+TEST_F(timevalTest, AddFullNorm) {
+       for (int i = -4; i <= 4; ++i)
+               for (int j = -4; j <= 4; ++j) {
+                       TVAL a( i , 200);
+                       TVAL b( j , 400);
+                       TVAL E(i+j, 600);
+                       TVAL c;
+                       timeval_add(c, a, b);
+                       ASSERT_EQ(E, c);
+               }
+}
+
+TEST_F(timevalTest, AddFullOflow1) {
+       for (int i = -4; i <= 4; ++i)
+               for (int j = -4; j <= 4; ++j) {
+                       TVAL a(  i  , 200);
+                       TVAL b(  j  , 999900);
+                       TVAL E(i+j+1, 100);
+                       TVAL c;
+                       timeval_add(c, a, b);
+                       ASSERT_EQ(E, c);
+               }
+}
+
+TEST_F(timevalTest, AddUsecNorm) {
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a(i, 200);
+               TVAL E(i, 600);
+               TVAL c;
+               timeval_addus(c, a, 400);
+               ASSERT_EQ(E, c);
+       }
+}
+
+TEST_F(timevalTest, AddUsecOflow1) {
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a( i , 200);
+               TVAL E(i+1, 100);
+               TVAL c;
+               timeval_addus(c, a, MICROSECONDS - 100);
+               ASSERT_EQ(E, c);
+       }
+}
+
+// test subtraction (difference)
+TEST_F(timevalTest, SubFullNorm) {
+       for (int i = -4; i <= 4; ++i)
+               for (int j = -4; j <= 4; ++j) {
+                       TVAL a( i , 600);
+                       TVAL b( j , 400);
+                       TVAL E(i-j, 200);
+                       TVAL c;
+                       timeval_sub(c, a, b);
+                       ASSERT_EQ(E, c);
+               }
+}
+
+TEST_F(timevalTest, SubFullOflow) {
+       for (int i = -4; i <= 4; ++i)
+               for (int j = -4; j <= 4; ++j) {
+                       TVAL a(  i  , 100);
+                       TVAL b(  j  , 999900);
+                       TVAL E(i-j-1, 200);
+                       TVAL c;
+                       timeval_sub(c, a, b);
+                       ASSERT_EQ(E, c);
+               }
+}
+
+TEST_F(timevalTest, SubUsecNorm) {
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a(i, 600);
+               TVAL E(i, 200);
+               TVAL c;
+               timeval_subus(c, a, 400);
+               ASSERT_EQ(E, c);
+       }
+}
+
+TEST_F(timevalTest, SubUsecOflow) {
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a( i , 100);
+               TVAL E(i-1, 200);
+               TVAL c;
+               timeval_subus(c, a, MICROSECONDS - 100);
+               ASSERT_EQ(E, c);
+       }
+}
+
+// test negation
+TEST_F(timevalTest, Neg) {
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a( i , 100);
+               TVAL b;
+               TVAL c;
+               timeval_neg(b, a);
+               timeval_add(c, a, b);
+               ASSERT_EQ(0, timeval_test(c));
+       }
+}
+
+// test abs value
+TEST_F(timevalTest, AbsNoFrac) {
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a(i , 0);
+               TVAL b;
+               int   c;
+               c = timeval_abs(b, a);
+               ASSERT_EQ((i < 0), c);
+               ASSERT_EQ((i != 0), timeval_test(b));
+       }
+}
+
+TEST_F(timevalTest, AbsWithFrac) {
+       for (int i = -4; i <= 4; ++i) {
+               TVAL a(i , 100);
+               TVAL b;
+               int   c;
+               c = timeval_abs(b, a);
+               ASSERT_EQ((i < 0), c);
+               ASSERT_EQ(1, timeval_test(b));
+       }
+}
+
+// conversion to l_fp
+TEST_F(timevalTest, ToLFPrelPos) {
+       for (int i = 0; i < sizeof(fdata)/sizeof(*fdata); ++i) {
+               TVAL a(1, fdata[i].usec);
+               LFP  E(1, fdata[i].frac);
+               LFP  r;
+               timeval_reltolfp(r, a);
+               ASSERT_EQ(E, r);
+       }
+}
+
+TEST_F(timevalTest, ToLFPrelNeg) {
+       for (int i = 0; i < sizeof(fdata)/sizeof(*fdata); ++i) {
+               TVAL a(-1, fdata[i].usec);
+               LFP  E(~0, fdata[i].frac);
+               LFP  r;
+               timeval_reltolfp(r, a);
+               ASSERT_EQ(E, r);
+       }
+}
+
+TEST_F(timevalTest, ToLFPabs) {
+       for (int i = 0; i < sizeof(fdata)/sizeof(*fdata); ++i) {
+               TVAL a(1         , fdata[i].usec);
+               LFP  E(1+JAN_1970, fdata[i].frac);
+               LFP  r;
+               timeval_abstolfp(r, a);
+               ASSERT_EQ(E, r);
+       }
+}
+
+TEST_F(timevalTest, ToString) {
+       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" },
+               { 1,-1,  "0.999999" },
+               {-1, 1, "-0.999999" }
+       };
+       for (int i = 0; i < sizeof(data)/sizeof(*data); ++i) {
+               TVAL a(data[i].sec, data[i].usec);
+               std::string E(data[i].repr);
+               std::string r(timeval_tostr(a));
+               ASSERT_EQ(E, r);
+       }
+}
+
+// -*- EOF -*-