void test_AddUsecOflow1() {
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);
}
}
void test_SubUsecOflow() {
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);
}
}
void test_SubUsecNorm() {
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);
}
}
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);
}
}
void test_FromLFPrelNeg() {
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)); //ASSERT_PRED_FORMAT2(TimevalClose, E, r);
}
}
void test_AddFullOflow1() {
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);
}
}
//----------------------------------------------------------------------
// test compare
//----------------------------------------------------------------------
void test_CmpFracEQ() {
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);
}
}
void test_SubFullOflow() {
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);
}
}
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));
}
}
void test_SubFullNorm() {
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);
}
}
void test_CmpFracLT() {
// 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);
}
}
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);
}
}
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;
}
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);
}
}
void test_FromLFPbittest() {
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)); //ASSERT_PRED_FORMAT2(TimevalClose, E, r);
}
}
void test_Normalise() {
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));
}
}
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_AbsWithFrac() {
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));
}
}
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));
}
}
void test_SignNoFrac() {
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);
}
}
void test_SignWithFrac() {
// 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);
}
}
void test_ToLFPrelNeg() {
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)); //ASSERT_PRED_FORMAT2(FpClose,E, r);
}
}
void test_Neg() {
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));
}
}
void test_ToLFPbittest() {
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);
}
}
// usec -> frac -> usec roundtrip, using a prime start and increment
void test_LFProundtrip() {
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);
}
}
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));
}
}
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;
}
