On Wed, Jun 30, 2010 at 12:13 PM, Lucas De Marchi <[email protected]> wrote: > > It works fine now. Thanks both of you,
Humn... false alarm. I'm attaching a source file and the semantic patch I'm using. It doesn't patch the _timer3 function and some others. I'm running with: spatch -sp_file /tmp/a.spatch -D id=ecore_timer_add ecore_test_ecore.c -all_includes -I /home/lucas/dev/e/include/ -I /home/lucas/dev/e/include/eina-0/ -I /usr/include/ -I ../../ /home/lucas/dev/e/include/ contains Ecore.h /home/lucas/dev/e/include/eina-0/ contains Eina.h ../../ contains config.h ./ contains ecore_suite.h, which includes check.h (where some macros are defined, like START_TEST and END_TEST With these includes it does not output any warning I tried to reproduce this issue in a simplified source file without those macros, but I was not successful. Do you know what's wrong? thanks Lucas De Marchi
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <Ecore.h>
#include <Eina.h>
#include <unistd.h>
#include "ecore_suite.h"
static int _log_dom;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
static int
_quit_cb(void *data)
{
Eina_Bool *val = data;
*val = EINA_TRUE;
ecore_main_loop_quit();
return 0;
}
static int
_dummy_cb(void *data)
{
return (int)(long)data;
}
START_TEST(ecore_test_ecore_init)
{
int ret;
ret = ecore_init();
fail_if(ret != 1);
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
START_TEST(ecore_test_ecore_main_loop)
{
Eina_Bool did = EINA_FALSE;
Ecore_Timer *timer;
int ret;
ret = ecore_init();
fail_if(ret != 1);
timer = ecore_timer_add(0.0, _quit_cb, &did);
fail_if(timer == NULL);
ecore_main_loop_begin();
fail_if(did == EINA_FALSE);
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
START_TEST(ecore_test_ecore_main_loop_idler)
{
Eina_Bool did = EINA_FALSE;
Ecore_Idler *idler;
int ret;
ret = ecore_init();
fail_if(ret != 1);
idler = ecore_idler_add(_quit_cb, &did);
fail_if(idler == NULL);
ecore_main_loop_begin();
fail_if(did == EINA_FALSE);
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
START_TEST(ecore_test_ecore_main_loop_idle_enterer)
{
Eina_Bool did = EINA_FALSE;
Ecore_Idle_Enterer *idle_enterer;
int ret;
ret = ecore_init();
fail_if(ret != 1);
idle_enterer = ecore_idle_enterer_add(_quit_cb, &did);
fail_if(idle_enterer == NULL);
ecore_main_loop_begin();
fail_if(did == EINA_FALSE);
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
START_TEST(ecore_test_ecore_main_loop_idle_exiter)
{
Eina_Bool did = EINA_FALSE;
Ecore_Timer *timer;
Ecore_Idle_Exiter *idle_exiter;
int ret;
ret = ecore_init();
fail_if(ret != 1);
/* make system exit idle */
timer = ecore_timer_add(0.0, _dummy_cb, (void *)(long)0);
fail_if(timer == NULL);
idle_exiter = ecore_idle_exiter_add(_quit_cb, &did);
fail_if(idle_exiter == NULL);
ecore_main_loop_begin();
fail_if(did == EINA_FALSE);
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
START_TEST(ecore_test_ecore_main_loop_timer)
{
Eina_Bool did = EINA_FALSE;
Ecore_Timer *timer;
double start, end, elapsed;
int ret;
ret = ecore_init();
fail_if(ret != 1);
timer = ecore_timer_add(2.0, _quit_cb, &did);
fail_if(timer == NULL);
start = ecore_time_get();
ecore_main_loop_begin();
end = ecore_time_get();
elapsed = end - start;
fail_if(did == EINA_FALSE);
fail_if(elapsed < 2.0);
fail_if(elapsed > 3.0); /* 1 second "error margin" */
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
static int _timer3(void *data)
{
/* timer 3, do nothing */
return 0;
}
static int _timer2(void *data)
{
/* timer 2, quit inner mainloop */
ecore_main_loop_quit();
return 0;
}
static int _timer1(void *data)
{
/* timer 1, begin inner mainloop */
int *times = data;
(*times)++;
ecore_timer_add(0.3, _timer2, NULL);
ecore_timer_add(0.1, _timer3, NULL);
ecore_main_loop_begin();
ecore_main_loop_quit();
return 0;
}
START_TEST(ecore_test_ecore_main_loop_timer_inner)
{
int times = 0;
ecore_init();
ecore_timer_add(1.0, _timer1, ×);
/* BEGIN: outer mainloop */
ecore_main_loop_begin();
/*END: outer mainloop */
fail_if(times != 1);
}
END_TEST
static int
_fd_handler_cb(void *data, Ecore_Fd_Handler *handler __UNUSED__)
{
Eina_Bool *val = data;
*val = EINA_TRUE;
ecore_main_loop_quit();
return 0;
}
START_TEST(ecore_test_ecore_main_loop_fd_handler)
{
Eina_Bool did = EINA_FALSE;
Ecore_Fd_Handler *fd_handler;
int comm[2];
int ret;
ret = ecore_init();
fail_if(ret != 1);
ret = pipe(comm);
fail_if(ret != 0);
fd_handler = ecore_main_fd_handler_add
(comm[0], ECORE_FD_READ, _fd_handler_cb, &did, NULL, NULL);
fail_if(fd_handler == NULL);
ret = write(comm[1], &did, 1);
fail_if(ret != 1);
ecore_main_loop_begin();
close(comm[0]);
close(comm[1]);
fail_if(did == EINA_FALSE);
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
static int
_event_handler_cb(void *data, int type __UNUSED__, void *event __UNUSED__)
{
Eina_Bool *val = data;
*val = EINA_TRUE;
ecore_main_loop_quit();
return 0;
}
START_TEST(ecore_test_ecore_main_loop_event)
{
Eina_Bool did = EINA_FALSE;
Ecore_Event_Handler *handler;
Ecore_Event *event;
int ret, type;
ret = ecore_init();
fail_if(ret != 1);
type = ecore_event_type_new();
fail_if(type < 1);
handler = ecore_event_handler_add(type, _event_handler_cb, &did);
fail_if(handler == NULL);
event = ecore_event_add(type, NULL, NULL, NULL);
fail_if(event == NULL);
ecore_main_loop_begin();
fail_if(did == EINA_FALSE);
ret = ecore_shutdown();
fail_if(ret != 0);
}
END_TEST
static int
_timer_quit_recursive(void *data)
{
INF(" _timer_quit_recursive: begin");
ecore_main_loop_quit(); /* quits inner main loop */
INF(" _timer_quit_recursive: end");
return 0;
}
static int
_event_recursive_cb(void *data, int type, void *event)
{
Ecore_Event *e;
static int guard = 0;
/* If we enter this callback more than once, it's wrong! */
fail_if(guard != 0);
guard++;
INF(" event_recursive_cb: begin");
ecore_timer_add(1.0, _timer_quit_recursive, NULL);
INF(" add 1.0s timer (once) to trigger _timer_quit_recursive");
INF(" inner main loop begin (recurse)");
ecore_main_loop_begin();
INF(" inner main loop end (recurse)");
ecore_main_loop_quit(); /* quits outer main loop */
INF(" guard = %d", guard);
INF(" event_recursive_cb: end");
return 0;
}
START_TEST(ecore_test_ecore_main_loop_event_recursive)
{
/* This test tests if the event handlers are really called only once when
* recursive main loops are used and any number of events may have occurred
* between the beginning and the end of recursive main loop.
*/
Ecore_Event *e;
int type;
_log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
INF("main: begin");
ecore_init();
type = ecore_event_type_new();
ecore_event_handler_add(type, _event_recursive_cb, NULL);
e = ecore_event_add(type, NULL, NULL, NULL);
INF(" add event to trigger cb1: event=%p", e);
INF(" main loop begin");
ecore_main_loop_begin();
INF(" main loop end");
INF("main: end");
ecore_shutdown();
}
END_TEST
void ecore_test_ecore(TCase *tc)
{
tcase_add_test(tc, ecore_test_ecore_init);
tcase_add_test(tc, ecore_test_ecore_main_loop);
tcase_add_test(tc, ecore_test_ecore_main_loop_idler);
tcase_add_test(tc, ecore_test_ecore_main_loop_idle_enterer);
tcase_add_test(tc, ecore_test_ecore_main_loop_idle_exiter);
tcase_add_test(tc, ecore_test_ecore_main_loop_timer);
tcase_add_test(tc, ecore_test_ecore_main_loop_fd_handler);
tcase_add_test(tc, ecore_test_ecore_main_loop_event);
tcase_add_test(tc, ecore_test_ecore_main_loop_timer_inner);
tcase_add_test(tc, ecore_test_ecore_main_loop_event_recursive);
}
a.spatch
Description: Binary data
_______________________________________________ Cocci mailing list [email protected] http://lists.diku.dk/mailman/listinfo/cocci (Web access from inside DIKUs LAN only)
