1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
#include <iostream>
#include <chrono>
#include <gtest/gtest.h>
#include "timer.hpp"
using namespace phosphor::ipmi;
class TimerTest : public ::testing::Test
{
public:
// systemd event handler
sd_event* events;
// Need this so that events can be initialized.
int rc;
// Source of event
sd_event_source* eventSource;
// Add a Timer Object
Timer timer;
// Gets called as part of each TEST_F construction
TimerTest()
: rc(sd_event_default(&events)),
timer(events)
{
// Check for successful creation of
// event handler and timer object.
EXPECT_GE(rc, 0);
}
// Gets called as part of each TEST_F destruction
~TimerTest()
{
events = sd_event_unref(events);
}
};
/** @brief Makes sure that timer is expired and the
* callback handler gets invoked post 2 seconds
*/
TEST_F(TimerTest, timerExpiresAfter2seconds)
{
using namespace std::chrono;
auto time = duration_cast<microseconds>(seconds(2));
EXPECT_GE(timer.startTimer(time), 0);
// Waiting 2 seconds is enough here since we have
// already spent some usec now
int count = 0;
while(count < 2 && !timer.isExpired())
{
// Returns -0- on timeout and positive number on dispatch
auto sleepTime = duration_cast<microseconds>(seconds(1));
if(!sd_event_run(events, sleepTime.count()))
{
count++;
}
}
EXPECT_EQ(true, timer.isExpired());
EXPECT_EQ(1, count);
}
/** @brief Makes sure that timer is not expired
*/
TEST_F(TimerTest, timerNotExpiredAfter2Seconds)
{
using namespace std::chrono;
auto time = duration_cast<microseconds>(seconds(2));
EXPECT_GE(timer.startTimer(time), 0);
// Now turn off the timer post a 1 second sleep
sleep(1);
EXPECT_GE(timer.setTimer(SD_EVENT_OFF), 0);
// Wait 2 seconds and see that timer is not expired
int count = 0;
while(count < 2)
{
// Returns -0- on timeout
auto sleepTime = duration_cast<microseconds>(seconds(1));
if(!sd_event_run(events, sleepTime.count()))
{
count++;
}
}
EXPECT_EQ(false, timer.isExpired());
// 2 because of one more count that happens prior to exiting
EXPECT_EQ(2, count);
}
/** @brief Makes sure that timer value is changed in between
* and that the new timer expires
*/
TEST_F(TimerTest, updateTimerAndExpectExpire)
{
using namespace std::chrono;
auto time = duration_cast<microseconds>(seconds(2));
EXPECT_GE(timer.startTimer(time), 0);
// Now sleep for a second and then set the new timeout value
sleep(1);
// New timeout is 3 seconds from THIS point.
time = duration_cast<microseconds>(seconds(3));
EXPECT_GE(timer.startTimer(time), 0);
// Wait 3 seconds and see that timer is expired
int count = 0;
while(count < 3 && !timer.isExpired())
{
// Returns -0- on timeout
auto sleepTime = duration_cast<microseconds>(seconds(1));
if(!sd_event_run(events, sleepTime.count()))
{
count++;
}
}
EXPECT_EQ(true, timer.isExpired());
EXPECT_EQ(2, count);
}
/** @brief Makes sure that timer value is changed in between
* and turn off and make sure that timer does not expire
*/
TEST_F(TimerTest, updateTimerAndNeverExpire)
{
using namespace std::chrono;
auto time = duration_cast<microseconds>(seconds(2));
EXPECT_GE(timer.startTimer(time), 0);
// Now sleep for a second and then set the new timeout value
sleep(1);
// New timeout is 2 seconds from THIS point.
time = duration_cast<microseconds>(seconds(2));
EXPECT_GE(timer.startTimer(time), 0);
// Now turn off the timer post a 1 second sleep
sleep(1);
EXPECT_GE(timer.setTimer(SD_EVENT_OFF), 0);
// Wait 2 seconds and see that timer is expired
int count = 0;
while(count < 2)
{
// Returns -0- on timeout
auto sleepTime = duration_cast<microseconds>(seconds(1));
if(!sd_event_run(events, sleepTime.count()))
{
count++;
}
}
EXPECT_EQ(false, timer.isExpired());
// 2 becase of one more count that happens prior to exiting
EXPECT_EQ(2, count);
}
|
