nilix/tint2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
tint2/src/util/timer.c
Chris Lee b539c0a1c0 fix crash if bad config path given #719
2018-09-25 19:55:55 +00:00

1699 lines
46 KiB
C
Raw Blame History

/**************************************************************************
*
* Copyright (C) 2009 Andreas.Fink (Andreas.Fink85@gmail.com)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**************************************************************************/
#include <time.h>
#include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "colors.h"
#include "timer.h"
#include "test.h"
bool warnings_for_timers = true;
bool debug_timers = false;
#define MOCK_ORIGIN 1000000
// All active timers
static GList *timers = NULL;
long long get_time_ms();
void default_timers()
{
timers = NULL;
}
void cleanup_timers()
{
if (debug_timers)
fprintf(stderr, "tint2: timers: %s\n", __FUNCTION__);
g_list_free(timers);
timers = NULL;
}
void init_timer(Timer *timer, const char *name)
{
if (debug_timers)
fprintf(stderr, "tint2: timers: %s: %s, %p\n", __FUNCTION__, name, (void *)timer);
bzero(timer, sizeof(*timer));
strncpy(timer->name_, name, sizeof(timer->name_));
if (!g_list_find(timers, timer)) {
timers = g_list_append(timers, timer);
}
}
void destroy_timer(Timer *timer)
{
if (warnings_for_timers && !g_list_find(timers, timer)) {
fprintf(stderr, RED "tint2: Attempt to destroy nonexisting timer: %s" RESET "\n", timer->name_);
return;
}
if (debug_timers)
fprintf(stderr, "tint2: timers: %s: %s, %p\n", __FUNCTION__, timer->name_, (void *)timer);
timers = g_list_remove(timers, timer);
}
void change_timer(Timer *timer, bool enabled, int delay_ms, int period_ms, TimerCallback *callback, void *arg)
{
if (!g_list_find(timers, timer)) {
fprintf(stderr, RED "tint2: Attempt to change unknown timer" RESET "\n");
init_timer(timer, "unknown");
}
timer->enabled_ = enabled;
timer->expiration_time_ms_ = get_time_ms() + delay_ms;
timer->period_ms_ = period_ms;
timer->callback_ = callback;
timer->arg_ = arg;
if (debug_timers)
fprintf(stderr,
"tint2: timers: %s: %s, %p: %s, expires %lld, period %d\n",
__FUNCTION__,
timer->name_,
(void *)timer,
timer->enabled_ ? "on" : "off",
timer->expiration_time_ms_,
timer->period_ms_);
}
void stop_timer(Timer *timer)
{
change_timer(timer, false, 0, 0, NULL, NULL);
}
struct timeval *get_duration_to_next_timer_expiration()
{
static struct timeval result = {0, 0};
long long min_expiration_time = -1;
Timer *next_timer = NULL;
for (GList *it = timers; it; it = it->next) {
Timer *timer = (Timer *)it->data;
if (!timer->enabled_)
continue;
if (min_expiration_time < 0 || timer->expiration_time_ms_ < min_expiration_time) {
min_expiration_time = timer->expiration_time_ms_;
next_timer = timer;
}
}
if (min_expiration_time < 0) {
if (debug_timers)
fprintf(stderr,
"tint2: timers: %s: no active timer\n",
__FUNCTION__);
return NULL;
}
long long now = get_time_ms();
long long duration = min_expiration_time - now;
if (debug_timers)
fprintf(stderr,
"tint2: timers: %s: t=%lld, %lld to next timer: %s, %p: %s, expires %lld, period %d\n",
__FUNCTION__,
now,
duration,
next_timer->name_,
(void *)next_timer,
next_timer->enabled_ ? "on" : "off",
next_timer->expiration_time_ms_,
next_timer->period_ms_);
result.tv_sec = duration / 1000;
result.tv_usec = 1000 * (duration - result.tv_sec);
return &result;
}
void handle_expired_timers()
{
long long now = get_time_ms();
bool expired_timers = false;
for (GList *it = timers; it; it = it->next) {
Timer *timer = (Timer *)it->data;
if (timer->enabled_ && timer->callback_ && timer->expiration_time_ms_ <= now)
expired_timers = true;
}
if (!expired_timers)
return;
// We make a copy of the timer list, as the callbacks may create new timers,
// which we don't want to trigger in this event loop iteration,
// to prevent infinite loops.
GList *current_timers = g_list_copy(timers);
// Mark all timers as not handled.
// This is to ensure not triggering a timer more than once per event loop iteration,
// in case it is modified from a callback.
for (GList *it = current_timers; it; it = it->next) {
Timer *timer = (Timer *)it->data;
timer->handled_ = false;
}
bool triggered;
do {
triggered = false;
for (GList *it = current_timers; it; it = it->next) {
Timer *timer = (Timer *)it->data;
// Check that it is still registered.
if (!g_list_find(timers, timer))
continue;
if (!timer->enabled_ || timer->handled_ || !timer->callback_ || timer->expiration_time_ms_ > now)
continue;
timer->handled_ = true;
if (timer->period_ms_ == 0) {
// One shot timer, turn it off.
timer->enabled_ = false;
} else {
// Periodic timer, reschedule.
timer->expiration_time_ms_ = now + timer->period_ms_;
}
if (debug_timers)
fprintf(stderr,
"tint2: timers: %s: t=%lld, triggering %s, %p: %s, expires %lld, period %d\n",
__FUNCTION__,
now,
timer->name_,
(void *)timer,
timer->enabled_ ? "on" : "off",
timer->expiration_time_ms_,
timer->period_ms_);
timer->callback_(timer->arg_);
// The callback may have modified timers, so start from scratch
triggered = true;
break;
}
} while (triggered);
g_list_free(current_timers);
}
// Time helper functions
static struct timespec mock_time = {0, 0};
void set_mock_time(struct timespec *tp)
{
mock_time = *tp;
if (debug_timers)
fprintf(stderr,
"tint2: timers: %s: t=%lld\n",
__FUNCTION__,
get_time_ms());
}
void set_mock_time_ms(u_int64_t ms)
{
struct timespec t;
t.tv_sec = ms / 1000;
t.tv_nsec = (ms % 1000) * 1000 * 1000;
set_mock_time(&t);
}
int gettime(struct timespec *tp)
{
if (mock_time.tv_sec || mock_time.tv_nsec) {
*tp = mock_time;
return 0;
}
// CLOCK_BOOTTIME under Linux is the same as CLOCK_MONOTONIC under *BSD.
#ifdef CLOCK_BOOTTIME
return clock_gettime(CLOCK_BOOTTIME, tp);
#else
return clock_gettime(CLOCK_MONOTONIC, tp);
#endif
}
gint compare_timespecs(const struct timespec *t1, const struct timespec *t2)
{
if (t1->tv_sec < t2->tv_sec)
return -1;
else if (t1->tv_sec == t2->tv_sec) {
if (t1->tv_nsec < t2->tv_nsec)
return -1;
else if (t1->tv_nsec == t2->tv_nsec)
return 0;
else
return 1;
} else
return 1;
}
struct timespec add_msec_to_timespec(struct timespec ts, int msec)
{
ts.tv_sec += msec / 1000;
ts.tv_nsec += (msec % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000) { // 10^9
ts.tv_sec++;
ts.tv_nsec -= 1000000000;
}
return ts;
}
static double profiling_get_time_old_time = 0;
double get_time()
{
struct timespec cur_time;
gettime(&cur_time);
return cur_time.tv_sec + cur_time.tv_nsec * 1.0e-9;
}
long long get_time_ms()
{
struct timespec cur_time;
gettime(&cur_time);
return cur_time.tv_sec * 1000LL + cur_time.tv_nsec / 1000000LL;
}
double profiling_get_time()
{
double t = get_time();
if (profiling_get_time_old_time <= 0)
profiling_get_time_old_time = t;
double delta = t - profiling_get_time_old_time;
profiling_get_time_old_time = t;
return delta;
}
///////////////////////////////////////////////////////////////////////////////
// Tests start here
static int64_t timeval_to_ms(struct timeval *v)
{
if (!v)
return -1;
return (int64_t)(v->tv_sec * 1000 + v->tv_usec / 1000);
}
static void trigger_callback(void *arg)
{
int *triggered = (int *)arg;
*triggered += 1;
}
typedef struct {
Timer *timer;
int triggered;
bool stop;
bool change;
int change_value_ms;
int change_interval_ms;
bool add;
int add_value_ms;
int add_interval_ms;
bool stop_other;
bool change_other;
int change_other_value_ms;
int change_other_interval_ms;
Timer *other;
} TimeoutContainer;
static void container_callback(void *arg)
{
TimeoutContainer *container = (TimeoutContainer *)arg;
container->triggered += 1;
if (container->stop)
stop_timer(container->timer);
else if (container->change) {
change_timer(container->timer,
true,
container->change_value_ms,
container->change_interval_ms,
container_callback,
arg);
if (container->change_interval_ms)
container->change = false;
}
if (container->add) {
Timer *timer = calloc(1, sizeof(Timer));
init_timer(timer, "container_callback");
change_timer(timer, true, container->add_value_ms, container->add_interval_ms, container_callback, arg);
container->add = false;
}
if (container->stop_other)
stop_timer(container->other);
else if (container->change_other) {
change_timer(container->other,
true,
container->change_other_value_ms,
container->change_other_interval_ms,
container_callback,
arg);
container->change_other = false;
}
}
TEST(mock_time)
{
struct timespec t1 = {1000, 2};
struct timespec t2 = {0, 0};
struct timespec t3 = {2000, 3};
int ret;
set_mock_time(&t1);
ret = gettime(&t2);
ASSERT_EQUAL(ret, 0);
ASSERT_EQUAL(t1.tv_sec, t2.tv_sec);
ASSERT_EQUAL(t1.tv_nsec, t2.tv_nsec);
set_mock_time(&t3);
ret = gettime(&t2);
ASSERT_EQUAL(ret, 0);
ASSERT_EQUAL(t3.tv_sec, t2.tv_sec);
ASSERT_EQUAL(t3.tv_nsec, t2.tv_nsec);
}
TEST(mock_time_ms)
{
struct timespec t1 = {1000, 2 * 1000 * 1000};
struct timespec t2 = {0, 0};
struct timespec t3 = {2000, 3 * 1000 * 1000};
int ret;
set_mock_time_ms(1000 * 1000 + 2);
ret = gettime(&t2);
ASSERT_EQUAL(ret, 0);
ASSERT_EQUAL(t1.tv_sec, t2.tv_sec);
ASSERT_EQUAL(t1.tv_nsec, t2.tv_nsec);
set_mock_time_ms(2000 * 1000 + 3);
ret = gettime(&t2);
ASSERT_EQUAL(ret, 0);
ASSERT_EQUAL(t3.tv_sec, t2.tv_sec);
ASSERT_EQUAL(t3.tv_nsec, t2.tv_nsec);
}
TEST(change_timer_simple)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer timer;
init_timer(&timer, __FUNCTION__);
set_mock_time_ms(origin + 0);
change_timer(&timer, true, 200, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 190);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
}
TEST(change_timer_simple_two)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
change_timer(&t2, true, 200, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 190);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
}
TEST(change_timer_simple_two_reversed)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 200, 0, trigger_callback, &triggered);
change_timer(&t2, true, 100, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 190);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
}
TEST(change_timer_simple_two_overlap)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
change_timer(&t2, true, 100, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
}
TEST(change_timer_simple_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer timer;
init_timer(&timer, __FUNCTION__);
set_mock_time_ms(origin + 0);
container.add = true;
container.add_value_ms = 100;
container.timer = &timer;
change_timer(container.timer, true, 200, 0, container_callback, &container);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
}
TEST(change_timer_multi)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer timer;
init_timer(&timer, __FUNCTION__);
set_mock_time_ms(origin + 0);
change_timer(&timer, true, 200, 100, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
}
TEST(change_timer_multi_two)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
change_timer(&t2, true, 200, 200, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 6);
}
TEST(change_timer_multi_two_overlap)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
change_timer(&t2, true, 100, 100, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 6);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 8);
}
TEST(change_timer_simple_multi_two)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
change_timer(&t2, true, 200, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 5);
}
TEST(change_timer_simple_multi_two_overlap)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
change_timer(&t2, true, 100, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 5);
}
TEST(stop_timer_simple_two)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
change_timer(&t2, true, 200, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
stop_timer(&t1);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 190);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
}
TEST(stop_timer_simple_two_reversed)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
change_timer(&t2, true, 200, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
stop_timer(&t2);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 190);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
}
TEST(stop_timer_simple_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
container.stop = true;
container.timer = &t1;
change_timer(&t1, true, 200, 0, container_callback, &container);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
}
TEST(stop_timer_simple_other_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t1, "t2");
int triggered_other = 0;
set_mock_time_ms(origin + 0);
container.stop_other = true;
container.timer = &t1;
change_timer(&t1, true, 100, 0, container_callback, &container);
container.other = &t2;
change_timer(&t2, true, 200, 0, trigger_callback, &triggered_other);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
ASSERT_EQUAL(triggered_other, 0);
}
TEST(stop_timer_multi)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
stop_timer(&t1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
}
TEST(stop_timer_multi_two)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
change_timer(&t2, true, 100, 100, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
stop_timer(&t1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 5);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 6);
}
TEST(stop_timer_multi_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
container.stop = true;
container.timer = &t1;
change_timer(&t1, true, 100, 100, container_callback, &container);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
}
TEST(stop_timer_multi_other_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
int triggered_other = 0;
set_mock_time_ms(origin + 0);
container.stop_other = true;
container.timer = &t1;
change_timer(&t1, true, 100, 100, container_callback, &container);
container.other = &t2;
change_timer(&t2, true, 200, 10, trigger_callback, &triggered_other);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
ASSERT_EQUAL(triggered_other, 0);
}
TEST(change_timer_simple_again)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 200, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
change_timer(&t1, true, 200, 0, trigger_callback, &triggered);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
}
TEST(change_timer_simple_two_again)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 200, 0, trigger_callback, &triggered);
change_timer(&t2, true, 250, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
change_timer(&t1, true, 200, 0, trigger_callback, &triggered);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
}
TEST(change_timer_simple_inside_callback_again)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
container.change = true;
container.change_value_ms = 100;
container.timer = &t1;
change_timer(&t1, true, 200, 0, container_callback, &container);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
set_mock_time_ms(origin + 350);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
}
TEST(change_timer_simple_other_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
int triggered_other = 0;
set_mock_time_ms(origin + 0);
container.change_other = true;
container.change_other_value_ms = 100;
container.timer = &t1;
change_timer(&t1, true, 100, 0, container_callback, &container);
container.other = &t2;
change_timer(&t2, true, 1000, 0, trigger_callback, &triggered_other);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
ASSERT_EQUAL(triggered_other, 0);
}
TEST(add_change_two_timer_simple_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
container.add = true;
container.add_value_ms = 100;
container.change = true;
container.change_value_ms = 100;
container.timer = &t1;
change_timer(&t1, true, 200, 0, container_callback, &container);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
// Now we have two running timers, one changing itself to expire after 100 ms when triggered,
// the other firing once after 100 ms
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
set_mock_time_ms(origin + 350);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 4);
}
TEST(change_timer_multi_again)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 50, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
set_mock_time_ms(origin + 350);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 5);
}
TEST(change_timer_simple_multi)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
change_timer(&t1, true, 100, 100, trigger_callback, &triggered);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
change_timer(&t1, true, 50, 0, trigger_callback, &triggered);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
set_mock_time_ms(origin + 350);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
}
TEST(change_timer_multi_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
container.change = true;
container.change_value_ms = 100;
container.change_interval_ms = 100;
container.timer = &t1;
change_timer(&t1, true, 200, 200, container_callback, &container);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
set_mock_time_ms(origin + 350);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
}
TEST(change_timer_multi_other_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
int triggered_other = 0;
set_mock_time_ms(origin + 0);
container.change_other = true;
container.change_other_value_ms = 100;
container.change_other_interval_ms = 100;
container.timer = &t1;
change_timer(&t1, true, 100, 0, container_callback, &container);
container.other = &t2;
change_timer(&t2, true, 1000, 0, trigger_callback, &triggered_other);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 2);
ASSERT_EQUAL(triggered_other, 0);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
ASSERT_EQUAL(triggered_other, 0);
}
TEST(add_change_two_timer_multi_inside_callback)
{
u_int64_t origin = MOCK_ORIGIN;
TimeoutContainer container;
bzero(&container, sizeof(container));
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
container.add = true;
container.add_value_ms = 100;
container.add_interval_ms = 100;
container.change = true;
container.change_value_ms = 100;
container.change_interval_ms = 100;
container.timer = &t1;
change_timer(&t1, true, 200, 200, container_callback, &container);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 0);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
// Now we have two running timers, one changing itself to expire after 100 ms when triggered,
// the other firing once after 100 ms
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
set_mock_time_ms(origin + 350);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 3);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(container.triggered, 5);
}
TEST(get_duration_to_next_timer_expiration_simple)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 200, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 200);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
change_timer(&t1, true, 200, 0, trigger_callback, &triggered);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 200);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
set_mock_time_ms(origin + 250);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 50);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), -1);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), -1);
}
TEST(get_duration_to_next_timer_expiration_multi)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 200, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 50);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 200);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 200);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
change_timer(&t1, true, 100, 300, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
set_mock_time_ms(origin + 400);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 300);
set_mock_time_ms(origin + 700);
handle_expired_timers();
ASSERT_EQUAL(triggered, 4);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 300);
}
TEST(get_duration_to_next_timer_expiration_simple_multi)
{
u_int64_t origin = MOCK_ORIGIN;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t2, "t2");
int triggered = 0;
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
change_timer(&t2, true, 200, 50, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 50);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 100);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 50);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 50);
change_timer(&t1, true, 10, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 2);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 10);
set_mock_time_ms(origin + 210);
handle_expired_timers();
ASSERT_EQUAL(triggered, 3);
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), 40);
}
TEST(cleanup_timers_simple)
{
u_int64_t origin = MOCK_ORIGIN;
int triggered = 0;
Timer t1;
init_timer(&t1, "t1");
Timer t2;
init_timer(&t1, "t2");
Timer t3;
init_timer(&t1, "t3");
set_mock_time_ms(origin + 0);
change_timer(&t1, true, 100, 0, trigger_callback, &triggered);
change_timer(&t2, true, 200, 0, trigger_callback, &triggered);
change_timer(&t3, true, 300, 0, trigger_callback, &triggered);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 50);
handle_expired_timers();
ASSERT_EQUAL(triggered, 0);
set_mock_time_ms(origin + 100);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 150);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
cleanup_timers();
ASSERT_EQUAL(timeval_to_ms(get_duration_to_next_timer_expiration()), -1);
set_mock_time_ms(origin + 200);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 300);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
set_mock_time_ms(origin + 500);
handle_expired_timers();
ASSERT_EQUAL(triggered, 1);
}
Reference in a new issue View git blame Copy permalink