// only handle x > y condition
inline u32 time_sub(time64 x, time64 y)
{
time64 ret;
if(time_greater(x, y))
{
if(x.time_p2 == y.time_p2)
{
ret.time_p2 = 0;
ret.time_p1 = x.time_p1 - y.time_p1;
}
else
{
if(x.time_p1 > y.time_p1)
{
ret.time_p2 = x.time_p2 - y.time_p2;
ret.time_p1 = x.time_p1 - y.time_p1;
}
else
{
ret.time_p2 = x.time_p2 - 1 - y.time_p2;
ret.time_p1 = 0xFFFFFFFF - y.time_p1 + x.time_p1;
}
}
}
return ret.time_p1; // we believe that the reverse should be just one time
}
int vrpn_read_available_characters(int comm, unsigned char *buffer,
size_t bytes, struct timeval *timeout)
{
#ifdef VERBOSE
printf("vrpn_read_available_characters(timeout): Entering\n");
#endif
struct timeval start, finish, now;
int sofar = 0, ret; // How many characters we have read so far
unsigned char *where = buffer;
// Find out what time it is at the start, and when we should end
// (unless the timeout is NULL)
if (timeout == NULL) {
// Set up so that it will never be that now > finish
// This prevents the while() loop below from stopping looping
vrpn_gettimeofday(&now, NULL);
memcpy(&finish, &now, sizeof(finish));
vrpn_gettimeofday(&finish, NULL);
}
else {
vrpn_gettimeofday(&start, NULL);
memcpy(&now, &start, sizeof(now));
time_add(start, *timeout, finish);
}
// Keep reading until we timeout. Exit from the middle of this by
// returning if we complete or find an error so that the loop only has
// to check for timeout, not other terminating conditions.
do {
ret = vrpn_read_available_characters(comm, where, bytes - sofar);
if (ret == -1) {
return -1;
}
sofar += ret;
if (sofar == bytes) {
break;
}
where += ret;
if (timeout != NULL) { // Update the time if we are checking timeout
vrpn_gettimeofday(&now, NULL);
}
} while (!(time_greater(now, finish)));
#ifdef VERBOSE
printf("vrpn_read_available_characters(timeout): Exiting\n");
#endif
return sofar;
}
// returns 1 if child exited, else 0
static int wait_for_child_gone() {
struct timeval beg_time = time_now();
struct timeval sleep_time = {0, 1000};
int status;
int timeout = 0;
while(!timeout) {
pid_t pid = gdb_pid();
pid_t wpid = waitpid(pid, &status, WNOHANG);
if(wpid == pid) // child done
break;
// wait a little
time_sleep(&sleep_time);
struct timeval now_time = time_now();
struct timeval wait_time = time_sub(&now_time, &beg_time);
if(time_greater(&wait_time, &wait_timeout))
timeout = 1;
}
if(timeout)
return 0;
return 1;
}
int main(void)
{
struct timespec t1, t2, t3, zero = { 0, 0 };
plan_tests(61);
/* Test time_now */
t1 = time_now();
t2 = time_now();
/* Test time_sub. */
t3 = time_sub(t2, t1);
ok1(t3.tv_sec > 0 || t3.tv_nsec >= 0);
t3 = time_sub(t2, t2);
ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
t3 = time_sub(t1, t1);
ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
/* Test time_eq */
ok1(time_eq(t1, t1));
ok1(time_eq(t2, t2));
ok1(!time_eq(t1, t3));
ok1(!time_eq(t2, t3));
/* Make sure t2 > t1. */
t3.tv_sec = 0;
t3.tv_nsec = 1;
t2 = time_add(t2, t3);
/* Test time_less and time_greater. */
ok1(!time_eq(t1, t2));
ok1(!time_greater(t1, t2));
ok1(time_less(t1, t2));
ok1(time_greater(t2, t1));
ok1(!time_less(t2, t1));
t3.tv_sec = 0;
t3.tv_nsec = 999999999;
t2 = time_add(t2, t3);
ok1(!time_eq(t1, t2));
ok1(!time_greater(t1, t2));
ok1(time_less(t1, t2));
ok1(time_greater(t2, t1));
ok1(!time_less(t2, t1));
t3 = time_sub(t2, zero);
ok1(time_eq(t3, t2));
t3 = time_sub(t2, t2);
ok1(time_eq(t3, zero));
/* time_from_sec / time_to_sec */
t3 = time_from_sec(500);
ok1(t3.tv_sec == 500);
ok1(t3.tv_nsec == 0);
ok1(time_to_sec(t3) == 500);
/* time_from_msec / time_to_msec */
t3 = time_from_msec(500);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_msec(t3) == 500);
t3 = time_from_msec(1000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 0);
ok1(time_to_msec(t3) == 1000);
t3 = time_from_msec(1500);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_msec(t3) == 1500);
/* time_from_usec */
t3 = time_from_usec(500000);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_usec(t3) == 500000);
t3 = time_from_usec(1000000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 0);
ok1(time_to_usec(t3) == 1000000);
t3 = time_from_usec(1500000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_usec(t3) == 1500000);
/* time_from_nsec */
t3 = time_from_nsec(500000000);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_nsec(t3) == 500000000);
t3 = time_from_nsec(1000000000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 0);
ok1(time_to_nsec(t3) == 1000000000);
t3 = time_from_nsec(1500000000);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 500000000);
ok1(time_to_nsec(t3) == 1500000000);
/* Test wrapunder */
t3 = time_sub(time_sub(t2, time_from_msec(500)), time_from_msec(500));
ok1(t3.tv_sec == t2.tv_sec - 1);
ok1(t3.tv_nsec == t2.tv_nsec);
/* time_divide and time_multiply */
t1.tv_nsec = 100;
t1.tv_sec = 100;
t3 = time_divide(t1, 2);
ok1(t3.tv_sec == 50);
ok1(t3.tv_nsec == 50);
t3 = time_divide(t1, 100);
ok1(t3.tv_sec == 1);
ok1(t3.tv_nsec == 1);
t3 = time_multiply(t3, 100);
ok1(time_eq(t3, t1));
t3 = time_divide(t1, 200);
ok1(t3.tv_sec == 0);
ok1(t3.tv_nsec == 500000000);
/* Divide by huge number. */
t1.tv_sec = (1U << 31) - 1;
t1.tv_nsec = 999999999;
t2 = time_divide(t1, 1 << 30);
/* Allow us to round either way. */
ok1((t2.tv_sec == 2 && t2.tv_nsec == 0)
|| (t2.tv_sec == 1 && t2.tv_nsec == 999999999));
/* Multiply by huge number. */
t1.tv_sec = 0;
t1.tv_nsec = 1;
t2 = time_multiply(t1, 1UL << 31);
ok1(t2.tv_sec == 2);
ok1(t2.tv_nsec == 147483648);
return exit_status();
}
