doc:
@echo "entering doc/"
make -C doc doc
+
+# Unit tests
+
+if EFL_ENABLE_TESTS
+
+check-local:
+ @./src/tests/ecore_suite
+
+else
+
+check-local:
+ @echo "reconfigure with --enable-tests"
+
+endif
AC_DEFINE([ENABLE_XIM], [1], [Enable X Input Method])
fi
+# Unit tests
+
+EFL_CHECK_TESTS([enable_tests="yes"], [enable_tests="no"])
+
### Checks for programs
m4_ifdef([AC_PROG_OBJC],
src/lib/ecore_x/Makefile
src/lib/ecore_x/xlib/Makefile
src/lib/ecore_x/xcb/Makefile
+src/tests/Makefile
README
ecore.spec
$po_makefile_in
echo " Software 16bit WinCE.......: $have_ecore_evas_software_16_wince"
fi
echo
+echo " Tests................: ${enable_tests}"
echo " Maximum log level....: ${with_max_log_level}"
echo "Documentation..........: ${build_doc}"
echo
MAINTAINERCLEANFILES = Makefile.in
-SUBDIRS = lib bin
+SUBDIRS = lib bin tests
}
}
- if ((!args) || (!args[0]))
- {
- IF_FREE(buf);
- IF_FREE(args);
- ERR("arg[0] is NULL!");
- return;
- }
-
if (!(flags & ECORE_EXE_NOT_LEADER)) setsid();
if ((flags & ECORE_EXE_USE_SH))
{
}
else
{ /* We can run this directly. */
+ if (!args)
+ {
+ IF_FREE(buf);
+ IF_FREE(args);
+ ERR("arg[0] is NULL!");
+ return;
+ }
errno = 0;
execvp(args[0], args);
}
err = write(fd[1], tosend, tosend_len);
}
-on_error:
if (result)
freeaddrinfo(result);
curl_easy_setopt(url_con->curl_easy, CURLOPT_PROGRESSFUNCTION,
_ecore_con_url_progress_cb);
curl_easy_setopt(url_con->curl_easy, CURLOPT_PROGRESSDATA, url_con);
- curl_easy_setopt(url_con->curl_easy, CURLOPT_NOPROGRESS, EINA_FALSE);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_NOPROGRESS, EINA_TRUE);
curl_easy_setopt(url_con->curl_easy, CURLOPT_HEADERFUNCTION,
_ecore_con_url_header_cb);
ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
ee->driver = "opengl_x11";
+ ee->no_comp_sync = 1; // gl engine doesnt need to sync - its whole swaps
if (disp_name) ee->name = strdup(disp_name);
if (w < 1) w = 1;
if (!isdir)
em->func(em->data, em, ECORE_FILE_EVENT_MODIFIED, buf);
}
+ if (mask & IN_MODIFY)
+ {
+ if (!isdir)
+ em->func(em->data, em, ECORE_FILE_EVENT_MODIFIED, buf);
+ }
if (mask & IN_MOVED_FROM)
{
if (isdir)
static int
_ecore_file_monitor_inotify_monitor(Ecore_File_Monitor *em, const char *path)
{
- int mask;
- mask = IN_ATTRIB|IN_CLOSE_WRITE|
- IN_MOVED_FROM|IN_MOVED_TO|
- IN_DELETE|IN_CREATE|
- IN_DELETE_SELF|IN_MOVE_SELF|
- IN_UNMOUNT;
- ECORE_FILE_MONITOR_INOTIFY(em)->wd = inotify_add_watch(ecore_main_fd_handler_fd_get(_fdh),
- path, mask);
+ int mask =
+ IN_ATTRIB |
+ IN_CLOSE_WRITE |
+ IN_MOVED_FROM |
+ IN_MOVED_TO |
+ IN_DELETE |
+ IN_CREATE |
+ IN_MODIFY |
+ IN_DELETE_SELF |
+ IN_MOVE_SELF |
+ IN_UNMOUNT;
+
+ ECORE_FILE_MONITOR_INOTIFY(em)->wd =
+ inotify_add_watch(ecore_main_fd_handler_fd_get(_fdh), path, mask);
if (ECORE_FILE_MONITOR_INOTIFY(em)->wd < 0)
{
ERR("inotify_add_watch error");
kc = "KP_Delete";
}
break;
+ case VK_SPACE:
+ kn = "space";
+ ks = "space";
+ kc = "space";
case VK_F1:
kn = "F1";
ks = "F1";
strncpy(ks, "Escape", 32);
strncpy(kc, "Escape", 32);
break;
+ case VK_SPACE:
+ strncpy(kn, "space", 32);
+ strncpy(ks, "space", 32);
+ strncpy(kc, "space", 32);
+ break;
default:
/* displayable characters */
printf (" * key : %d\n", key);
ks = "Delete";
kc = "Delete";
break;
+ case VK_SPACE:
+ kn = "space";
+ ks = "space";
+ kc = "space";
+ break;
case VK_F1:
kn = "F1";
ks = "F1";
strncpy(ks, "Escape", 32);
strncpy(kc, "Escape", 32);
break;
+ case VK_SPACE:
+ strncpy(kn, "space", 32);
+ strncpy(ks, "space", 32);
+ strncpy(kc, "space", 32);
+ break;
default:
/* displayable characters */
printf (" * key : %d\n", key);
unsigned int m;
unsigned int locks[8];
int i, ev;
+ Window *t;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
b = button;
XGrabButton(_ecore_x_disp, b, m | locks[i],
win, False, ev, GrabModeSync, GrabModeAsync, None, None);
_ecore_window_grabs_num++;
- _ecore_window_grabs = realloc(_ecore_window_grabs,
- _ecore_window_grabs_num * sizeof(Window));
+ t = realloc(_ecore_window_grabs,
+ _ecore_window_grabs_num * sizeof(Window));
+ if (!t) return;
+ _ecore_window_grabs = t;
_ecore_window_grabs[_ecore_window_grabs_num - 1] = win;
} /* ecore_x_window_button_grab */
_ecore_x_window_grab_remove(Ecore_X_Window win)
{
int i, shuffle = 0;
-
+ Window *t;
+
if (_ecore_window_grabs_num > 0)
{
for (i = 0; i < _ecore_window_grabs_num; i++)
if (shuffle)
{
_ecore_window_grabs_num--;
- _ecore_window_grabs = realloc(_ecore_window_grabs,
- _ecore_window_grabs_num *
- sizeof(Window));
+ if (_ecore_window_grabs_num <= 0)
+ {
+ free(_ecore_window_grabs);
+ _ecore_window_grabs = NULL;
+ return;
+ }
+ t = realloc(_ecore_window_grabs,
+ _ecore_window_grabs_num *
+ sizeof(Window));
+ if (!t) return;
+ _ecore_window_grabs = t;
}
}
} /* _ecore_x_window_grab_remove */
unsigned int m;
unsigned int locks[8];
int i;
+ Window *t;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
if (!strncmp(key, "Keycode-", 8))
XGrabKey(_ecore_x_disp, keycode, m | locks[i],
win, False, GrabModeSync, GrabModeAsync);
_ecore_key_grabs_num++;
- _ecore_key_grabs = realloc(_ecore_key_grabs,
- _ecore_key_grabs_num * sizeof(Window));
+ t = realloc(_ecore_key_grabs,
+ _ecore_key_grabs_num * sizeof(Window));
+ if (!t) return;
+ _ecore_key_grabs = t;
_ecore_key_grabs[_ecore_key_grabs_num - 1] = win;
} /* ecore_x_window_key_grab */
_ecore_x_key_grab_remove(Ecore_X_Window win)
{
int i, shuffle = 0;
-
+ Window *t;
+
if (_ecore_key_grabs_num > 0)
{
for (i = 0; i < _ecore_key_grabs_num; i++)
if (shuffle)
{
_ecore_key_grabs_num--;
- _ecore_key_grabs = realloc(_ecore_key_grabs,
- _ecore_key_grabs_num * sizeof(Window));
+ if (_ecore_key_grabs_num <= 0)
+ {
+ free(_ecore_key_grabs);
+ _ecore_key_grabs = NULL;
+ return;
+ }
+ t = realloc(_ecore_key_grabs,
+ _ecore_key_grabs_num * sizeof(Window));
+ if (!t) return;
+ _ecore_key_grabs = t;
}
}
} /* _ecore_x_key_grab_remove */
if (!_ecore_x_dnd_init_count)
{
_source = calloc(1, sizeof(Ecore_X_DND_Source));
+ if (!_source) return;
_source->version = ECORE_X_DND_VERSION;
_source->win = None;
_source->dest = None;
_source->prev.window = 0;
_target = calloc(1, sizeof(Ecore_X_DND_Target));
+ if (!_target)
+ {
+ free(_source);
+ _source = NULL;
+ return;
+ }
_target->win = None;
_target->source = None;
_target->state = ECORE_X_DND_TARGET_IDLE;
{
int bufsize = strlen((char *)text_prop.value) + 1;
*data_ret = malloc(bufsize);
+ if (!*data_ret)
+ {
+ free(mystr);
+ return EINA_FALSE;
+ }
memcpy(*data_ret, text_prop.value, bufsize);
*size_ret = bufsize;
XFree(text_prop.value);
{
unsigned char *prop_data;
int num;
+ Version_Cache_Item *t;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
// this looks hacky - and it is, but we need a way of caching info about
if (_version_cache_num > _version_cache_alloc)
_version_cache_alloc += 16;
- _version_cache = realloc(_version_cache,
- _version_cache_alloc *
- sizeof(Version_Cache_Item));
+ t = realloc(_version_cache,
+ _version_cache_alloc *
+ sizeof(Version_Cache_Item));
+ if (!t) return 0;
+ _version_cache = t;
_version_cache[_version_cache_num - 1].win = win;
_version_cache[_version_cache_num - 1].ver = version;
}
if (_version_cache_num > _version_cache_alloc)
_version_cache_alloc += 16;
- _version_cache =
- realloc(_version_cache, _version_cache_alloc *
- sizeof(Version_Cache_Item));
+ t = realloc(_version_cache, _version_cache_alloc *
+ sizeof(Version_Cache_Item));
+ if (!t) return 0;
+ _version_cache = t;
_version_cache[_version_cache_num - 1].win = win;
_version_cache[_version_cache_num - 1].ver = 0;
}
case ECORE_X_VIRTUAL_KEYBOARD_STATE_J2ME:
return ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_J2ME;
- default: return 0;
+ default: break;
} /* switch */
return 0;
} /* _ecore_x_e_vkbd_atom_get */
return ECORE_X_ATOM_E_ILLUME_MODE_DUAL_LEFT;
default:
- return ECORE_X_ILLUME_MODE_UNKNOWN;
+ break;
} /* switch */
return ECORE_X_ILLUME_MODE_UNKNOWN;
} /* _ecore_x_e_illume_atom_get */
return ECORE_X_ATOM_E_ILLUME_QUICKPANEL_OFF;
default:
- return 0;
+ break;
} /* switch */
return 0;
} /* _ecore_x_e_quickpanel_atom_get */
"Keycode-%i",
xevent->keycode);
keyname = keyname_buffer;
- if (!keyname)
- return;
}
sym = 0;
if (!key)
key = keyname;
- if (!key)
- goto on_error;
-
e =
malloc(sizeof(Ecore_Event_Key) + strlen(key) + strlen(keyname) +
(compose ? strlen(compose) : 0) + 3);
void
_ecore_x_event_handle_selection_clear(XEvent *xevent)
{
- Ecore_X_Selection_Intern *d;
+// Ecore_X_Selection_Intern *d;
Ecore_X_Event_Selection_Clear *e;
Ecore_X_Atom sel;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
_ecore_x_last_event_mouse_move = 0;
- d = _ecore_x_selection_get(xevent->xselectionclear.selection);
/* errr..... why? paranoia.
+ d = _ecore_x_selection_get(xevent->xselectionclear.selection);
if (d && (xevent->xselectionclear.time > d->time))
{
_ecore_x_selection_set(None, NULL, 0,
ecore_x_netwm_desk_names_set(Ecore_X_Window root,
const char **names, unsigned int n_desks)
{
- char ss[32], *buf;
+ char ss[32], *buf, *t;
const char *s;
unsigned int i;
int l, len;
}
l = strlen(s) + 1;
- buf = realloc(buf, len + l);
- memcpy(buf + len, s, l);
+ t = realloc(buf, len + l);
+ if (t)
+ {
+ buf = t;
+ memcpy(buf + len, s, l);
+ }
len += l;
}
{
return Ecore_X_Randr_Unset;
}
-#endif
+#else
return -1;
+#endif
}
Eina_Bool
sizes =
XRRSizes(_ecore_x_disp, XRRRootToScreen(_ecore_x_disp,
root), &n);
+ if ((!sizes) || (n <= 0)) return NULL;
ret = calloc(n, sizeof(Ecore_X_Randr_Screen_Size_MM));
if (!ret)
return NULL;
XFree(xss);
return idle;
-#endif /* ifdef ECORE_XSS */
-
+#else
return 0;
+#endif /* ifdef ECORE_XSS */
} /* ecore_x_screensaver_idle_time_get */
EAPI void
selections[in].time = _ecore_x_event_last_time;
buf = malloc(size);
+ if (!buf) return EINA_FALSE;
memcpy(buf, data, size);
selections[in].data = buf;
}
}
cnv->next = calloc(1, sizeof(Ecore_X_Selection_Converter));
+ if (!cnv->next) return;
cnv = cnv->next;
}
else
{
converters = calloc(1, sizeof(Ecore_X_Selection_Converter));
+ if (!converters) return;
cnv = converters;
}
{
int bufsize = strlen((char *)text_prop.value) + 1;
*data_ret = malloc(bufsize);
+ if (!*data_ret)
+ {
+ free(mystr);
+ return EINA_FALSE;
+ }
memcpy(*data_ret, text_prop.value, bufsize);
*size_ret = bufsize;
XFree(text_prop.value);
{
int bufsize = strlen(text_prop.value) + 1;
*data_ret = malloc(bufsize);
+ if (!*data_ret) return EINA_FALSE;
memcpy(*data_ret, text_prop.value, bufsize);
*size_ret = bufsize;
XFree(text_prop.value);
}
prs->next = calloc(1, sizeof(Ecore_X_Selection_Parser));
+ if (!prs->next) return;
prs = prs->next;
}
else
{
parsers = calloc(1, sizeof(Ecore_X_Selection_Parser));
+ if (!parsers) return;
prs = parsers;
}
/* Default, just return the data */
sel = calloc(1, sizeof(Ecore_X_Selection_Data));
+ if (!sel) return NULL;
sel->free = _ecore_x_selection_data_default_free;
sel->length = size;
sel->format = format;
int format __UNUSED__)
{
Ecore_X_Selection_Data_Files *sel;
- char *data = _data;
+ char *t, *data = _data;
int i, is;
char *tmp;
+ char **t2;
if (strcmp(target, "text/uri-list") &&
strcmp(target, "_NETSCAPE_URL"))
return NULL;
sel = calloc(1, sizeof(Ecore_X_Selection_Data_Files));
+ if (!sel) return NULL;
ECORE_X_SELECTION_DATA(sel)->free = _ecore_x_selection_data_files_free;
if (data[size - 1])
{
/* Isn't nul terminated */
size++;
- data = realloc(data, size);
+ t = realloc(data, size);
+ if (!t)
+ {
+ free(sel);
+ return NULL;
+ }
+ data = t;
data[size - 1] = 0;
}
tmp = malloc(size);
+ if (!tmp)
+ {
+ free(sel);
+ return NULL;
+ }
i = 0;
is = 0;
while ((is < size) && (data[is]))
while ((data[is] == '\r') || (data[is] == '\n')) is++;
tmp[i] = 0;
sel->num_files++;
- sel->files =
- realloc(sel->files, sel->num_files * sizeof(char *));
- sel->files[sel->num_files - 1] = strdup(tmp);
+ t2 = realloc(sel->files, sel->num_files * sizeof(char *));
+ if (t2)
+ {
+ sel->files = t2;
+ sel->files[sel->num_files - 1] = strdup(tmp);
+ }
tmp[0] = 0;
i = 0;
}
{
tmp[i] = 0;
sel->num_files++;
- sel->files = realloc(sel->files, sel->num_files * sizeof(char *));
- sel->files[sel->num_files - 1] = strdup(tmp);
+ t2 = realloc(sel->files, sel->num_files * sizeof(char *));
+ if (t2)
+ {
+ sel->files = t2;
+ sel->files[sel->num_files - 1] = strdup(tmp);
+ }
}
free(tmp);
{
Ecore_X_Selection_Data_Text *sel;
unsigned char *data = _data;
+ void *t;
sel = calloc(1, sizeof(Ecore_X_Selection_Data_Text));
-
+ if (!sel) return NULL;
if (data[size - 1])
{
/* Isn't nul terminated */
size++;
- data = realloc(data, size);
+ t = realloc(data, size);
+ if (!t)
+ {
+ free(sel);
+ return NULL;
+ }
+ data = t;
data[size - 1] = 0;
}
int i;
sel = calloc(1, sizeof(Ecore_X_Selection_Data_Targets));
+ if (!sel) return NULL;
targets = (unsigned long *)data;
sel->num_targets = size - 2;
sel->targets = malloc((size - 2) * sizeof(char *));
+ if (!sel->targets)
+ {
+ free(sel);
+ return NULL;
+ }
for (i = 2; i < size; i++)
sel->targets[i - 2] = XGetAtomName(_ecore_x_disp, targets[i]);
ecore_x_window_ignore_set(Ecore_X_Window win, int ignore)
{
int i, j;
+ Ecore_X_Window *t;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
if (ignore)
if (win == ignore_list[i])
return;
}
- ignore_list =
- realloc(ignore_list, (ignore_num + 1) * sizeof(Ecore_X_Window));
- if (!ignore_list)
- return;
-
+ t = realloc(ignore_list, (ignore_num + 1) * sizeof(Ecore_X_Window));
+ if (!t) return;
+ ignore_list = t;
ignore_list[ignore_num++] = win;
}
else
{
ignore_num = 0;
ignore_list = malloc(sizeof(Ecore_X_Window));
- ignore_list[ignore_num++] = win;
+ if (ignore_list)
+ ignore_list[ignore_num++] = win;
}
}
else
else
ignore_num--;
}
- ignore_list = realloc(ignore_list, ignore_num * sizeof(Ecore_X_Window));
+ if (ignore_num <= 0)
+ {
+ free(ignore_list);
+ ignore_list = NULL;
+ return;
+ }
+ t = realloc(ignore_list, ignore_num * sizeof(Ecore_X_Window));
+ if (t) ignore_list = t;
}
} /* ecore_x_window_ignore_set */
--- /dev/null
+MAINTAINERCLEANFILES = Makefile.in
+
+AM_CPPFLAGS = \
+-I$(top_srcdir)/src/lib/ecore \
+-I$(top_srcdir)/src/lib/ecore_con \
+-I$(top_srcdir)/src/lib/ecore_x \
+@EINA_CFLAGS@ \
+@CHECK_CFLAGS@
+
+if EFL_ENABLE_TESTS
+
+noinst_PROGRAMS = ecore_suite
+
+check_PROGRAMS = ecore_suite
+
+ecore_suite_SOURCES = \
+ecore_suite.c \
+ecore_test_ecore.c \
+ecore_test_ecore_con.c \
+ecore_test_ecore_x.c
+
+ecore_suite_LDADD = \
+@CHECK_LIBS@ \
+$(top_builddir)/src/lib/ecore/libecore.la \
+$(top_builddir)/src/lib/ecore_con/libecore_con.la
+
+if BUILD_ECORE_X
+ecore_suite_LDADD += \
+$(top_builddir)/src/lib/ecore_x/libecore_x.la
+endif
+
+endif
+
+EXTRA_DIST = ecore_suite.h
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <Ecore.h>
+
+#include "ecore_suite.h"
+
+typedef struct _Ecore_Test_Case Ecore_Test_Case;
+
+struct _Ecore_Test_Case
+{
+ const char *test_case;
+ void (*build)(TCase *tc);
+};
+
+static const Ecore_Test_Case etc[] = {
+ { "Ecore", ecore_test_ecore },
+ { "Ecore_Con", ecore_test_ecore_con },
+ { "Ecore_X", ecore_test_ecore_x },
+ { NULL, NULL }
+};
+
+static void
+_list_tests(void)
+{
+ const Ecore_Test_Case *itr;
+
+ itr = etc;
+ fputs("Available Test Cases:\n", stderr);
+ for (; itr->test_case; itr++)
+ fprintf(stderr, "\t%s\n", itr->test_case);
+}
+static Eina_Bool
+_use_test(int argc, const char **argv, const char *test_case)
+{
+ if (argc < 1)
+ return 1;
+
+ for (; argc > 0; argc--, argv++)
+ if (strcmp(test_case, *argv) == 0)
+ return 1;
+ return 0;
+}
+
+static Suite *
+ecore_suite_build(int argc, const char **argv)
+{
+ TCase *tc;
+ Suite *s;
+ int i;
+
+ s = suite_create("Ecore");
+
+ for (i = 0; etc[i].test_case; ++i)
+ {
+ if (!_use_test(argc, argv, etc[i].test_case)) continue;
+ tc = tcase_create(etc[i].test_case);
+
+ etc[i].build(tc);
+
+ suite_add_tcase(s, tc);
+ tcase_set_timeout(tc, 0);
+ }
+
+ return s;
+}
+
+int
+main(int argc, char **argv)
+{
+ Suite *s;
+ SRunner *sr;
+ int i, failed_count;
+
+ for (i = 1; i < argc; i++)
+ if ((strcmp(argv[i], "-h") == 0) ||
+ (strcmp(argv[i], "--help") == 0))
+ {
+ fprintf(stderr, "Usage:\n\t%s [test_case1 .. [test_caseN]]\n",
+ argv[0]);
+ _list_tests();
+ return 0;
+ }
+ else if ((strcmp(argv[i], "-l") == 0) ||
+ (strcmp(argv[i], "--list") == 0))
+ {
+ _list_tests();
+ return 0;
+ }
+
+ s = ecore_suite_build(argc - 1, (const char **)argv + 1);
+ sr = srunner_create(s);
+
+ srunner_run_all(sr, CK_ENV);
+ failed_count = srunner_ntests_failed(sr);
+ srunner_free(sr);
+
+ return (failed_count == 0) ? 0 : 255;
+}
--- /dev/null
+#ifndef _ECORE_SUITE_H
+#define _ECORE_SUITE_H
+
+#include <check.h>
+
+void ecore_test_ecore(TCase *tc);
+void ecore_test_ecore_con(TCase *tc);
+void ecore_test_ecore_x(TCase *tc);
+
+
+#endif /* _ECORE_SUITE_H */
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ecore_suite.h"
+
+#include <Ecore.h>
+#include <Eina.h>
+#include <unistd.h>
+#include <stdio.h>
+
+static int _log_dom;
+#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
+
+static Eina_Bool
+_quit_cb(void *data)
+{
+ Eina_Bool *val = data;
+ *val = EINA_TRUE;
+ ecore_main_loop_quit();
+ return EINA_FALSE;
+}
+
+static Eina_Bool
+_dummy_cb(void *data)
+{
+ return !!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 Eina_Bool _timer3(void *data)
+{
+ /* timer 3, do nothing */
+ return EINA_FALSE;
+}
+
+static Eina_Bool _timer2(void *data)
+{
+ /* timer 2, quit inner mainloop */
+ ecore_main_loop_quit();
+ return EINA_FALSE;
+}
+
+static Eina_Bool _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 EINA_FALSE;
+}
+
+START_TEST(ecore_test_ecore_main_loop_timer_inner)
+{
+ Ecore_Timer *timer;
+ int ret;
+ int times = 0;
+
+ ret = ecore_init();
+ fail_if(ret != 1);
+
+ timer = ecore_timer_add(1.0, _timer1, ×);
+ fail_if(timer == NULL);
+
+ /* BEGIN: outer mainloop */
+ ecore_main_loop_begin();
+ /*END: outer mainloop */
+
+ fail_if(times != 1);
+}
+END_TEST
+
+static Eina_Bool
+_fd_handler_cb(void *data, Ecore_Fd_Handler *handler __UNUSED__)
+{
+ /* FIXME: why setting val if it is overwritten just after and what is its purpose ??? */
+ Eina_Bool *val = data;
+
+ *val = EINA_TRUE;
+ ecore_main_loop_quit();
+ return EINA_FALSE;
+}
+
+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 Eina_Bool
+_event_handler_cb(void *data, int type __UNUSED__, void *event __UNUSED__)
+{
+ /* FIXME: why setting val if it is overwritten just after and what is its purpose ??? */
+ Eina_Bool *val = data;
+
+ *val = EINA_TRUE;
+ ecore_main_loop_quit();
+ return EINA_FALSE;
+}
+
+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 Eina_Bool
+_timer_quit_recursive(void *data)
+{
+ INF(" _timer_quit_recursive: begin");
+ ecore_main_loop_quit(); /* quits inner main loop */
+ INF(" _timer_quit_recursive: end");
+ return EINA_FALSE;
+}
+
+static Eina_Bool
+_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 EINA_FALSE;
+}
+
+
+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;
+ int ret;
+
+ _log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
+
+ INF("main: begin");
+ ret = ecore_init();
+ fail_if(ret != 1);
+
+
+ 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);
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Ecore_Con.h>
+
+#include "ecore_suite.h"
+
+
+START_TEST(ecore_test_ecore_con_init)
+{
+ int ret;
+
+ ret = ecore_con_init();
+ fail_if(ret != 1);
+
+ ret = ecore_con_shutdown();
+ fail_if(ret != 0);
+}
+END_TEST
+
+void ecore_test_ecore_con(TCase *tc)
+{
+ tcase_add_test(tc, ecore_test_ecore_con_init);
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Ecore_X.h>
+
+#include "ecore_suite.h"
+
+
+/* TODO: change to HAVE_ECORE_X when xcb implementation is done */
+#ifdef HAVE_ECORE_X_XLIB
+
+START_TEST(ecore_test_ecore_x_init)
+{
+ int ret;
+
+ ret = ecore_x_init(NULL);
+ fail_if(ret != 1);
+
+ ret = ecore_x_shutdown();
+ fail_if(ret != 0);
+}
+END_TEST
+
+START_TEST(ecore_test_ecore_x_bell)
+{
+ int i;
+ int ret;
+
+ ret = ecore_x_init(NULL);
+ fail_if(ret != 1);
+
+ printf("You should hear 3 beeps now.\n");
+ for (i = 0; i < 3; i++)
+ {
+ ret = ecore_x_bell(0);
+ fail_if(ret != EINA_TRUE);
+ ecore_x_sync();
+ sleep(1);
+ }
+
+ ecore_x_shutdown();
+}
+END_TEST
+
+#endif
+
+void ecore_test_ecore_x(TCase *tc)
+{
+
+/* TODO: change to HAVE_ECORE_X when xcb implementation is done */
+#ifdef HAVE_ECORE_X_XLIB
+ tcase_add_test(tc, ecore_test_ecore_x_init);
+ tcase_add_test(tc, ecore_test_ecore_x_bell);
+#endif
+}
projects / profile / ivi / ecore.git / commitdiff