170 lines
3.3 KiB
C++
170 lines
3.3 KiB
C++
#include <unistd.h>
|
|
|
|
#include <chrono>
|
|
#include <iostream>
|
|
#include <functional>
|
|
|
|
#include <di/Timer.h>
|
|
#include <di/Log.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
using namespace std;
|
|
using namespace Di;
|
|
using std::chrono::steady_clock;
|
|
|
|
TEST(Timer, isElapsed) {
|
|
Timer t;
|
|
|
|
t.set(chrono::milliseconds(250));
|
|
t.start();
|
|
|
|
// Timer has not expired, so result will be FALSE
|
|
EXPECT_FALSE(t.isElapsed());
|
|
|
|
usleep(250000);
|
|
|
|
// Timer has expired, so result will be TRUE
|
|
EXPECT_TRUE(t.isElapsed());
|
|
|
|
t.reset();
|
|
t.start();
|
|
t.stop();
|
|
|
|
// Timer has been stopped but not expired, so result will be FALSE
|
|
EXPECT_FALSE(t.isElapsed());
|
|
|
|
t.start();
|
|
|
|
usleep(250000);
|
|
|
|
// Timer has expired, so result will be TRUE
|
|
EXPECT_TRUE(t.isElapsed());
|
|
}
|
|
|
|
static atomic_int callback_called(0);
|
|
|
|
void callback(Timer *t, int param) {
|
|
if (t->isElapsed())
|
|
callback_called = param;
|
|
else
|
|
callback_called = param;
|
|
}
|
|
|
|
TEST(Timer, CallbackTest) {
|
|
Timer t;
|
|
callback_called = 0;
|
|
t.setCallback(bind(callback, placeholders::_1, 4));
|
|
t.set(chrono::milliseconds(250));
|
|
t.start();
|
|
usleep(500 * 1000);
|
|
EXPECT_TRUE(t.isElapsed());
|
|
EXPECT_EQ(callback_called, 4);
|
|
}
|
|
|
|
void callbackReset(Timer *t, atomic_int *param) {
|
|
callback_called--;
|
|
*param = 1;
|
|
if (callback_called > 0) {
|
|
t->reset();
|
|
}
|
|
}
|
|
|
|
TEST(Timer, CallbackResetTest) {
|
|
Timer t;
|
|
atomic_int test(0);
|
|
callback_called = 4;
|
|
t.setCallback(bind(callbackReset, placeholders::_1, &test));
|
|
t.set(chrono::milliseconds(100));
|
|
t.start();
|
|
while (test == 0)
|
|
usleep(10);
|
|
test = 0;
|
|
EXPECT_EQ(callback_called, 3);
|
|
while (test == 0)
|
|
usleep(10);
|
|
test = 0;
|
|
EXPECT_EQ(callback_called, 2);
|
|
while (test == 0)
|
|
usleep(10);
|
|
test = 0;
|
|
EXPECT_EQ(callback_called, 1);
|
|
while (test == 0)
|
|
usleep(10);
|
|
test = 0;
|
|
EXPECT_EQ(callback_called, 0);
|
|
usleep(500 * 1000);
|
|
EXPECT_EQ(callback_called, 0);
|
|
}
|
|
|
|
|
|
void callbackStopStart(Timer *t, atomic_int *param) {
|
|
Log::debug("callbackStopStart");
|
|
callback_called--;
|
|
*param = 1;
|
|
if (callback_called > 0) {
|
|
t->reset();
|
|
}
|
|
}
|
|
|
|
TEST(Timer, CallbackStopStart) {
|
|
Timer t;
|
|
atomic_int test(0);
|
|
callback_called = 5;
|
|
t.setCallback(bind(callbackStopStart, placeholders::_1, &test));
|
|
t.set(chrono::milliseconds(100));
|
|
t.start();
|
|
while (test == 0)
|
|
usleep(10);
|
|
|
|
EXPECT_EQ(callback_called, 4);
|
|
|
|
t.stop();
|
|
usleep(200 * 1000);
|
|
test = 0;
|
|
t.start();
|
|
int i = 0;
|
|
// We must also quit after 1s.
|
|
while (test == 0 && i < 1000) {
|
|
i++;
|
|
usleep(1000);
|
|
}
|
|
|
|
EXPECT_EQ(callback_called, 3);
|
|
}
|
|
|
|
TEST(Timer, CallbackPrematureEndTest) {
|
|
Timer *t = new Timer();
|
|
callback_called = 0;
|
|
t->setCallback(bind(callback, placeholders::_1, 4));
|
|
t->set(chrono::seconds(1));
|
|
auto begin = steady_clock::now();
|
|
t->start();
|
|
usleep(500000);
|
|
delete t;
|
|
auto end = steady_clock::now();
|
|
// The expected end-time must be in the future
|
|
EXPECT_TRUE((begin + chrono::seconds(1)) > end);
|
|
// The callback was not called
|
|
EXPECT_EQ(callback_called, 0);
|
|
}
|
|
|
|
|
|
TEST(Timer, CallbackPrematureTriggerTest) {
|
|
Timer *t = new Timer();
|
|
callback_called = 0;
|
|
t->setCallback(bind(callback, placeholders::_1, 4));
|
|
t->set(chrono::seconds(1));
|
|
auto begin = steady_clock::now();
|
|
t->start();
|
|
usleep(75 * 1000);
|
|
t->trigger();
|
|
usleep(75 * 1000);
|
|
delete t;
|
|
auto end = steady_clock::now();
|
|
// The expected end-time must be in the future
|
|
EXPECT_TRUE((begin + chrono::seconds(1)) > end);
|
|
// The callback was called
|
|
EXPECT_EQ(callback_called, 4);
|
|
}
|
|
|