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_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);
}
}
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);
}
}
/*
* gettimeofday_cached()
*
* Clones the event_base_gettimeofday_cached() interface but ensures the
* times are always on the gettimeofday() 1970 scale. Older libevent 2
* sometimes used gettimeofday(), sometimes the since-system-start
* clock_gettime(CLOCK_MONOTONIC), depending on the platform.
*
* It is not cleanly possible to tell which timescale older libevent is
* using.
*
* The strategy involves 1 hour thresholds chosen to be far longer than
* the duration of a round of libevent callbacks, which share a cached
* start-of-round time. First compare the last cached time with the
* current gettimeofday() time. If they are within one hour, libevent
* is using the proper timescale so leave the offset 0. Otherwise,
* compare libevent's cached time and the current time on the monotonic
* scale. If they are within an hour, libevent is using the monotonic
* scale so calculate the offset to add to such times to bring them to
* gettimeofday()'s scale.
*/
int
gettimeofday_cached(
struct event_base * b,
struct timeval * caller_tv
)
{
#if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
static struct event_base * cached_b;
static struct timeval cached;
static struct timeval adj_cached;
static struct timeval offset;
static int offset_ready;
struct timeval latest;
struct timeval systemt;
struct timespec ts;
struct timeval mono;
struct timeval diff;
int cgt_rc;
int gtod_rc;
event_base_gettimeofday_cached(b, &latest);
if (b == cached_b &&
!memcmp(&latest, &cached, sizeof(latest))) {
*caller_tv = adj_cached;
return 0;
}
cached = latest;
cached_b = b;
if (!offset_ready) {
cgt_rc = clock_gettime(CLOCK_MONOTONIC, &ts);
gtod_rc = gettimeofday(&systemt, NULL);
if (0 != gtod_rc) {
msyslog(LOG_ERR,
"%s: gettimeofday() error %m",
progname);
exit(1);
}
diff = sub_tval(systemt, latest);
if (debug > 1)
printf("system minus cached %+ld.%06ld\n",
(long)diff.tv_sec, (long)diff.tv_usec);
if (0 != cgt_rc || labs((long)diff.tv_sec) < 3600) {
/*
* Either use_monotonic == 0, or this libevent
* has been repaired. Leave offset at zero.
*/
} else {
mono.tv_sec = ts.tv_sec;
mono.tv_usec = ts.tv_nsec / 1000;
diff = sub_tval(latest, mono);
if (debug > 1)
printf("cached minus monotonic %+ld.%06ld\n",
(long)diff.tv_sec, (long)diff.tv_usec);
if (labs((long)diff.tv_sec) < 3600) {
/* older libevent2 using monotonic */
offset = sub_tval(systemt, mono);
TRACE(1, ("%s: Offsetting libevent CLOCK_MONOTONIC times by %+ld.%06ld\n",
"gettimeofday_cached",
(long)offset.tv_sec,
(long)offset.tv_usec));
}
}
offset_ready = TRUE;
}
adj_cached = add_tval(cached, offset);
*caller_tv = adj_cached;
return 0;
#else
return event_base_gettimeofday_cached(b, caller_tv);
#endif
}