266 lines
6.9 KiB
C
266 lines
6.9 KiB
C
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#define EFL_NOLEGACY_API_SUPPORT
|
|
#include <Efl_Core.h>
|
|
#include "efl_app_suite.h"
|
|
#include "../efl_check.h"
|
|
|
|
/*
|
|
static Eina_Bool
|
|
_test_time_cb(void *data)
|
|
{
|
|
Eina_Bool *run = data;
|
|
|
|
*run = EINA_TRUE;
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
static void
|
|
_test_death_cb(void *data, const Efl_Event *ev EINA_UNUSED)
|
|
{
|
|
Eina_Bool *die = data;
|
|
|
|
*die = EINA_TRUE;
|
|
}
|
|
|
|
static void
|
|
_test_run_cb(void *data, const Efl_Event *ev EINA_UNUSED)
|
|
{
|
|
_test_time_cb(data);
|
|
}
|
|
|
|
EFL_START_TEST(ecore_test_timer_lifecycle)
|
|
{
|
|
Eina_Bool rl = EINA_FALSE, re = EINA_FALSE;
|
|
Eina_Bool dl = EINA_FALSE, de = EINA_FALSE;
|
|
Ecore_Timer *t;
|
|
Eo *et;
|
|
|
|
efl_object_init();
|
|
|
|
t = ecore_timer_add(1.0, _test_time_cb, &rl);
|
|
efl_event_callback_add((Eo*) t, EFL_EVENT_DEL, _test_death_cb, &dl);
|
|
|
|
et = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
|
|
efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _test_run_cb, &re),
|
|
efl_event_callback_add(efl_added, EFL_EVENT_DEL, _test_death_cb, &de),
|
|
efl_loop_timer_interval_set(efl_added, 1.0));
|
|
efl_ref(et);
|
|
|
|
fail_if(re == EINA_TRUE && rl == EINA_TRUE);
|
|
fail_if(dl == EINA_FALSE);
|
|
fail_if(de == EINA_TRUE);
|
|
|
|
efl_del(et);
|
|
fail_if(de == EINA_FALSE);
|
|
|
|
efl_object_shutdown();
|
|
}
|
|
EFL_END_TEST
|
|
*/
|
|
|
|
EFL_START_TEST(efl_app_test_loop_timer_invalid)
|
|
{
|
|
Efl_Object *t = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_get());
|
|
fail_if(t != NULL);
|
|
}
|
|
EFL_END_TEST
|
|
|
|
|
|
|
|
static int count = 0;
|
|
|
|
static void
|
|
_timer_cb(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
|
|
{
|
|
count++;
|
|
}
|
|
|
|
static void
|
|
array_clean(Eina_Array *arr)
|
|
{
|
|
Eo *t;
|
|
|
|
while ((t = eina_array_pop(arr)))
|
|
efl_del(t);
|
|
}
|
|
|
|
EFL_START_TEST(efl_loop_test_loop_timer_iteration)
|
|
{
|
|
Eo *t, *loop;
|
|
Eina_Array *arr;
|
|
|
|
loop = efl_main_loop_get();
|
|
count = 0;
|
|
arr = eina_array_new(5);
|
|
#define TIMER(duration) \
|
|
t = efl_add(EFL_LOOP_TIMER_CLASS, loop, \
|
|
efl_loop_timer_interval_set(efl_added, (duration)), \
|
|
efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _timer_cb, NULL) \
|
|
); \
|
|
eina_array_push(arr, t)
|
|
/* verify that timers expire after exactly one loop iteration */
|
|
TIMER(0);
|
|
efl_loop_iterate(loop);
|
|
/* timers should not expire for one loop iteration */
|
|
ck_assert_int_eq(count, 0);
|
|
efl_loop_iterate(loop);
|
|
/* timers should expire after one loop iteration */
|
|
ck_assert_int_eq(count, 1);
|
|
array_clean(arr);
|
|
|
|
count = 0;
|
|
/* verify multiple timer expiration in single mainloop iteration */
|
|
TIMER(0);
|
|
TIMER(0);
|
|
efl_loop_iterate(loop);
|
|
/* timers should not expire for one loop iteration */
|
|
ck_assert_int_eq(count, 0);
|
|
TIMER(0);
|
|
efl_loop_iterate(loop);
|
|
/* all pending and instantiated timers should expire after exactly one loop iteration */
|
|
ck_assert_int_eq(count, 2);
|
|
efl_loop_iterate(loop);
|
|
/* this should not interfere with successive timer processing */
|
|
ck_assert_int_eq(count, 5);
|
|
array_clean(arr);
|
|
|
|
count = 0;
|
|
/* verify out-of-order timer processing solely based on timer times */
|
|
TIMER(1);
|
|
efl_loop_iterate(loop);
|
|
ck_assert_int_eq(count, 0);
|
|
TIMER(0);
|
|
efl_loop_iterate(loop);
|
|
ck_assert_int_eq(count, 0);
|
|
/* timer should expire after exactly 2 iterations */
|
|
efl_loop_iterate(loop);
|
|
ck_assert_int_eq(count, 1);
|
|
efl_loop_timer_interval_set(eina_array_data_get(arr, 0), 0);
|
|
efl_loop_timer_reset(eina_array_data_get(arr, 0));
|
|
/* timer should expire after exactly 2 iterations since it becomes un-instantiated now */
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
ck_assert_int_eq(count, 4);
|
|
array_clean(arr);
|
|
}
|
|
EFL_END_TEST
|
|
|
|
#undef TIMER
|
|
#define TIMER(duration) \
|
|
efl_add(EFL_LOOP_TIMER_CLASS, loop, \
|
|
efl_loop_timer_interval_set(efl_added, (duration)), \
|
|
efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _timer_del_cb, NULL) \
|
|
); \
|
|
|
|
static void
|
|
_timer_del_cb(void *data EINA_UNUSED, const Efl_Event *ev)
|
|
{
|
|
count++;
|
|
efl_del(ev->object);
|
|
}
|
|
|
|
|
|
static void
|
|
_recursion(void *data EINA_UNUSED, const Efl_Event *ev)
|
|
{
|
|
static unsigned int recurse = 0;
|
|
static Eo *timer;
|
|
Eo *loop = efl_main_loop_get();
|
|
|
|
switch (recurse++)
|
|
{
|
|
case 0:
|
|
/* verify multiple timer expiration in single mainloop iteration */
|
|
TIMER(0);
|
|
TIMER(0);
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
ck_assert_int_eq(count, 6);
|
|
efl_loop_quit(loop, EINA_VALUE_EMPTY);
|
|
break;
|
|
case 1:
|
|
/* timers should not expire for one loop iteration */
|
|
ck_assert_int_eq(count, 1);
|
|
TIMER(0);
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
break;
|
|
case 2:
|
|
/* all pending and instantiated timers should expire after exactly one loop iteration */
|
|
ck_assert_int_eq(count, 3);
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
break;
|
|
case 3:
|
|
/* this should not interfere with successive timer processing */
|
|
ck_assert_int_eq(count, 4);
|
|
|
|
/* verify out-of-order timer processing solely based on timer times */
|
|
timer = TIMER(1);
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
break;
|
|
case 4:
|
|
ck_assert_int_eq(count, 4);
|
|
TIMER(0);
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
break;
|
|
case 5:
|
|
ck_assert_int_eq(count, 4);
|
|
/* timer should expire after exactly 2 iterations */
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
break;
|
|
case 6:
|
|
ck_assert_int_eq(count, 5);
|
|
efl_loop_timer_interval_set(timer, 0);
|
|
efl_loop_timer_reset(timer);
|
|
/* timer should expire after exactly 2 iterations since it becomes un-instantiated now */
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
break;
|
|
case 7:
|
|
efl_loop_iterate(loop);
|
|
efl_loop_iterate(loop);
|
|
efl_del(ev->object);
|
|
break;
|
|
}
|
|
}
|
|
|
|
EFL_START_TEST(efl_loop_test_loop_timer_recursion)
|
|
{
|
|
Eina_Bool crit = eina_log_abort_on_critical_get();
|
|
int critlevel = eina_log_abort_on_critical_level_get();
|
|
Eo *loop = efl_main_loop_get();
|
|
count = 1;
|
|
eina_log_abort_on_critical_set(1);
|
|
eina_log_abort_on_critical_level_set(1);
|
|
efl_add(EFL_LOOP_TIMER_CLASS, loop,
|
|
efl_loop_timer_interval_set(efl_added, 0),
|
|
efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _recursion, NULL)
|
|
);
|
|
efl_loop_begin(loop);
|
|
ck_assert_int_eq(count, 6);
|
|
eina_log_abort_on_critical_set(crit);
|
|
eina_log_abort_on_critical_level_set(critlevel);
|
|
}
|
|
EFL_END_TEST
|
|
|
|
void efl_app_test_efl_loop_timer(TCase *tc EINA_UNUSED)
|
|
{
|
|
/* XXX: this seems a silly test - that we del the loop object?
|
|
tcase_add_test(tc, ecore_test_timer_lifecycle);
|
|
*/
|
|
|
|
tcase_add_test(tc, efl_app_test_loop_timer_invalid);
|
|
tcase_add_test(tc, efl_loop_test_loop_timer_iteration);
|
|
tcase_add_test(tc, efl_loop_test_loop_timer_recursion);
|
|
}
|