src/tests/ecore_test_ecore.c

   1 #ifdef HAVE_CONFIG_H
   2 # include <config.h>
   3 #endif
   4
   5 #include "ecore_suite.h"
   6
   7 #include <Ecore.h>
   8 #include <Eina.h>
   9 #include <unistd.h>
  10 #include <stdio.h>
  11
  12 static int _log_dom;
  13 #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
  14
  15 static Eina_Bool
  16 _quit_cb(void *data)
  17 {
  18    Eina_Bool *val = data;
  19    *val = EINA_TRUE;
  20    ecore_main_loop_quit();
  21    return EINA_FALSE;
  22 }
  23
  24 static Eina_Bool
  25 _dummy_cb(void *data)
  26 {
  27    return !!data;
  28 }
  29
  30 START_TEST(ecore_test_ecore_init)
  31 {
  32    int ret;
  33
  34    ret = ecore_init();
  35    fail_if(ret != 1);
  36
  37    ret = ecore_shutdown();
  38    fail_if(ret != 0);
  39 }
  40 END_TEST
  41
  42 START_TEST(ecore_test_ecore_main_loop)
  43 {
  44    Eina_Bool did = EINA_FALSE;
  45    Ecore_Timer *timer;
  46    int ret;
  47
  48    ret = ecore_init();
  49    fail_if(ret != 1);
  50
  51    timer = ecore_timer_add(0.0, _quit_cb, &did);
  52    fail_if(timer == NULL);
  53
  54    ecore_main_loop_begin();
  55
  56    fail_if(did == EINA_FALSE);
  57
  58    ret = ecore_shutdown();
  59    fail_if(ret != 0);
  60 }
  61 END_TEST
  62
  63 START_TEST(ecore_test_ecore_main_loop_idler)
  64 {
  65    Eina_Bool did = EINA_FALSE;
  66    Ecore_Idler *idler;
  67    int ret;
  68
  69    ret = ecore_init();
  70    fail_if(ret != 1);
  71
  72    idler = ecore_idler_add(_quit_cb, &did);
  73    fail_if(idler == NULL);
  74
  75    ecore_main_loop_begin();
  76
  77    fail_if(did == EINA_FALSE);
  78
  79    ret = ecore_shutdown();
  80    fail_if(ret != 0);
  81 }
  82 END_TEST
  83
  84 START_TEST(ecore_test_ecore_main_loop_idle_enterer)
  85 {
  86    Eina_Bool did = EINA_FALSE;
  87    Ecore_Idle_Enterer *idle_enterer;
  88    int ret;
  89
  90    ret = ecore_init();
  91    fail_if(ret != 1);
  92
  93    idle_enterer = ecore_idle_enterer_add(_quit_cb, &did);
  94    fail_if(idle_enterer == NULL);
  95
  96    ecore_main_loop_begin();
  97
  98    fail_if(did == EINA_FALSE);
  99
 100    ret = ecore_shutdown();
 101    fail_if(ret != 0);
 102 }
 103 END_TEST
 104
 105 START_TEST(ecore_test_ecore_main_loop_idle_exiter)
 106 {
 107    Eina_Bool did = EINA_FALSE;
 108    Ecore_Timer *timer;
 109    Ecore_Idle_Exiter *idle_exiter;
 110    int ret;
 111
 112    ret = ecore_init();
 113    fail_if(ret != 1);
 114
 115    /* make system exit idle */
 116    timer = ecore_timer_add(0.0, _dummy_cb, (void *)(long)0);
 117    fail_if(timer == NULL);
 118
 119    idle_exiter = ecore_idle_exiter_add(_quit_cb, &did);
 120    fail_if(idle_exiter == NULL);
 121
 122    ecore_main_loop_begin();
 123
 124    fail_if(did == EINA_FALSE);
 125
 126    ret = ecore_shutdown();
 127    fail_if(ret != 0);
 128 }
 129 END_TEST
 130
 131 START_TEST(ecore_test_ecore_main_loop_timer)
 132 {
 133    Eina_Bool did = EINA_FALSE;
 134    Ecore_Timer *timer;
 135    double start, end, elapsed;
 136    int ret;
 137
 138    ret = ecore_init();
 139    fail_if(ret != 1);
 140
 141    timer = ecore_timer_add(2.0, _quit_cb, &did);
 142    fail_if(timer == NULL);
 143
 144    start = ecore_time_get();
 145    ecore_main_loop_begin();
 146    end = ecore_time_get();
 147    elapsed = end - start;
 148
 149    fail_if(did == EINA_FALSE);
 150    fail_if(elapsed < 2.0);
 151    fail_if(elapsed > 3.0); /* 1 second "error margin" */
 152
 153    ret = ecore_shutdown();
 154    fail_if(ret != 0);
 155 }
 156 END_TEST
 157
 158 static Eina_Bool _timer3(void *data)
 159 {
 160    /* timer 3, do nothing */
 161    return EINA_FALSE;
 162 }
 163
 164 static Eina_Bool _timer2(void *data)
 165 {
 166    /* timer 2, quit inner mainloop */
 167    ecore_main_loop_quit();
 168    return EINA_FALSE;
 169 }
 170
 171 static Eina_Bool _timer1(void *data)
 172 {
 173    /* timer 1, begin inner mainloop */
 174    int *times = data;
 175    (*times)++;
 176
 177    ecore_timer_add(0.3, _timer2, NULL);
 178    ecore_timer_add(0.1, _timer3, NULL);
 179    ecore_main_loop_begin();
 180
 181    ecore_main_loop_quit();
 182
 183    return EINA_FALSE;
 184 }
 185
 186 START_TEST(ecore_test_ecore_main_loop_timer_inner)
 187 {
 188    Ecore_Timer *timer;
 189    int ret;
 190    int times = 0;
 191
 192    ret = ecore_init();
 193    fail_if(ret != 1);
 194
 195    timer = ecore_timer_add(1.0, _timer1, &times);
 196    fail_if(timer == NULL);
 197
 198    /* BEGIN: outer mainloop */
 199    ecore_main_loop_begin();
 200    /*END: outer mainloop */
 201
 202    fail_if(times != 1);
 203 }
 204 END_TEST
 205
 206 static Eina_Bool
 207 _fd_handler_cb(void *data, Ecore_Fd_Handler *handler __UNUSED__)
 208 {
 209    /* FIXME: why setting val if it is overwritten just after and what is its purpose ??? */
 210    Eina_Bool *val = data;
 211
 212    *val = EINA_TRUE;
 213    ecore_main_loop_quit();
 214    return EINA_FALSE;
 215 }
 216
 217 START_TEST(ecore_test_ecore_main_loop_fd_handler)
 218 {
 219    Eina_Bool did = EINA_FALSE;
 220    Ecore_Fd_Handler *fd_handler;
 221    int comm[2];
 222    int ret;
 223
 224    ret = ecore_init();
 225    fail_if(ret != 1);
 226
 227    ret = pipe(comm);
 228    fail_if(ret != 0);
 229
 230    fd_handler = ecore_main_fd_handler_add
 231      (comm[0], ECORE_FD_READ, _fd_handler_cb, &did, NULL, NULL);
 232    fail_if(fd_handler == NULL);
 233
 234    ret = write(comm[1], &did, 1);
 235    fail_if(ret != 1);
 236
 237    ecore_main_loop_begin();
 238
 239    close(comm[0]);
 240    close(comm[1]);
 241
 242    fail_if(did == EINA_FALSE);
 243
 244    ret = ecore_shutdown();
 245    fail_if(ret != 0);
 246 }
 247 END_TEST
 248
 249 static Eina_Bool
 250 _event_handler_cb(void *data, int type __UNUSED__, void *event __UNUSED__)
 251 {
 252    /* FIXME: why setting val if it is overwritten just after and what is its purpose ??? */
 253    Eina_Bool *val = data;
 254
 255    *val = EINA_TRUE;
 256    ecore_main_loop_quit();
 257    return EINA_FALSE;
 258 }
 259
 260 START_TEST(ecore_test_ecore_main_loop_event)
 261 {
 262    Eina_Bool did = EINA_FALSE;
 263    Ecore_Event_Handler *handler;
 264    Ecore_Event *event;
 265    int ret, type;
 266
 267    ret = ecore_init();
 268    fail_if(ret != 1);
 269
 270    type = ecore_event_type_new();
 271    fail_if(type < 1);
 272
 273    handler = ecore_event_handler_add(type, _event_handler_cb, &did);
 274    fail_if(handler == NULL);
 275
 276    event = ecore_event_add(type, NULL, NULL, NULL);
 277    fail_if(event == NULL);
 278
 279    ecore_main_loop_begin();
 280
 281    fail_if(did == EINA_FALSE);
 282
 283    ret = ecore_shutdown();
 284    fail_if(ret != 0);
 285 }
 286 END_TEST
 287
 288 static Eina_Bool
 289 _timer_quit_recursive(void *data)
 290 {
 291    INF("   _timer_quit_recursive: begin");
 292    ecore_main_loop_quit(); /* quits inner main loop */
 293    INF("   _timer_quit_recursive: end");
 294    return EINA_FALSE;
 295 }
 296
 297 static Eina_Bool
 298 _event_recursive_cb(void *data, int type, void *event)
 299 {
 300    Ecore_Event *e;
 301    static int guard = 0;
 302
 303    /* If we enter this callback more than once, it's wrong! */
 304    fail_if(guard != 0);
 305    guard++;
 306
 307    INF("  event_recursive_cb: begin");
 308
 309    ecore_timer_add(1.0, _timer_quit_recursive, NULL);
 310    INF("   add 1.0s timer (once) to trigger _timer_quit_recursive");
 311
 312    INF("   inner main loop begin (recurse)");
 313    ecore_main_loop_begin();
 314    INF("   inner main loop end (recurse)");
 315
 316    ecore_main_loop_quit(); /* quits outer main loop */
 317
 318    INF("   guard = %d", guard);
 319    INF("  event_recursive_cb: end");
 320    return EINA_FALSE;
 321 }
 322
 323
 324 START_TEST(ecore_test_ecore_main_loop_event_recursive)
 325 {
 326    /* This test tests if the event handlers are really called only once when
 327     * recursive main loops are used and any number of events may have occurred
 328     * between the beginning and the end of recursive main loop.
 329     */
 330    Ecore_Event *e;
 331    int type;
 332    int ret;
 333
 334    _log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
 335
 336    INF("main: begin");
 337    ret = ecore_init();
 338    fail_if(ret != 1);
 339
 340
 341    type = ecore_event_type_new();
 342    ecore_event_handler_add(type, _event_recursive_cb, NULL);
 343    e = ecore_event_add(type, NULL, NULL, NULL);
 344    INF(" add event to trigger cb1: event=%p", e);
 345    INF(" main loop begin");
 346    ecore_main_loop_begin();
 347    INF(" main loop end");
 348
 349    INF("main: end");
 350    ecore_shutdown();
 351 }
 352 END_TEST
 353
 354 void ecore_test_ecore(TCase *tc)
 355 {
 356    tcase_add_test(tc, ecore_test_ecore_init);
 357    tcase_add_test(tc, ecore_test_ecore_main_loop);
 358    tcase_add_test(tc, ecore_test_ecore_main_loop_idler);
 359    tcase_add_test(tc, ecore_test_ecore_main_loop_idle_enterer);
 360    tcase_add_test(tc, ecore_test_ecore_main_loop_idle_exiter);
 361    tcase_add_test(tc, ecore_test_ecore_main_loop_timer);
 362    tcase_add_test(tc, ecore_test_ecore_main_loop_fd_handler);
 363    tcase_add_test(tc, ecore_test_ecore_main_loop_event);
 364    tcase_add_test(tc, ecore_test_ecore_main_loop_timer_inner);
 365    tcase_add_test(tc, ecore_test_ecore_main_loop_event_recursive);
 366 }