libamxp  1.4.0
Patterns C Implementation
Functions | Variables
test_timer.c File Reference
#include <sys/signalfd.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <fcntl.h>
#include <cmocka.h>
#include <amxc/amxc.h>
#include <amxc/amxc_timestamp.h>
#include <amxp/amxp_timer.h>
#include "test_timer.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

static void timer_delete_timers_cb (UNUSED amxp_timer_t *timer, UNUSED void *priv)
 
static void timer_delete_add_timers_cb (UNUSED amxp_timer_t *timer, UNUSED void *priv)
 
static void timer_callback (amxp_timer_t *timer, void *priv)
 
static void read_sigalrm (void)
 
void test_can_create_timer (UNUSED void **state)
 
void test_can_start_timers (UNUSED void **state)
 
void test_timer_callback_is_called (UNUSED void **state)
 
void test_can_start_interval_timer (UNUSED void **state)
 
void test_can_restart_timer (UNUSED void **state)
 
void test_timer_with_0_timeout_test1 (UNUSED void **state)
 
void test_timer_with_0_timeout_test2 (UNUSED void **state)
 
void test_timer_can_delete_timers_in_callback (UNUSED void **state)
 
void test_timer_can_delete_add_timers_in_callback (UNUSED void **state)
 

Variables

static amxp_timer_t * t1 = NULL
 
static amxp_timer_t * t2 = NULL
 

Function Documentation

◆ read_sigalrm()

static void read_sigalrm ( void  )
static

Definition at line 96 of file test_timer.c.

96  {
97  sigset_t mask;
98  int sfd;
99  struct signalfd_siginfo fdsi;
100  ssize_t s;
101 
102  sigemptyset(&mask);
103  sigaddset(&mask, SIGALRM);
104 
105  sigprocmask(SIG_BLOCK, &mask, NULL);
106 
107  sfd = signalfd(-1, &mask, 0);
108  s = read(sfd, &fdsi, sizeof(struct signalfd_siginfo));
109  assert_int_equal(s, sizeof(struct signalfd_siginfo));
110  if(fdsi.ssi_signo == SIGALRM) {
111  printf("Got SIGALRM\n");
112  } else {
113  printf("Read unexpected signal\n");
114  }
115 }
mask
static sigset_t mask
Definition: amxp_syssig.c:68

◆ test_can_create_timer()

void test_can_create_timer ( UNUSED void **  state)

Definition at line 117 of file test_timer.c.

117  {
118  amxp_timer_t* timer = NULL;
119 
120  assert_int_not_equal(amxp_timer_new(NULL, NULL, NULL), 0);
121  amxp_timer_delete(NULL);
122 
123  assert_int_equal(amxp_timer_new(&timer, NULL, NULL), 0);
124  assert_ptr_not_equal(timer, NULL);
125  assert_int_equal(timer->state, amxp_timer_off);
126  assert_ptr_equal(timer->cb, NULL);
127  assert_ptr_equal(timer->priv, NULL);
128 
129  assert_int_not_equal(amxp_timer_new(&timer, NULL, NULL), 0);
130 
131  amxp_timer_delete(&timer);
132  assert_ptr_equal(timer, NULL);
133  amxp_timer_delete(&timer);
134 }
amxp_timer_delete
void amxp_timer_delete(amxp_timer_t **timer)
Deletes a timer.
Definition: amxp_timer.c:247
amxp_timer_new
int amxp_timer_new(amxp_timer_t **timer, amxp_timer_cb_t cb, void *priv)
Allocate and initializes a new timer.
Definition: amxp_timer.c:229
amxp_timer_off
@ amxp_timer_off
Definition: amxp_timer.h:149
_amxp_timer
The timer type.
Definition: amxp_timer.h:163
_amxp_timer::priv
void * priv
Definition: amxp_timer.h:168
_amxp_timer::state
amxp_timer_state_t state
Definition: amxp_timer.h:166
_amxp_timer::cb
amxp_timer_cb_t cb
Definition: amxp_timer.h:167

◆ test_can_restart_timer()

void test_can_restart_timer ( UNUSED void **  state)

Definition at line 248 of file test_timer.c.

248  {
249  amxc_ts_t start_time;
250  amxc_ts_t end_time;
251 
252  amxp_timer_t* timer = NULL;
253  amxp_timer_new(&timer, NULL, NULL);
254  amxp_timer_start(timer, 3000);
255  sleep(1);
256  amxc_ts_now(&start_time);
257  amxp_timer_start(timer, 3000);
258  read_sigalrm();
259  amxc_ts_now(&end_time);
260  assert_int_equal(end_time.sec - start_time.sec, 3);
261 
262  amxp_timer_delete(&timer);
263 }
amxp_timer_start
int amxp_timer_start(amxp_timer_t *timer, unsigned int timeout_msec)
Starts or resets a timer.
Definition: amxp_timer.c:296
read_sigalrm
static void read_sigalrm(void)
Definition: test_timer.c:96

◆ test_can_start_interval_timer()

void test_can_start_interval_timer ( UNUSED void **  state)

Definition at line 201 of file test_timer.c.

201  {
202  amxp_timer_t* timer1 = NULL;
203  amxp_timer_t* timer2 = NULL;
204  int count = 11;
205  int remaining = 0;
206 
207  assert_int_equal(amxp_timer_new(&timer1, NULL, NULL), 0);
208  assert_ptr_not_equal(timer1, NULL);
209  assert_int_equal(amxp_timer_new(&timer2, NULL, NULL), 0);
210  assert_ptr_not_equal(timer2, NULL);
211 
212  assert_int_equal(amxp_timer_set_interval(timer1, 1000), 0);
213  assert_int_equal(amxp_timer_start(timer1, 1000), 0);
214  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
215  amxp_timers_check();
216  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
217 
218  assert_int_equal(amxp_timer_start(timer2, 10200), 0);
219  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
220  amxp_timers_check();
221  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
222 
223  while(amxp_timer_get_state(timer2) != amxp_timer_off) {
224  read_sigalrm();
225  amxp_timers_calculate();
226  amxp_timers_check();
227  count--;
228  if(count > 0) {
229  remaining = amxp_timer_remaining_time(timer2);
230  assert_true((remaining / 1000) <= (count - 1));
231  }
232  }
233 
234  assert_int_equal(count, 0);
235 
236  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
237  assert_int_equal(amxp_timer_stop(timer1), 0);
238  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_off);
239 
240  assert_int_not_equal(amxp_timer_set_interval(NULL, 1000), 0);
241  assert_int_equal(amxp_timer_remaining_time(NULL), 0);
242  assert_int_not_equal(amxp_timer_stop(NULL), 0);
243 
244  amxp_timer_delete(&timer1);
245  amxp_timer_delete(&timer2);
246 }
amxp_timer_remaining_time
unsigned int amxp_timer_remaining_time(amxp_timer_t *timer)
Get the remaining time of the timer.
Definition: amxp_timer.c:281
amxp_timer_get_state
amxp_timer_state_t amxp_timer_get_state(amxp_timer_t *timer)
Get the timer's state.
Definition: amxp_timer.c:334
amxp_timers_check
void amxp_timers_check(void)
Check all timers and call the callback function when the timer is in Timer expired state.
Definition: amxp_timer.c:183
amxp_timer_stop
int amxp_timer_stop(amxp_timer_t *timer)
Stops the timer.
Definition: amxp_timer.c:319
amxp_timers_calculate
void amxp_timers_calculate(void)
Caclulates the remaining time of all timers.
Definition: amxp_timer.c:144
amxp_timer_set_interval
int amxp_timer_set_interval(amxp_timer_t *timer, unsigned int msec)
Sets the interval of a timer in milli seconds.
Definition: amxp_timer.c:259
amxp_timer_running
@ amxp_timer_running
Definition: amxp_timer.h:151
count
int count
Definition: test_syssig.c:80

◆ test_can_start_timers()

void test_can_start_timers ( UNUSED void **  state)

Definition at line 136 of file test_timer.c.

136  {
137  amxp_timer_t* timer1 = NULL;
138  amxp_timer_t* timer2 = NULL;
139  amxc_ts_t ts1;
140  amxc_ts_t ts2;
141 
142  assert_int_equal(amxp_timer_new(&timer1, NULL, NULL), 0);
143  assert_ptr_not_equal(timer1, NULL);
144  assert_int_equal(amxp_timer_new(&timer2, NULL, NULL), 0);
145  assert_ptr_not_equal(timer2, NULL);
146 
147  assert_int_equal(amxp_timer_start(timer1, 1000), 0);
148  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
149  amxp_timers_check();
150  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
151 
152  assert_int_equal(amxp_timer_start(timer2, 3000), 0);
153  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
154  amxp_timers_check();
155  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
156 
157 
158  amxc_ts_now(&ts1);
159  read_sigalrm();
160  amxc_ts_now(&ts2);
161  amxp_timers_calculate();
162  amxp_timers_check();
163  assert_int_equal(ts2.sec - ts1.sec, 1);
164  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_off);
165  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
166 
167  read_sigalrm();
168  amxc_ts_now(&ts2);
169  amxp_timers_calculate();
170  amxp_timers_check();
171  assert_int_equal(ts2.sec - ts1.sec, 3);
172  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_off);
173  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_off);
174 
175  assert_int_not_equal(amxp_timer_start(NULL, 1000), 0);
176 
177  amxp_timer_delete(&timer1);
178  amxp_timer_delete(&timer2);
179 }

◆ test_timer_callback_is_called()

void test_timer_callback_is_called ( UNUSED void **  state)

Definition at line 181 of file test_timer.c.

181  {
182  amxp_timer_t* timer1 = NULL;
183 
184  assert_int_equal(amxp_timer_new(&timer1, timer_callback, NULL), 0);
185  assert_ptr_not_equal(timer1, NULL);
186 
187  assert_int_equal(amxp_timer_start(timer1, 500), 0);
188  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
189 
190  expect_any(timer_callback, timer);
191  expect_any(timer_callback, priv);
192 
193  read_sigalrm();
194 
195  amxp_timers_calculate();
196  amxp_timers_check();
197 
198  amxp_timer_delete(&timer1);
199 }
timer_callback
static void timer_callback(amxp_timer_t *timer, void *priv)
Definition: test_timer.c:89

◆ test_timer_can_delete_add_timers_in_callback()

void test_timer_can_delete_add_timers_in_callback ( UNUSED void **  state)

Definition at line 338 of file test_timer.c.

338  {
339  amxp_timer_new(&t1, timer_delete_add_timers_cb, NULL);
340  amxp_timer_new(&t2, NULL, NULL);
341 
342  amxp_timer_start(t1, 1000);
343 
344  assert_int_equal(amxp_timer_get_state(t1), amxp_timer_running);
345 
346  read_sigalrm();
347  amxp_timers_calculate();
348  amxp_timers_check();
349 
350  read_sigalrm();
351  amxp_timers_calculate();
352  amxp_timers_check();
353 }
t1
static amxp_timer_t * t1
Definition: test_timer.c:75
timer_delete_add_timers_cb
static void timer_delete_add_timers_cb(UNUSED amxp_timer_t *timer, UNUSED void *priv)
Definition: test_timer.c:83
t2
static amxp_timer_t * t2
Definition: test_timer.c:76

◆ test_timer_can_delete_timers_in_callback()

void test_timer_can_delete_timers_in_callback ( UNUSED void **  state)

Definition at line 323 of file test_timer.c.

323  {
324  amxp_timer_new(&t1, timer_delete_timers_cb, NULL);
325  amxp_timer_new(&t2, timer_delete_timers_cb, NULL);
326 
327  amxp_timer_start(t1, 3000);
328  amxp_timer_start(t2, 10000);
329 
330  assert_int_equal(amxp_timer_get_state(t1), amxp_timer_running);
331  assert_int_equal(amxp_timer_get_state(t2), amxp_timer_running);
332 
333  read_sigalrm();
334  amxp_timers_calculate();
335  amxp_timers_check();
336 }
timer_delete_timers_cb
static void timer_delete_timers_cb(UNUSED amxp_timer_t *timer, UNUSED void *priv)
Definition: test_timer.c:78

◆ test_timer_with_0_timeout_test1()

void test_timer_with_0_timeout_test1 ( UNUSED void **  state)

Definition at line 265 of file test_timer.c.

265  {
266  amxc_ts_t start_time;
267  amxc_ts_t end_time;
268  amxp_timer_t* timer1 = NULL;
269  amxp_timer_t* timer2 = NULL;
270 
271  amxp_timer_new(&timer1, timer_callback, NULL);
272  amxp_timer_new(&timer2, NULL, NULL);
273 
274  expect_any(timer_callback, timer);
275  expect_any(timer_callback, priv);
276 
277  amxp_timer_start(timer1, 0);
278  amxp_timer_start(timer2, 3000);
279  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
280  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
281  amxc_ts_now(&start_time);
282  read_sigalrm();
283  amxc_ts_now(&end_time);
284  amxp_timers_calculate();
285  amxp_timers_check();
286  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_off);
287  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
288  assert_int_equal(end_time.sec - start_time.sec, 0);
289 
290  amxp_timer_delete(&timer1);
291  amxp_timer_delete(&timer2);
292 }

◆ test_timer_with_0_timeout_test2()

void test_timer_with_0_timeout_test2 ( UNUSED void **  state)

Definition at line 294 of file test_timer.c.

294  {
295  amxc_ts_t start_time;
296  amxc_ts_t end_time;
297  amxp_timer_t* timer1 = NULL;
298  amxp_timer_t* timer2 = NULL;
299 
300  amxp_timer_new(&timer1, timer_callback, NULL);
301  amxp_timer_new(&timer2, NULL, NULL);
302 
303  expect_any(timer_callback, timer);
304  expect_any(timer_callback, priv);
305 
306  amxp_timer_start(timer2, 3000);
307  amxp_timer_start(timer1, 0);
308  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_running);
309  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
310  amxc_ts_now(&start_time);
311  read_sigalrm();
312  amxc_ts_now(&end_time);
313  amxp_timers_calculate();
314  amxp_timers_check();
315  assert_int_equal(amxp_timer_get_state(timer1), amxp_timer_off);
316  assert_int_equal(amxp_timer_get_state(timer2), amxp_timer_running);
317  assert_int_equal(end_time.sec - start_time.sec, 0);
318 
319  amxp_timer_delete(&timer1);
320  amxp_timer_delete(&timer2);
321 }

◆ timer_callback()

static void timer_callback ( amxp_timer_t *  timer,
void *  priv 
)
static

Definition at line 89 of file test_timer.c.

89  {
90  check_expected(timer);
91  check_expected(priv);
92 
93  assert_ptr_not_equal(timer, NULL);
94 }

◆ timer_delete_add_timers_cb()

static void timer_delete_add_timers_cb ( UNUSED amxp_timer_t *  timer,
UNUSED void *  priv 
)
static

Definition at line 83 of file test_timer.c.

83  {
84  amxp_timer_delete(&t2);
85  amxp_timer_new(&t2, timer_delete_timers_cb, NULL);
86  amxp_timer_start(t1, 1000);
87 }

◆ timer_delete_timers_cb()

static void timer_delete_timers_cb ( UNUSED amxp_timer_t *  timer,
UNUSED void *  priv 
)
static

Definition at line 78 of file test_timer.c.

78  {
79  amxp_timer_delete(&t1);
80  amxp_timer_delete(&t2);
81 }

Variable Documentation

◆ t1

amxp_timer_t* t1 = NULL
static

Definition at line 75 of file test_timer.c.

◆ t2

amxp_timer_t* t2 = NULL
static

Definition at line 76 of file test_timer.c.