#define _ECORE_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void ecore_test_ecore(TCase *tc);
void ecore_test_ecore_x(TCase *tc);
void ecore_test_ecore_imf(TCase *tc);
return EINA_TRUE;
}
-START_TEST(ecore_test_animators)
+EFL_START_TEST(ecore_test_animators)
{
Ecore_Animator *animator;
double interval1 = 0.02;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
Eina_Bool test_pos(Ecore_Pos_Map posmap, double v1, double v2, double (*testmap)(double val, double v1, double v2))
{
return (1 - cos(val * M_PI)) / 2;
}
-START_TEST(ecore_test_pos_map)
+EFL_START_TEST(ecore_test_pos_map)
{
fail_if(!test_pos(ECORE_POS_MAP_LINEAR, 0, 0, _linear));
fail_if(!test_pos(ECORE_POS_MAP_ACCELERATE, 0, 0, _accel));
fail_if(!test_pos(ECORE_POS_MAP_DECELERATE, 0, 0, _decel));
fail_if(!test_pos(ECORE_POS_MAP_SINUSOIDAL, 0, 0, _sinusoidal));
}
-END_TEST
+EFL_END_TEST
static void _animator_called_cb(void *data)
{
return ECORE_CALLBACK_CANCEL;
}
-START_TEST(ecore_test_begin_end_tick)
+EFL_START_TEST(ecore_test_begin_end_tick)
{
Ecore_Timer *timer1, *timer2;
Ecore_Animator *animator;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_animator(TCase *tc)
{
ecore_main_loop_quit();
}
-START_TEST(ecore_test_args1)
+EFL_START_TEST(ecore_test_args1)
{
ecore_init();
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_cb_args2(void *data EINA_UNUSED, const Efl_Event *event)
ecore_main_loop_quit();
}
-START_TEST(ecore_test_args2)
+EFL_START_TEST(ecore_test_args2)
{
const char *simple_args[] = {
"hello world"
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_cb_args3(void *data EINA_UNUSED, const Efl_Event *event)
ecore_main_loop_quit();
}
-START_TEST(ecore_test_args3)
+EFL_START_TEST(ecore_test_args3)
{
ecore_init();
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_args(TCase *tc)
{
return !!data;
}
-START_TEST(ecore_test_ecore_init)
+EFL_START_TEST(ecore_test_ecore_init)
{
int ret;
ret = ecore_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop)
+EFL_START_TEST(ecore_test_ecore_main_loop)
{
Eina_Bool did = EINA_FALSE;
Ecore_Timer *timer;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop_idler)
+EFL_START_TEST(ecore_test_ecore_main_loop_idler)
{
Eina_Bool did = EINA_FALSE;
Ecore_Idler *idler;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop_idle_enterer)
+EFL_START_TEST(ecore_test_ecore_main_loop_idle_enterer)
{
Eina_Bool did = EINA_FALSE;
Ecore_Idle_Enterer *idle_enterer;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop_idle_before_enterer)
+EFL_START_TEST(ecore_test_ecore_main_loop_idle_before_enterer)
{
Eina_Bool did = EINA_FALSE;
Ecore_Idle_Enterer *idle_enterer;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop_idle_exiter)
+EFL_START_TEST(ecore_test_ecore_main_loop_idle_exiter)
{
Eina_Bool did = EINA_FALSE;
Ecore_Timer *timer;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop_timer)
+EFL_START_TEST(ecore_test_ecore_main_loop_timer)
{
Eina_Bool did = EINA_FALSE;
Ecore_Timer *timer;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
// Disabled tests: inner main loops are not supposed to work!
#if 0
return EINA_FALSE;
}
-START_TEST(ecore_test_ecore_main_loop_timer_inner)
+EFL_START_TEST(ecore_test_ecore_main_loop_timer_inner)
{
Ecore_Timer *timer;
int ret;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
static Eina_Bool
return EINA_FALSE;
}
-START_TEST(ecore_test_ecore_main_loop_fd_handler)
+EFL_START_TEST(ecore_test_ecore_main_loop_fd_handler)
{
Eina_Bool did = EINA_FALSE;
Ecore_Fd_Handler *fd_handler;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop_fd_handler_valid_flags)
+EFL_START_TEST(ecore_test_ecore_main_loop_fd_handler_valid_flags)
{
Ecore_Fd_Handler *fd_handler;
int comm[2];
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_eo_read_cb(void *data, const Efl_Event *info EINA_UNUSED)
ecore_main_loop_quit();
}
-START_TEST(ecore_test_efl_loop_fd)
+EFL_START_TEST(ecore_test_efl_loop_fd)
{
Eina_Bool did = EINA_FALSE;
Eo *fd;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_efl_del_cb(void *data, const Efl_Event *ev EINA_UNUSED)
*dead = EINA_TRUE;
}
-START_TEST(ecore_test_efl_loop_fd_lifecycle)
+EFL_START_TEST(ecore_test_efl_loop_fd_lifecycle)
{
Eina_Bool did = EINA_FALSE;
Eina_Bool dead = EINA_FALSE;
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_main_loop_fd_handler_activate_modify)
+EFL_START_TEST(ecore_test_ecore_main_loop_fd_handler_activate_modify)
{
Eina_Bool did = EINA_FALSE;
Ecore_Fd_Handler *fd_handler;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
_event_handler_cb(void *data, int type, void *event)
(*fdid)++;
}
-START_TEST(ecore_test_ecore_main_loop_event)
+EFL_START_TEST(ecore_test_ecore_main_loop_event)
{
Ecore_Event_Handler *handler, *handler2, *handler3;
Ecore_Event_Filter *filter_handler;
res_counter = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
#if 0
static int _log_dom;
return EINA_FALSE;
}
-START_TEST(ecore_test_ecore_main_loop_event_recursive)
+EFL_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
INF("main: end");
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(ecore_test_ecore_app)
+EFL_START_TEST(ecore_test_ecore_app)
{
int ret;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
Eina_Bool _poller_cb(void *data)
{
return ECORE_CALLBACK_RENEW;
}
-START_TEST(ecore_test_ecore_main_loop_poller)
+EFL_START_TEST(ecore_test_ecore_main_loop_poller)
{
int ret;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
Eina_Bool _poller_handler(void *data)
{
return ECORE_CALLBACK_RENEW;
}
-START_TEST(ecore_test_ecore_main_loop_poller_add_del)
+EFL_START_TEST(ecore_test_ecore_main_loop_poller_add_del)
{
int ret, count_res = 0;
ret = ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore(TCase *tc)
{
return EINA_FALSE;
}
-START_TEST(ecore_test_ecore_audio_obj_pulse)
+EFL_START_TEST(ecore_test_ecore_audio_obj_pulse)
{
Eo *in, *out;
Eina_Bool ret = EINA_FALSE;
efl_del(out);
efl_del(in);
}
-END_TEST
+EFL_END_TEST
#endif
#endif
return EINA_FALSE;
}
-START_TEST(ecore_test_ecore_audio_cleanup)
+EFL_START_TEST(ecore_test_ecore_audio_cleanup)
{
Eo *in, *out;
int freq = 1000;
ecore_file_remove(TESTS_BUILD_DIR"/tmp.ogg");
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_audio_obj_tone)
+EFL_START_TEST(ecore_test_ecore_audio_obj_tone)
{
Eo *in, *out;
double len;
//TODO: Compare and fail
ecore_file_remove(TESTS_BUILD_DIR"/tmp.wav");
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_audio_obj_sndfile)
+EFL_START_TEST(ecore_test_ecore_audio_obj_sndfile)
{
Eo *in, *out;
double len, rem;
//TODO: Compare and fail
ecore_file_remove(TESTS_BUILD_DIR"/tmp.wav");
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_audio_obj_in_out)
+EFL_START_TEST(ecore_test_ecore_audio_obj_in_out)
{
Eo *out2;
Eina_List *in3;
efl_del(in);
}
-END_TEST
+EFL_END_TEST
static int read_cb(void *data EINA_UNUSED, Eo *eo_obj EINA_UNUSED, void *buffer, int len)
{
.write = write_cb,
};
-START_TEST(ecore_test_ecore_audio_obj_vio)
+EFL_START_TEST(ecore_test_ecore_audio_obj_vio)
{
Eo *in, *out;
efl_del(out);
efl_del(in);
}
-END_TEST
+EFL_END_TEST
static void _myfree(void *data)
{
*freed = EINA_TRUE;
}
-START_TEST(ecore_test_ecore_audio_obj_in)
+EFL_START_TEST(ecore_test_ecore_audio_obj_in)
{
int i;
double speed, length;
efl_del(in);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_audio_obj)
+EFL_START_TEST(ecore_test_ecore_audio_obj)
{
int i;
const char *name;
}
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_audio_init)
+EFL_START_TEST(ecore_test_ecore_audio_init)
{
int ret;
ck_assert_int_eq(ret, 1);
}
-END_TEST
+EFL_END_TEST
void setup(void)
{
#define MAX_ITER 10
-START_TEST(ecore_test_ecore_drm_shutdown_bef_init)
+EFL_START_TEST(ecore_test_ecore_drm_shutdown_bef_init)
{
int ret = 0;
fprintf(stderr, "Calling ecore_drm_shutdown after ecore_drm_init.\n");
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_drm_init)
+EFL_START_TEST(ecore_test_ecore_drm_init)
{
int ret, i, j;
fail_if(ret != j);
}
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_drm(TCase *tc)
{
#define WINDOW_HEIGHT 200
#define WINDOW_WIDTH 200
-START_TEST(ecore_test_ecore_evas_associate)
+EFL_START_TEST(ecore_test_ecore_evas_associate)
{
Ecore_Evas *ee;
Evas *canvas;
ret = ecore_evas_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_evas_cocoa)
+EFL_START_TEST(ecore_test_ecore_evas_cocoa)
{
int ret;
Ecore_Evas *ee;
ret = ecore_evas_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_evas(TCase *tc)
{
#define MAX_ITER 10
-START_TEST(ecore_test_ecore_fb_init)
+EFL_START_TEST(ecore_test_ecore_fb_init)
{
// SKIP fb test as all it tests is init and shutdown and nothing else
// and these require basically a linux box with root or special
}
*/
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_fb(TCase *tc)
{
return ECORE_FILE_PROGRESS_CONTINUE;
}
-START_TEST(ecore_test_ecore_file_init)
+EFL_START_TEST(ecore_test_ecore_file_init)
{
int ret;
ret = ecore_file_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_file_operations)
+EFL_START_TEST(ecore_test_ecore_file_operations)
{
const char* dirs[] = {"b", "b/c", "b/c/d", "d", 0};
char *dirs2[] = {"a2", "b2", "c2", 0};
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_file_path)
+EFL_START_TEST(ecore_test_ecore_file_path)
{
const char *src_dir, *src_file, *dest_file;
char *dup_dir, *path;
ret = ecore_file_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_file_monitor)
+EFL_START_TEST(ecore_test_ecore_file_monitor)
{
Ecore_File_Monitor *mon;
const char *src_dir;
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_file_download)
+EFL_START_TEST(ecore_test_ecore_file_download)
{
const char *download_dir;
const char *download_file;
ret = ecore_file_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_file(TCase *tc)
{
#include "ecore_suite.h"
-START_TEST(ecore_test_ecore_imf_init)
+EFL_START_TEST(ecore_test_ecore_imf_init)
{
ecore_imf_init();
ecore_imf_shutdown();
}
-END_TEST
+EFL_END_TEST
static const char *built_modules[] = {
#ifdef ENABLE_XIM
return EINA_FALSE;
}
-START_TEST(ecore_test_ecore_imf_modules)
+EFL_START_TEST(ecore_test_ecore_imf_modules)
{
Eina_List *modules;
const char **itr;
eina_list_free(modules);
ecore_imf_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_imf_modules_load)
+EFL_START_TEST(ecore_test_ecore_imf_modules_load)
{
const char **itr;
ecore_imf_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_imf(TCase *tc)
{
#define MAX_ITER 10
-START_TEST(ecore_test_ecore_input_init)
+EFL_START_TEST(ecore_test_ecore_input_init)
{
int ret, i, j;
fail_if(ret != j);
}
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_input(TCase *tc)
{
}
}
-START_TEST(ecore_test_ecore_thread_eina_thread_queue_t1)
+EFL_START_TEST(ecore_test_ecore_thread_eina_thread_queue_t1)
{
int val = 99;
ecore_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
/////////////////////////////////////////////////////////////////////////////
typedef struct
}
}
-START_TEST(ecore_test_ecore_thread_eina_thread_queue_t2)
+EFL_START_TEST(ecore_test_ecore_thread_eina_thread_queue_t2)
{
Msg2 *msg;
void *ref;
ecore_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
/////////////////////////////////////////////////////////////////////////////
typedef struct
}
}
-START_TEST(ecore_test_ecore_thread_eina_thread_queue_t3)
+EFL_START_TEST(ecore_test_ecore_thread_eina_thread_queue_t3)
{
int val1 = 99, val2 = 99, cnt = 0;
Eina_Thread_Queue *parent;
ecore_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
/////////////////////////////////////////////////////////////////////////////
typedef struct
}
-START_TEST(ecore_test_ecore_thread_eina_thread_queue_t4)
+EFL_START_TEST(ecore_test_ecore_thread_eina_thread_queue_t4)
{
int cnt = 0;
int val1 = 99, val2 = 9999;
ecore_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
/////////////////////////////////////////////////////////////////////////////
typedef struct
}
-START_TEST(ecore_test_ecore_thread_eina_thread_queue_t5)
+EFL_START_TEST(ecore_test_ecore_thread_eina_thread_queue_t5)
{
int val = 99;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
/////////////////////////////////////////////////////////////////////////////
typedef struct
if (DEBUG) printf("%s: message reading done!\n", __FUNCTION__);
}
-START_TEST(ecore_test_ecore_thread_eina_thread_queue_t6)
+EFL_START_TEST(ecore_test_ecore_thread_eina_thread_queue_t6)
{
Ecore_Thread *t1, *t2, *t3;
int do_break = 0;
ecore_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
/////////////////////////////////////////////////////////////////////////////
typedef struct
}
}
-START_TEST(ecore_test_ecore_thread_eina_thread_queue_t7)
+EFL_START_TEST(ecore_test_ecore_thread_eina_thread_queue_t7)
{
Msg7 *msg;
void *ref;
ecore_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_thread_eina_thread_queue(TCase *tc EINA_UNUSED)
{
#include <Ecore_X.h>
-START_TEST(ecore_test_ecore_x_init)
+EFL_START_TEST(ecore_test_ecore_x_init)
{
int ret;
ret = ecore_x_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_x_bell)
+EFL_START_TEST(ecore_test_ecore_x_bell)
{
int i;
int ret;
ecore_x_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
ecore_main_loop_quit();
}
-START_TEST(ecore_test_job)
+EFL_START_TEST(ecore_test_job)
{
Eina_Bool bob = EINA_FALSE;
Ecore_Job *job;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_job(TCase *tc)
{
}
// Test value set after then
-START_TEST(efl_test_promise_future_success)
+EFL_START_TEST(efl_test_promise_future_success)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
// Test value set before future_get
-START_TEST(efl_test_promise_future_success_before_get)
+EFL_START_TEST(efl_test_promise_future_success_before_get)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_cancel)
+EFL_START_TEST(efl_test_promise_future_cancel)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
// Test value set before then
-START_TEST(efl_test_promise_before_future_success)
+EFL_START_TEST(efl_test_promise_before_future_success)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_before_future_cancel)
+EFL_START_TEST(efl_test_promise_before_future_cancel)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_chain_then(void *data, const Efl_Event *ev)
}
// Test chained then
-START_TEST(efl_test_promise_future_chain_success)
+EFL_START_TEST(efl_test_promise_future_chain_success)
{
Efl_Promise *p;
Efl_Future *f1, *f2;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_chain_cancel)
+EFL_START_TEST(efl_test_promise_future_chain_cancel)
{
Efl_Promise *p;
Efl_Future *f1, *f2;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
// Test value set after multi then
-START_TEST(efl_test_promise_future_multi_success)
+EFL_START_TEST(efl_test_promise_future_multi_success)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_multi_success_noref)
+EFL_START_TEST(efl_test_promise_future_multi_success_noref)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_multi_cancel)
+EFL_START_TEST(efl_test_promise_future_multi_cancel)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
// Test value set before multi then
-START_TEST(efl_test_promise_before_future_multi_success)
+EFL_START_TEST(efl_test_promise_before_future_multi_success)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_before_future_multi_success_noref)
+EFL_START_TEST(efl_test_promise_before_future_multi_success_noref)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_before_future_multi_cancel)
+EFL_START_TEST(efl_test_promise_before_future_multi_cancel)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_before_future_multi_cancel_noref)
+EFL_START_TEST(efl_test_promise_before_future_multi_cancel_noref)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool cleanup = EINA_FALSE;
}
// Test optional value set without then
-START_TEST(efl_test_promise_future_optional_success)
+EFL_START_TEST(efl_test_promise_future_optional_success)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_optional_cancel)
+EFL_START_TEST(efl_test_promise_future_optional_cancel)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static int value[] = { 42, 7, 3 };
fo->then = EINA_TRUE;
}
-START_TEST(efl_test_promise_all)
+EFL_START_TEST(efl_test_promise_all)
{
Efl_Promise *p1, *p2, *p3;
Efl_Future *all = NULL, *f1;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_all_after_value_set)
+EFL_START_TEST(efl_test_promise_all_after_value_set)
{
Efl_Promise *p1, *p2, *p3;
Efl_Future *all = NULL, *f1, *f2, *f3;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_then_race(void *data, const Efl_Event *ev)
fo->then = EINA_TRUE;
}
-START_TEST(efl_test_promise_race)
+EFL_START_TEST(efl_test_promise_race)
{
Efl_Promise *p1, *p2, *p3;
Efl_Future *race = NULL, *f1;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_future_link)
+EFL_START_TEST(efl_test_future_link)
{
Efl_Promise *p;
Efl_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static Efl_Future *recursive_future = NULL;
efl_future_cancel(recursive_future);
}
-START_TEST(efl_test_recursive_mess)
+EFL_START_TEST(efl_test_recursive_mess)
{
Efl_Promise *p;
Future_Ok done = { EINA_FALSE, EINA_FALSE, EINA_FALSE };
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_ecore_promise(TCase *tc)
{
return value;
}
-START_TEST(efl_test_timeout)
+EFL_START_TEST(efl_test_timeout)
{
Eina_Future *f;
Eina_Bool done = EINA_FALSE;
fail_unless(done);
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_job)
+EFL_START_TEST(efl_test_job)
{
Eina_Future *f;
Eina_Bool done = EINA_FALSE;
fail_unless(done);
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_idle)
+EFL_START_TEST(efl_test_idle)
{
Eina_Future *f;
Eina_Bool done = EINA_FALSE;
fail_unless(done);
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_success)
+EFL_START_TEST(efl_test_promise_future_success)
{
Eina_Future *f;
fail_if(!ecore_init());
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_failure)
+EFL_START_TEST(efl_test_promise_future_failure)
{
Eina_Future *f;
fail_if(!ecore_init());
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_chain_no_error)
+EFL_START_TEST(efl_test_promise_future_chain_no_error)
{
Eina_Future *f;
static int i = 0;
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_chain_error)
+EFL_START_TEST(efl_test_promise_future_chain_error)
{
Eina_Future *f;
static int i = 0;
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_cancel)
+EFL_START_TEST(efl_test_promise_future_cancel)
{
fail_if(!ecore_init());
int i;
}
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_inner_promise)
+EFL_START_TEST(efl_test_promise_future_inner_promise)
{
Eina_Future *f;
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_inner_promise_fail)
+EFL_START_TEST(efl_test_promise_future_inner_promise_fail)
{
Eina_Future *f;
void *data =(void *) 0x01;
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_implicit_cancel)
+EFL_START_TEST(efl_test_promise_future_implicit_cancel)
{
Eina_Promise *p;
Eina_Future *f;
//Cancel should not be called, since we called eina_promise_resolve()
fail_if(cancel_called);
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_convert)
+EFL_START_TEST(efl_test_promise_future_convert)
{
Eina_Future *f;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_easy)
+EFL_START_TEST(efl_test_promise_future_easy)
{
Eina_Future *f;
Easy_Ctx easy1 = { 0 };
fail_if(!(easy2.success_called && !easy2.error_called && easy2.free_called));
fail_if(!(!easy3.success_called && easy3.error_called && easy3.free_called));
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_all)
+EFL_START_TEST(efl_test_promise_future_all)
{
Eina_Future *futures[11];
unsigned int i, futures_called = 0, len = EINA_C_ARRAY_LENGTH(futures);
ecore_shutdown();
fail_if(futures_called != len);
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_future_race)
+EFL_START_TEST(efl_test_promise_future_race)
{
Race_Ctx ctx = { 0 };
Eina_Future *futures[11];
fail_if(ctx.success != 1);
fail_if(ctx.failed != (len - 1));
}
-END_TEST
+EFL_END_TEST
static Eina_Value
_eo_future1_ok(Eo *eo EINA_UNUSED, const Eina_Value v)
return v;
}
-START_TEST(efl_test_promise_eo)
+EFL_START_TEST(efl_test_promise_eo)
{
Eina_Future *f;
Eo *obj;
efl_object_shutdown();
ck_assert_int_eq(free_called, 2);
}
-END_TEST
+EFL_END_TEST
static Eina_Value
_eo_future_link_success(Eo *eo EINA_UNUSED, const Eina_Value v)
return v;
}
-START_TEST(efl_test_promise_eo_link)
+EFL_START_TEST(efl_test_promise_eo_link)
{
Eina_Future *f;
Eo *obj;
efl_object_shutdown();
ck_assert_int_eq(err_called, 6);
}
-END_TEST
+EFL_END_TEST
static Eina_Value
_err_ignored(void *data EINA_UNUSED, const Eina_Value v, const Eina_Future *f EINA_UNUSED)
return v;
}
-START_TEST(efl_test_promise_future_ignore_error)
+EFL_START_TEST(efl_test_promise_future_ignore_error)
{
Eina_Future *f;
ecore_main_loop_begin();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
#define PROMISE_LOG_DOMAIN_STR ("promise_test_domain")
*log_ok = EINA_TRUE;
}
-START_TEST(efl_test_promise_log)
+EFL_START_TEST(efl_test_promise_log)
{
Promise_Log_Ctx ctx = { 0 };
Eina_Future *f;
fail_if(!ctx.err_log_ok);
fail_if(!ctx.info_log_ok);
}
-END_TEST
+EFL_END_TEST
#ifdef EINA_SAFETY_CHECKS
{
}
-START_TEST(efl_test_promise_null)
+EFL_START_TEST(efl_test_promise_null)
{
Log_Ctx ctx = { 0 };
Eina_Promise *p;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_promise_reject_resolve_null)
+EFL_START_TEST(efl_test_promise_reject_resolve_null)
{
Log_Ctx ctx = { 0 };
Eina_Value v;
fail_unless(ctx.did);
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Value
_future_null_cb(void *data, const Eina_Value v, const Eina_Future *dead)
(*cb_called)++;
}
-START_TEST(efl_test_future_null)
+EFL_START_TEST(efl_test_future_null)
{
Eina_Future *f;
Log_Ctx ctx = { 0 };
ck_assert_int_eq(easy_cb_calls, 2);
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Value
_future_race_all_null_cb(void *data, const Eina_Value v, const Eina_Future *dead EINA_UNUSED)
return v;
}
-START_TEST(efl_test_future_all_null)
+EFL_START_TEST(efl_test_future_all_null)
{
Log_Ctx ctx = { 0 };
unsigned i, len;
ecore_shutdown();
ck_assert_int_eq(cb_called, len);
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_future_race_null)
+EFL_START_TEST(efl_test_future_race_null)
{
Log_Ctx ctx = { 0 };
unsigned i, len;
ecore_shutdown();
ck_assert_int_eq(cb_called, len);
}
-END_TEST
+EFL_END_TEST
#endif
Timer 5 finishes testing.
*/
-START_TEST(ecore_test_timers)
+EFL_START_TEST(ecore_test_timers)
{
struct _timers timer = \
{
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
typedef struct _Test_Inside_Call
{
return it != 0;
}
-START_TEST(ecore_test_timer_inside_call)
+EFL_START_TEST(ecore_test_timer_inside_call)
{
Test_Inside_Call c;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
_test_time_cb(void *data)
_test_time_cb(data);
}
-START_TEST(ecore_test_timer_lifecycle)
+EFL_START_TEST(ecore_test_timer_lifecycle)
{
Eina_Bool rl = EINA_FALSE, re = EINA_FALSE;
Eina_Bool dl = EINA_FALSE, de = EINA_FALSE;
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_timer_valid_callbackfunc)
+EFL_START_TEST(ecore_test_timer_valid_callbackfunc)
{
fail_if(!ecore_init(), "ERROR: Cannot init Ecore!\n");
Ecore_Timer *t = NULL;
fail_if((t = ecore_timer_add(0.5, NULL, NULL)), "ERROR: Invalid callback func!\n");
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_test_timer(TCase *tc)
{
#include "efl_app_suite.h"
#include "../efl_check.h"
-START_TEST(efl_app_test_efl_loop_register)
+EFL_START_TEST(efl_app_test_efl_loop_register)
{
Efl_Object *t, *n;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_app_test_efl_build_version)
+EFL_START_TEST(efl_app_test_efl_build_version)
{
const Efl_Version *ver;
Eo *app;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void efl_test_efl_app(TCase *tc)
{
#define _EFL_APP_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void efl_app_test_efl_app(TCase *tc);
#endif /* _EFL_APP_SUITE_H */
#define _ECORE_CON_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void ecore_con_test_ecore_con(TCase *tc);
void ecore_con_test_ecore_con_url(TCase *tc);
void ecore_con_test_ecore_con_eet(TCase *tc);
ret = eina_shutdown();
}
-START_TEST(ecore_test_ecore_con_local_user)
+EFL_START_TEST(ecore_test_ecore_con_local_user)
{
_ecore_con_server_client_tests(ECORE_CON_LOCAL_USER, "test_sock", EINA_FALSE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_user_home)
+EFL_START_TEST(ecore_test_ecore_con_local_user_home)
{
const char *xdg_runtime_dir = getenv("XDG_RUNTIME_DIR");
_ecore_con_server_client_tests(ECORE_CON_LOCAL_USER, "test_soc", EINA_FALSE, 12345);
if (xdg_runtime_dir) setenv("XDG_RUNTIME_DIR", xdg_runtime_dir, 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_user_tmp)
+EFL_START_TEST(ecore_test_ecore_con_local_user_tmp)
{
const char *xdg_runtime_dir = getenv("XDG_RUNTIME_DIR");
const char *homedir = getenv("HOME");
if (homedir) setenv("HOME", homedir, 1);
if (xdg_runtime_dir) setenv("XDG_RUNTIME_DIR", xdg_runtime_dir, 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_user_none)
+EFL_START_TEST(ecore_test_ecore_con_local_user_none)
{
const char *xdg_runtime_dir = getenv("XDG_RUNTIME_DIR");
const char *homedir = getenv("HOME");
if (homedir) setenv("HOME", homedir, 1);
if (xdg_runtime_dir) setenv("XDG_RUNTIME_DIR", xdg_runtime_dir, 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_system)
+EFL_START_TEST(ecore_test_ecore_con_local_system)
{
_ecore_con_server_client_tests(ECORE_CON_LOCAL_SYSTEM, "test_sock", EINA_FALSE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_system_fullpath)
+EFL_START_TEST(ecore_test_ecore_con_local_system_fullpath)
{
_ecore_con_server_client_tests(ECORE_CON_LOCAL_SYSTEM, "/tmp/test_sock", EINA_FALSE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_system_negport)
+EFL_START_TEST(ecore_test_ecore_con_local_system_negport)
{
_ecore_con_server_client_tests(ECORE_CON_LOCAL_SYSTEM, "test_sock", EINA_FALSE, -6);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_system_negport_fullpath)
+EFL_START_TEST(ecore_test_ecore_con_local_system_negport_fullpath)
{
_ecore_con_server_client_tests(ECORE_CON_LOCAL_SYSTEM, "/tmp/test_sock", EINA_FALSE, -6);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_local_abstract)
+EFL_START_TEST(ecore_test_ecore_con_local_abstract)
{
_ecore_con_server_client_tests(ECORE_CON_LOCAL_ABSTRACT, "test_sock", EINA_FALSE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_tcp)
+EFL_START_TEST(ecore_test_ecore_con_remote_tcp)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_TCP, "127.0.0.1", EINA_FALSE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_nodelay)
+EFL_START_TEST(ecore_test_ecore_con_remote_nodelay)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_NODELAY, "127.0.0.1", EINA_FALSE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_tcp_tls)
+EFL_START_TEST(ecore_test_ecore_con_remote_tcp_tls)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_TLS, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_tcp_tls_load_cert)
+EFL_START_TEST(ecore_test_ecore_con_remote_tcp_tls_load_cert)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_TLS | ECORE_CON_LOAD_CERT, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_tcp_mixed)
+EFL_START_TEST(ecore_test_ecore_con_remote_tcp_mixed)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_MIXED, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_tcp_mixed_load_cert)
+EFL_START_TEST(ecore_test_ecore_con_remote_tcp_mixed_load_cert)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_nodelay_tls)
+EFL_START_TEST(ecore_test_ecore_con_remote_nodelay_tls)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_NODELAY | ECORE_CON_USE_TLS, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_nodelay_tls_load_cert)
+EFL_START_TEST(ecore_test_ecore_con_remote_nodelay_tls_load_cert)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_NODELAY | ECORE_CON_USE_TLS | ECORE_CON_LOAD_CERT, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_nodelay_mixed)
+EFL_START_TEST(ecore_test_ecore_con_remote_nodelay_mixed)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_NODELAY | ECORE_CON_USE_MIXED, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_remote_nodelay_mixed_load_cert)
+EFL_START_TEST(ecore_test_ecore_con_remote_nodelay_mixed_load_cert)
{
_ecore_con_server_client_tests(ECORE_CON_REMOTE_NODELAY | ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT, "127.0.0.1", EINA_TRUE, 12345);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_ssl_available)
+EFL_START_TEST(ecore_test_ecore_con_ssl_available)
{
int ret = ecore_con_ssl_available_get();
#ifdef HAVE_GNUTLS
fail_if(!ret);
#endif
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_init)
+EFL_START_TEST(ecore_test_ecore_con_init)
{
int ret;
ret = ecore_con_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_dns)
+EFL_START_TEST(ecore_test_ecore_con_dns)
{
Ecore_Con_Server *client;
Ecore_Event_Handler *e_err;
fail_if(ret != 0);
ret = eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_ecore_con_shutdown_bef_init)
+EFL_START_TEST(ecore_test_ecore_con_shutdown_bef_init)
{
int ret;
fail_if(ret != 0);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_lookup_done_cb(const char *canonname, const char *ip, struct sockaddr *addr, int addrlen, void *data)
ecore_main_loop_quit();
}
-START_TEST(ecore_test_ecore_con_dns_lookup)
+EFL_START_TEST(ecore_test_ecore_con_dns_lookup)
{
const char link[] = "www.google.com";
ecore_con_init();
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_con_test_ecore_con(TCase *tc)
{
ecore_con_server_del(cl);
}
-START_TEST(ecore_con_test_ecore_con_eet_svr_cl)
+EFL_START_TEST(ecore_con_test_ecore_con_eet_svr_cl)
{
Ecore_Con_Eet *ece_svr, *ece_cl;
Ecore_Con_Server *svr, *cl;
eet_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
_eet_svr_discnct_cb(void *data EINA_UNUSED, Ecore_Con_Reply *reply EINA_UNUSED, Ecore_Con_Server *conn EINA_UNUSED)
ecore_con_server_del(svr);
}
-START_TEST(ecore_con_test_ecore_con_eet_svr_del)
+EFL_START_TEST(ecore_con_test_ecore_con_eet_svr_del)
{
Ecore_Con_Eet *ece_svr, *ece_cl;
Ecore_Con_Server *svr, *cl;
eet_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_con_test_ecore_con_eet(TCase *tc)
{
#endif
#ifdef ECORE_CON_FTP_TEST_URL
-START_TEST(ecore_con_test_ecore_con_url_ftp_upload)
+EFL_START_TEST(ecore_con_test_ecore_con_url_ftp_upload)
{
Ecore_Con_Url *ec_url;
url_test *info = NULL;
fail_if(ret != 0);
ret = eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
#ifdef ECORE_CON_HTTP_TEST_URL
-START_TEST(ecore_con_test_ecore_con_url_post)
+EFL_START_TEST(ecore_con_test_ecore_con_url_post)
{
Ecore_Con_Url *ec_url;
url_test *info = NULL;
fail_if(ret != 0);
ret = eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(ecore_con_test_ecore_con_url_download)
+EFL_START_TEST(ecore_con_test_ecore_con_url_download)
{
Ecore_Con_Url *url;
url_test *info;
fail_if(ret != 0);
ret = eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_con_test_ecore_con_url_create)
+EFL_START_TEST(ecore_con_test_ecore_con_url_create)
{
Ecore_Con_Url *url;
int ret;
fail_if(ret != 0);
ret = eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_con_test_ecore_con_url_init)
+EFL_START_TEST(ecore_con_test_ecore_con_url_init)
{
int ret;
ret = ecore_con_url_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
_url_cookies_compl_cb(void *data EINA_UNUSED, int type EINA_UNUSED, void *event_info)
eina_shutdown();
}
-START_TEST(ecore_con_test_ecore_con_url_cookies_clear)
+EFL_START_TEST(ecore_con_test_ecore_con_url_cookies_clear)
{
Ecore_Con_Url *ec_url = _ecore_con_url_cookies_test_init();
Eina_Tmpstr *path;
_ecore_con_url_cookies_test_shutdown(ec_url, tmpfd, &path);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_con_test_ecore_con_url_cookies_clear_session)
+EFL_START_TEST(ecore_con_test_ecore_con_url_cookies_clear_session)
{
Ecore_Con_Url *ec_url = _ecore_con_url_cookies_test_init();
Eina_Tmpstr *path;
_ecore_con_url_cookies_test_shutdown(ec_url, tmpfd, &path);
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_con_test_ecore_con_url_cookies_ignore_session)
+EFL_START_TEST(ecore_con_test_ecore_con_url_cookies_ignore_session)
{
Ecore_Con_Url *ec_url = _ecore_con_url_cookies_test_init();
Eina_Tmpstr *path;
_ecore_con_url_cookies_test_shutdown(ec_url, tmpfd, &path);
}
-END_TEST
+EFL_END_TEST
void ecore_con_test_ecore_con_url(TCase *tc)
{
ck_assert_str_eq(efl_net_ip_address_string_get(o), buf);
}
-START_TEST(ecore_test_efl_net_ip_address_ipv4_manual_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_manual_ok)
{
struct sockaddr_in addr = {
.sin_family = AF_INET,
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_manual_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_manual_fail)
{
uint8_t c = 123;
Eina_Slice wrong_slice = { .mem = &c, .len = 1 };
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_create_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_create_ok)
{
struct sockaddr_in addr = {
.sin_family = AF_INET,
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_create_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_create_fail)
{
uint8_t c = 123;
Eina_Slice wrong_slice = { .mem = &c, .len = 1 };
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_create_sockaddr_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_create_sockaddr_ok)
{
struct sockaddr_in addr = {
.sin_family = AF_INET,
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_create_sockaddr_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_create_sockaddr_fail)
{
struct sockaddr_in addr = {
.sin_family = AF_UNSPEC,
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_parse_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_parse_ok)
{
Eo *o;
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_parse_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_parse_fail)
{
Eo *o;
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_resolve_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_resolve_ok)
{
struct resolve_ctx ctx = { };
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_resolve_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_resolve_fail)
{
struct resolve_ctx ctx = { };
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv4_checks)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv4_checks)
{
const struct test {
uint32_t addr;
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
/* IPv6 *****************************************************************/
memcpy(&addr->sin6_addr, s, 16);
}
-START_TEST(ecore_test_efl_net_ip_address_ipv6_manual_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_manual_ok)
{
struct sockaddr_in6 addr = {
.sin6_family = AF_INET6,
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv6_manual_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_manual_fail)
{
uint8_t c = 123;
Eina_Slice wrong_slice = { .mem = &c, .len = 1 };
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv6_create_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_create_ok)
{
struct sockaddr_in6 addr = {
.sin6_family = AF_INET6,
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv6_create_sockaddr_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_create_sockaddr_ok)
{
struct sockaddr_in6 addr = {
.sin6_family = AF_INET6,
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv6_parse_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_parse_ok)
{
Eo *o;
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv6_parse_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_parse_fail)
{
Eo *o;
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
static const char *
_ipv6_localhost_check(void)
return found;
}
-START_TEST(ecore_test_efl_net_ip_address_ipv6_resolve_ok)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_resolve_ok)
{
struct resolve_ctx ctx = { };
char buf[4096];
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv6_resolve_fail)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_resolve_fail)
{
struct resolve_ctx ctx = { };
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(ecore_test_efl_net_ip_address_ipv6_checks)
+EFL_START_TEST(ecore_test_efl_net_ip_address_ipv6_checks)
{
const struct test {
const char *str;
ecore_con_shutdown();
}
-END_TEST
+EFL_END_TEST
void ecore_con_test_efl_net_ip_address(TCase *tc)
{
#include <algorithm>
#include <check.h>
-
+#include "../efl_check.h"
void ecore_cxx_test_safe_call(TCase* tc);
#endif /* _ECORE_CXX_SUITE_H */
#define ECTOR_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void ector_test_init(TCase *tc);
#endif
#include "ector_suite.h"
-START_TEST(ector_init_simple)
+EFL_START_TEST(ector_init_simple)
{
fail_if(ector_init() != 1);
fail_if(ector_shutdown() != 0);
}
-END_TEST
+EFL_END_TEST
void
ector_test_init(TCase *tc)
#define _EDJE_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void edje_test_edje(TCase *tc);
#define EVAS_DATA_DIR TESTS_SRC_DIR "/../../lib/evas"
-START_TEST(edje_test_edje_init)
+EFL_START_TEST(edje_test_edje_init)
{
int ret;
ret = edje_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_edje_load)
+EFL_START_TEST(edje_test_edje_load)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
Edje_Load_Error error;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
static const char *
test_layout_get(const char *name)
return filename;
}
-START_TEST(edje_test_load_simple_layout)
+EFL_START_TEST(edje_test_load_simple_layout)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
Evas_Object *obj;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_simple_layout_geometry)
+EFL_START_TEST(edje_test_simple_layout_geometry)
{
int x, y, w, h;
int r, g, b, a;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_complex_layout)
+EFL_START_TEST(edje_test_complex_layout)
{
int x, y, w, h;
Evas *evas = EDJE_TEST_INIT_EVAS();
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_calculate_parens)
+EFL_START_TEST(edje_test_calculate_parens)
{
int x, y, w, h;
Evas *evas = EDJE_TEST_INIT_EVAS();
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_masking)
+EFL_START_TEST(edje_test_masking)
{
int x, y, w, h;
Evas *evas = EDJE_TEST_INIT_EVAS();
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_filters)
+EFL_START_TEST(edje_test_filters)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
const Evas_Object *text, *sub;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_snapshot)
+EFL_START_TEST(edje_test_snapshot)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
const Evas_Object *sub;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_size_class)
+EFL_START_TEST(edje_test_size_class)
{
int minw, minh, minw2, minh2;
Evas *evas = EDJE_TEST_INIT_EVAS();
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_color_class)
+EFL_START_TEST(edje_test_color_class)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_swallows)
+EFL_START_TEST(edje_test_swallows)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
Evas_Object *ly, *o1, *o2;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_swallows_eoapi)
+EFL_START_TEST(edje_test_swallows_eoapi)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
Evas_Object *ly, *o1, *o2;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_access)
+EFL_START_TEST(edje_test_access)
{
Evas *evas = EDJE_TEST_INIT_EVAS();
const char *name;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_box)
+EFL_START_TEST(edje_test_box)
{
Evas *evas;
Evas_Object *obj, *sobj, *sobjs[5];
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_box_eoapi)
+EFL_START_TEST(edje_test_box_eoapi)
{
Evas *evas;
Evas_Object *obj, *sobj, *sobjs[5];
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_table)
+EFL_START_TEST(edje_test_table)
{
Evas *evas;
Evas_Object *obj, *sobj, *sobjs[4];
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_table_eoapi)
+EFL_START_TEST(edje_test_table_eoapi)
{
Evas *evas;
Evas_Object *obj, *sobj, *sobjs[4], *proxy;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_combine_keywords)
+EFL_START_TEST(edje_test_combine_keywords)
{
Evas *evas;
Evas_Object *obj;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
static void
_message_signal_reply_cb(void *data, Evas_Object *obj EINA_UNUSED,
(*id)++;
}
-START_TEST(edje_test_message_send_legacy)
+EFL_START_TEST(edje_test_message_send_legacy)
{
Evas *evas;
Evas_Object *obj;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_message_send_eo)
+EFL_START_TEST(edje_test_message_send_eo)
{
Evas *evas;
Evas_Object *obj;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
-START_TEST(edje_test_signals)
+EFL_START_TEST(edje_test_signals)
{
Evas *evas;
Evas_Object *obj;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
static int _signal_count;
_signal_count += *_data;
}
-START_TEST(edje_test_signal_callback_del_full)
+EFL_START_TEST(edje_test_signal_callback_del_full)
{
Evas *evas;
Evas_Object *obj;
EDJE_TEST_FREE_EVAS();
}
-END_TEST
+EFL_END_TEST
void edje_test_edje(TCase *tc)
{
# define _EET_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void eet_test_init(TCase *tc);
void eet_test_data(TCase *tc);
void eet_test_file(TCase *tc);
return NULL;
}
-START_TEST(eet_test_cache_concurrency)
+EFL_START_TEST(eet_test_cache_concurrency)
{
char *file;
const char *buffer = "test data";
eina_threads_shutdown();
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
void eet_test_cache(TCase *tc)
{
#include "eet_suite.h"
#include "eet_test_common.h"
-START_TEST(eet_test_cipher_decipher_simple)
+EFL_START_TEST(eet_test_cipher_decipher_simple)
{
const char *buffer = "Here is a string of data to save !";
const char *key = "This is a crypto key";
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
void eet_test_cipher(TCase *tc)
{
return EINA_TRUE;
}
-START_TEST(eet_test_connection_check)
+EFL_START_TEST(eet_test_connection_check)
{
Eet_Data_Descriptor *edd;
Eet_Data_Descriptor_Class eddc;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
void eet_test_connection(TCase *tc)
{
fail_if(st3->boby != EET_TEST_INT + i);
} /* _eet_st3_cmp */
-START_TEST(eet_test_data_basic_type_encoding_decoding)
+EFL_START_TEST(eet_test_data_basic_type_encoding_decoding)
{
Eet_Data_Descriptor *edd;
Eet_Test_Basic_Type *result;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_data_type_encoding_decoding)
+EFL_START_TEST(eet_test_data_type_encoding_decoding)
{
Eet_Data_Descriptor *edd;
Eet_Test_Ex_Type *result;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_data_type_dump_undump)
+EFL_START_TEST(eet_test_data_type_dump_undump)
{
Eet_Data_Descriptor *edd;
Eet_Test_Ex_Type *result;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_data_type_escape_dump_undump)
+EFL_START_TEST(eet_test_data_type_escape_dump_undump)
{
void *blob;
int blob_len;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_data_fp)
+EFL_START_TEST(eet_test_data_fp)
{
Eet_Data_Descriptor_Class eddc;
Eet_Data_Descriptor *edd_5FP;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_data_union)
+EFL_START_TEST(eet_test_data_union)
{
Eet_Union_Test *eut;
Eet_List *l;
eet_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_data_variant)
+EFL_START_TEST(eet_test_data_variant)
{
Eet_Variant_Test *evt;
Eet_List *l;
eet_shutdown();
eina_shutdown();
-} /* START_TEST */
-END_TEST
+} /* EFL_START_TEST */
+EFL_END_TEST
-START_TEST(eet_test_data_hash_value)
+EFL_START_TEST(eet_test_data_hash_value)
{
Eet_Hash *h;
Eina_Value *val;
eet_shutdown();
eina_shutdown();
-} /* START_TEST */
-END_TEST
+} /* EFL_START_TEST */
+EFL_END_TEST
void eet_test_data(TCase *tc)
{
#include "eet_suite.h"
#include "eet_test_common.h"
-START_TEST(eet_test_file_simple_write)
+EFL_START_TEST(eet_test_file_simple_write)
{
const char *buffer = "Here is a string of data to save !";
Eina_Iterator *it;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_file_data)
+EFL_START_TEST(eet_test_file_data)
{
Eet_Data_Descriptor *edd;
Eet_Test_Ex_Type *result;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_file_data_dump)
+EFL_START_TEST(eet_test_file_data_dump)
{
Eet_Data_Descriptor *edd;
Eet_Test_Ex_Type *result;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_file_fp)
+EFL_START_TEST(eet_test_file_fp)
{
char *file;
Eet_Data_Descriptor_Class eddc;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
void eet_test_file(TCase *tc)
{
return strlen(pass);
}
-START_TEST(eet_test_identity_simple)
+EFL_START_TEST(eet_test_identity_simple)
{
const char *buffer = "Here is a string of data to save !";
const void *tmp;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_identity_open_simple)
+EFL_START_TEST(eet_test_identity_open_simple)
{
Eet_Key *k = NULL;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_identity_open_pkcs8)
+EFL_START_TEST(eet_test_identity_open_pkcs8)
{
Eet_Key *k = NULL;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_identity_open_pkcs8_enc)
+EFL_START_TEST(eet_test_identity_open_pkcs8_enc)
{
Eet_Key *k = NULL;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
static const char *_cert_dir_find(const char *_argv0)
{
}
};
-START_TEST(eet_test_image_normal)
+EFL_START_TEST(eet_test_image_normal)
{
Eet_File *ef;
char *file;
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eet_test_image_small)
+EFL_START_TEST(eet_test_image_small)
{
char *file;
unsigned int image[4];
eet_shutdown();
}
-END_TEST
+EFL_END_TEST
void eet_test_image(TCase *tc)
{
#include "eet_suite.h"
-START_TEST(_eet_test_init)
+EFL_START_TEST(_eet_test_init)
{
int ret;
ret = eet_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void eet_test_init(TCase *tc)
{
#include <algorithm>
#include <check.h>
-
+#include "../efl_check.h"
void eet_cxx_test_descriptors(TCase* tc);
#endif /* _EET_CXX_SUITE_H */
#define _EEZE_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void eeze_test_init(TCase *tc);
void eeze_test_udev(TCase *tc);
void eeze_test_net(TCase *tc);
#include "eeze_suite.h"
-START_TEST(eeze_test_eeze_init)
+EFL_START_TEST(eeze_test_eeze_init)
{
int ret;
ret = eeze_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void eeze_test_init(TCase *tc)
{
#include "eeze_suite.h"
-START_TEST(eeze_test_net_list)
+EFL_START_TEST(eeze_test_net_list)
{
int ret;
Eina_List *list = NULL;
ret = eeze_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eeze_test_net_attr)
+EFL_START_TEST(eeze_test_net_attr)
{
int ret;
int idx = 0;
ret = eeze_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
#ifdef HAVE_IPV6
-START_TEST(eeze_test_net_attr_ipv6)
+EFL_START_TEST(eeze_test_net_attr_ipv6)
{
int ret;
Eeze_Net *net = NULL;
ret = eeze_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
#endif
return ECORE_CALLBACK_DONE;
}
-START_TEST(eeze_test_sensor_read)
+EFL_START_TEST(eeze_test_sensor_read)
{
Eeze_Sensor_Obj *sens = NULL;
int ret = 0;
ret = eeze_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eeze_test_sensor_async_read)
+EFL_START_TEST(eeze_test_sensor_async_read)
{
Ecore_Event_Handler *handler;
ret = eeze_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eeze_test_sensor_obj_get)
+EFL_START_TEST(eeze_test_sensor_obj_get)
{
Eeze_Sensor_Obj *obj = NULL, *obj_tmp = NULL;
int ret = 0;
ret = eeze_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void eeze_test_sensor(TCase *tc)
{
#if 0
// FIXME split udev tests into pieces here
-START_TEST(eeze_test_udev_types)
+EFL_START_TEST(eeze_test_udev_types)
{
Eina_List *type;
eeze_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(eeze_test_udev_watch)
+EFL_START_TEST(eeze_test_udev_watch)
{
Eeze_Udev_Watch *watch;
eeze_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eeze_test_udev_syspath)
+EFL_START_TEST(eeze_test_udev_syspath)
{
Eina_List *type, *l;
const char *name;
eeze_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eeze_test_udev_attr)
+EFL_START_TEST(eeze_test_udev_attr)
{
Eina_List *type;
const char *name, *check, *check2;
eeze_shutdown();
}
-END_TEST
+EFL_END_TEST
/*
-START_TEST(eeze_test_udev_device)
+EFL_START_TEST(eeze_test_udev_device)
{
Eina_List *type, *l;
_udev_device *device, *device2;
eeze_shutdown();
}
-END_TEST
+EFL_END_TEST
*/
void eeze_test_udev(TCase *tc)
#define EFL_SUITE_H_
#include <check.h>
-
+#include "../efl_check.h"
void efl_test_case_model_container(TCase *tc);
void efl_test_case_model_composite_boolean(TCase *tc);
}
}
-START_TEST(efl_test_model_composite_boolean)
+EFL_START_TEST(efl_test_model_composite_boolean)
{
Efl_Model_Item *base_model, *child;
int i;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_test_model_composite_selection)
+EFL_START_TEST(efl_test_model_composite_selection)
{
Efl_Model_Item *base_model, *child;
int i;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void
efl_test_case_model_composite_boolean(TCase *tc)
}
-START_TEST(efl_test_model_container_values)
+EFL_START_TEST(efl_test_model_container_values)
{
Efl_Model_Container* model;
Efl_Future *future;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void
#ifndef EFL_CHECK_H
#define EFL_CHECK_H
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
#include <stdlib.h> /* getenv */
#include <stdio.h> /* fprintf, fputs */
#include <string.h> /* strcmp */
#include <unistd.h> /* execvp */
#include <errno.h> /* errno */
+#include <sys/time.h>
+
+#ifndef EINA_UNUSED
+
+#ifdef __GNUC__
+
+# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
+# define EINA_UNUSED __attribute__ ((__unused__))
+# else
+# define EINA_UNUSED
+# endif
+#else
+# define EINA_UNUSED
+#endif
+
+#endif
typedef struct _Efl_Test_Case Efl_Test_Case;
struct _Efl_Test_Case
fprintf(stderr, "\t%s\n", itr->test_case);
}
-static int
+EINA_UNUSED static int
_efl_test_option_disp(int argc, char **argv, const Efl_Test_Case *etc)
{
int i;
return 0;
}
+#ifdef HAVE_GETTIMEOFDAY
+EINA_UNUSED static double _timing_start_time;
+
static int
+_timing_enabled(void)
+{
+ const char *lc = getenv("TIMING_ENABLED");
+ return !!lc;
+}
+
+static double
+_timing_time_get(void)
+{
+ struct timeval timev;
+
+ gettimeofday(&timev, NULL);
+ return (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
+}
+
+EINA_UNUSED static void
+_timing_start(void)
+{
+ if (_timing_enabled())
+ _timing_start_time = _timing_time_get();
+}
+
+EINA_UNUSED static void
+_timing_end(void)
+{
+ double diff;
+
+ if (!_timing_enabled()) return;
+ diff = _timing_time_get() - _timing_start_time;
+
+ if (diff > 0.0001)
+ printf("TIME %s: %.5g\n", tcase_name(), diff);
+}
+
+# define EFL_START_TEST(TEST_NAME) \
+ START_TEST(TEST_NAME) \
+ _timing_start();
+
+# define EFL_END_TEST \
+ _timing_end(); \
+ END_TEST
+
+#else
+# define EFL_START_TEST(TEST_NAME) START_TEST(TEST_NAME)
+# define EFL_END_TEST END_TEST
+
+#endif
+
+EINA_UNUSED static int
_efl_suite_build_and_run(int argc, const char **argv, const char *suite_name, const Efl_Test_Case *etc)
{
Suite *s;
SRunner *sr;
TCase *tc;
int i, failed_count;
+#ifdef HAVE_GETTIMEOFDAY
+ double tstart;
+ int timing = _timing_enabled();
+ if (timing)
+ tstart = _timing_time_get();
+#endif
s = suite_create(suite_name);
sr = srunner_create(s);
srunner_run_all(sr, CK_ENV);
failed_count = srunner_ntests_failed(sr);
srunner_free(sr);
-
+#ifdef HAVE_GETTIMEOFDAY
+ if (timing)
+ printf("SUITE TIME %s: %.5g\n", suite_name, _timing_time_get() - tstart);
+#endif
return failed_count;
}
#define _EFREET_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void efreet_test_efreet(TCase *tc);
void efreet_test_efreet_cache(TCase *tc);
#include "efreet_suite.h"
-START_TEST(efreet_test_efreet_init)
+EFL_START_TEST(efreet_test_efreet_init)
{
int ret;
ret = efreet_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void efreet_test_efreet(TCase *tc)
{
#include "efreet_suite.h"
-START_TEST(efreet_test_efreet_cache_init)
+EFL_START_TEST(efreet_test_efreet_cache_init)
{
int ret;
ret = efreet_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void efreet_test_efreet_cache(TCase *tc)
{
#define EINA_SUITE_H_
#include <check.h>
+#include "../efl_check.h"
void eina_test_ustringshare(TCase *tc);
void eina_test_binshare(TCase *tc);
EAPI Eina_Unicode eina_unicode_utf8_get_next(const char *buf, int *iindex);
EAPI unsigned int eina_mempool_alignof(unsigned int size);
-START_TEST(eina_unicode_utf8)
+EFL_START_TEST(eina_unicode_utf8)
{
int ind;
unsigned char ch;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_alignof)
+EFL_START_TEST(eina_alignof)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_abi(TCase *tc)
return EINA_TRUE;
}
-START_TEST(eina_accessor_array_simple)
+EFL_START_TEST(eina_accessor_array_simple)
{
Eina_Accessor *it;
Eina_Array *ea;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
typedef struct _Eina_Test_Inlist Eina_Test_Inlist;
struct _Eina_Test_Inlist
return EINA_TRUE;
}
-START_TEST(eina_accessor_inlist_simple)
+EFL_START_TEST(eina_accessor_inlist_simple)
{
Eina_Inlist *lst = NULL;
Eina_Test_Inlist *tmp;
fail_if(i != 2);
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
eina_iterator_list_data_check(EINA_UNUSED const Eina_List *list,
return EINA_TRUE;
}
-START_TEST(eina_accessor_list_simple)
+EFL_START_TEST(eina_accessor_list_simple)
{
Eina_List *list = NULL;
Eina_Accessor *it;
eina_accessor_free(it);
}
-END_TEST
+EFL_END_TEST
void
eina_test_accessor(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_array_simple)
+EFL_START_TEST(eina_array_simple)
{
Eina_Array *ea;
char *tmp;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_array_static)
+EFL_START_TEST(eina_array_static)
{
Eina_Array sea;
char *tmp;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
Eina_Bool
keep_int(void *data, void *gdata)
return EINA_TRUE;
}
-START_TEST(eina_array_remove_stuff)
+EFL_START_TEST(eina_array_remove_stuff)
{
Eina_Array *ea;
int *tmp;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_array(TCase *tc)
return NULL;
}
-START_TEST(eina_barrier_test_simple)
+EFL_START_TEST(eina_barrier_test_simple)
{
Eina_Bool r;
int i;
eina_threads_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_barrier(TCase *tc)
global_test = a;
}
-START_TEST(eina_benchmark_simple)
+EFL_START_TEST(eina_benchmark_simple)
{
Eina_Benchmark *eb;
Eina_Array_Iterator it;
eina_benchmark_free(eb);
}
-END_TEST
+EFL_END_TEST
void
eina_test_benchmark(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_bezier_test_values)
+EFL_START_TEST(eina_bezier_test_values)
{
Eina_Bezier b;
double sx, sy, cx1, cy1, cx2, cy2, ex, ey;
ey != 8);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_bezier_test_angle)
+EFL_START_TEST(eina_bezier_test_angle)
{
Eina_Bezier b;
double angle;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_bezier_test_length)
+EFL_START_TEST(eina_bezier_test_length)
{
Eina_Bezier b;
double length;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_bezier_test_t_at)
+EFL_START_TEST(eina_bezier_test_t_at)
{
Eina_Bezier b;
double length, t;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_bezier_test_point_at)
+EFL_START_TEST(eina_bezier_test_point_at)
{
Eina_Bezier b;
double x, y;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_bezier_test_split_at_length)
+EFL_START_TEST(eina_bezier_test_split_at_length)
{
Eina_Bezier b, l , r;
double len, len1, len2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_bezier_test_bounds_get)
+EFL_START_TEST(eina_bezier_test_bounds_get)
{
Eina_Bezier b;
double x, y, w, h;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_bezier_test_on_interval)
+EFL_START_TEST(eina_bezier_test_on_interval)
{
Eina_Bezier b, res;
double px1, px2, py1, py2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_bezier(TCase *tc)
#include "eina_suite.h"
-START_TEST(binbuf_simple)
+EFL_START_TEST(binbuf_simple)
{
Eina_Binbuf *buf, *test_buf;
unsigned char *txt;
eina_shutdown();
#undef TEXT
}
-END_TEST
+EFL_END_TEST
-START_TEST(binbuf_remove)
+EFL_START_TEST(binbuf_remove)
{
Eina_Binbuf *buf;
const unsigned char cbuf[] = "12\0 456 78\0 abcthis is some more random junk here!";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
/* eina_binbuf_manage_new_length and eina_binbuf_manage_read_only_new_length
* are deprecated */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-START_TEST(binbuf_manage_simple)
+EFL_START_TEST(binbuf_manage_simple)
{
Eina_Binbuf *buf;
const char *_cbuf = "12\0 456 78\0 abcthis is some more random junk here!";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(binbuf_manage_read_only_simple)
+EFL_START_TEST(binbuf_manage_read_only_simple)
{
Eina_Binbuf *buf;
const char *_cbuf = "12\0 456 78\0 abcthis is some more random junk here!";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#pragma GCC diagnostic pop
-START_TEST(binbuf_insert)
+EFL_START_TEST(binbuf_insert)
{
#if 0
Eina_Binbuf *buf;
eina_shutdown();
#endif
}
-END_TEST
+EFL_END_TEST
-START_TEST(binbuf_realloc)
+EFL_START_TEST(binbuf_realloc)
{
Eina_Binbuf *buf;
unsigned char pattern[1024 * 16];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(binbuf_expand)
+EFL_START_TEST(binbuf_expand)
{
Eina_Binbuf *buf;
Eina_Rw_Slice rw_slice;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
#define TEST1 "te\0st/11"
#define TEST1_SIZE 8
-START_TEST(eina_binshare_simple)
+EFL_START_TEST(eina_binshare_simple)
{
const char *t0;
const char *t1;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_binshare_small)
+EFL_START_TEST(eina_binshare_small)
{
char buf[4];
int i;
}
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_binshare_test_share)
+EFL_START_TEST(eina_binshare_test_share)
{
const char *t0;
const char *t1;
eina_binshare_del(t1);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_binshare_putstuff)
+EFL_START_TEST(eina_binshare_putstuff)
{
const char *tmp;
int i;
}
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_binshare_collision)
+EFL_START_TEST(eina_binshare_collision)
{
Eina_Array *ea;
char buffer[50];
eina_array_free(ea);
}
-END_TEST
+EFL_END_TEST
void
eina_test_binshare(TCase *tc)
};
}
-START_TEST(eina_clist_basic)
+EFL_START_TEST(eina_clist_basic)
{
unsigned int n = 0;
fail_if(eina_clist_count(&string_list) != 0);
}
-END_TEST
+EFL_END_TEST
void
eina_test_clist(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_convert_simple)
+EFL_START_TEST(eina_convert_simple)
{
char tmp[128];
char ref[128];
fail_if(eina_convert_xtoa(0xFF00EF0E, tmp) != 8);
fail_if(strcmp(tmp, "ff00ef0e") != 0);
}
-END_TEST
+EFL_END_TEST
#define EET_TEST_DOUBLE0 123.45689
#define EET_TEST_DOUBLE1 1.0
fail_if(fabs(r - test) > DBL_MIN);
}
- START_TEST(eina_convert_double)
+ EFL_START_TEST(eina_convert_double)
{
long long int m = 0;
long e = 0;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_eina_convert_fp_check(double d, Eina_F32p32 fp, int length)
fail_if(fabs(fpd - d) > DBL_MIN);
}
- START_TEST(eina_convert_fp)
+ EFL_START_TEST(eina_convert_fp)
{
_eina_convert_fp_check(1.0, 0x0000000100000000, 6);
_eina_convert_fp_check(0.5, 0x0000000080000000, 8);
_eina_convert_fp_check(0.5, 0x0000000080000000, 8);
_eina_convert_fp_check(128.625, 0x00000080a0000000, 10);
}
-END_TEST
+EFL_END_TEST
void
eina_test_convert(TCase *tc)
}
#endif
-START_TEST(eina_counter_simple)
+EFL_START_TEST(eina_counter_simple)
{
Eina_Counter *cnt;
char *dump;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_counter_break)
+EFL_START_TEST(eina_counter_break)
{
Eina_Counter *cnt;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void eina_test_counter(TCase *tc)
{
*bol = EINA_TRUE;
}
-START_TEST(eina_cow_bad)
+EFL_START_TEST(eina_cow_bad)
{
const Eina_Cow_Test *cur;
Eina_Cow_Test *write;
eina_cow_del(cow);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_cow)
+EFL_START_TEST(eina_cow)
{
const Eina_Cow_Test *prev;
const Eina_Cow_Test *cur;
eina_cow_del(cow);
}
-END_TEST
+EFL_END_TEST
void
eina_test_cow(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_crc_simple)
+EFL_START_TEST(eina_crc_simple)
{
unsigned int seed = 0xffffffff, i, ret;
const char *data[] =
ret = eina_crc(s2, strlen(s2), ret, EINA_FALSE);
fail_if(ret != result[0]);
}
-END_TEST
+EFL_END_TEST
void eina_test_crc(TCase *tc)
{
#endif
}
-START_TEST(eina_error_errno)
+EFL_START_TEST(eina_error_errno)
{
int test;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_error_test_find)
+EFL_START_TEST(eina_error_test_find)
{
int test, r;
const char *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_error_test_modify)
+EFL_START_TEST(eina_error_test_modify)
{
int test, r;
const char *str, smsg[] = "Do not copy this string";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_error_test_lots)
+EFL_START_TEST(eina_error_test_lots)
{
char buf[64];
int codes[512];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#ifdef EINA_SAFETY_CHECKS
-START_TEST(eina_error_test_failures)
+EFL_START_TEST(eina_error_test_failures)
{
struct log_ctx ctx;
Eina_Error local_error;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void
#endif
-START_TEST(eina_file_split_simple)
+EFL_START_TEST(eina_file_split_simple)
{
Eina_Array *ea;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
Eina_Tmpstr*
get_full_path(const char* tmpdirname, const char* filename)
return tmp_dir;
}
-START_TEST(eina_file_direct_ls_simple)
+EFL_START_TEST(eina_file_direct_ls_simple)
{
eina_init();
eina_tmpstr_del(test_dirname);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_file_ls_simple)
+EFL_START_TEST(eina_file_ls_simple)
{
eina_init();
eina_tmpstr_del(test_dirname);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_file_map_new_test)
+EFL_START_TEST(eina_file_map_new_test)
{
const char *eina_map_test_string = "Hello. I'm the eina map test string.";
const char *test_file_name_part = "/example.txt";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static const char *virtual_file_data = "this\n"
"is a test for the sake of testing\r\n"
"file !\n"
"without any issue !";
-START_TEST(eina_test_file_virtualize)
+EFL_START_TEST(eina_test_file_virtualize)
{
Eina_File *f;
Eina_File *tmp;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static void *
_eina_test_file_thread(void *data EINA_UNUSED, Eina_Thread t EINA_UNUSED)
return NULL;
}
-START_TEST(eina_test_file_thread)
+EFL_START_TEST(eina_test_file_thread)
{
Eina_Thread th[4];
unsigned int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static const struct {
const char *test;
{ "/home/mydir/../myfile", "/home/myfile" }
};
-START_TEST(eina_test_file_path)
+EFL_START_TEST(eina_test_file_path)
{
unsigned int i;
char *path;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#ifdef XATTR_TEST_DIR
-START_TEST(eina_test_file_xattr)
+EFL_START_TEST(eina_test_file_xattr)
{
Eina_File *ef;
char *filename = "tmpfile";
eina_file_close(ef);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(eina_test_file_copy)
+EFL_START_TEST(eina_test_file_copy)
{
const char *test_file1_name = "EinaCopyFromXXXXXX.txt";
const char *test_file2_name = "EinaCopyToXXXXXX.txt";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_file_statat)
+EFL_START_TEST(eina_test_file_statat)
{
Eina_Tmpstr *test_file1_path, *test_file2_path;
Eina_Iterator *it;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_file_mktemp)
+EFL_START_TEST(eina_test_file_mktemp)
{
Eina_Tmpstr *tmpfile, *tmpdir = NULL;
char buf[PATH_MAX], fmt[256];
unlink(tmpfile);
remove(tmpdir);
}
-END_TEST
+EFL_END_TEST
int create_file_not_empty(const char *file_name, Eina_Tmpstr **test_file_path, Eina_Bool close_file)
{
return fd;
}
-START_TEST(eina_test_file_unlink)
+EFL_START_TEST(eina_test_file_unlink)
{
int fd;
Eina_Tmpstr *test_file_path;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_file(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_fp_cos)
+EFL_START_TEST(eina_fp_cos)
{
Eina_F32p32 fc;
Eina_F32p32 fl;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_fp_sin)
+EFL_START_TEST(eina_fp_sin)
{
Eina_F32p32 fc;
Eina_F32p32 fl;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_fp_mul)
+EFL_START_TEST(eina_fp_mul)
{
Eina_F32p32 fc1, fc2;
Eina_F32p32 fresult;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_fp_div)
+EFL_START_TEST(eina_fp_div)
{
Eina_F32p32 fc1, fc2;
Eina_F32p32 fresult;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_fp(TCase *tc)
#include "eina_suite.h"
-START_TEST(freeq_simple)
+EFL_START_TEST(freeq_simple)
{
Eina_FreeQ *fq;
int *p;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static int _n = 0;
_n--;
}
-START_TEST(freeq_tune)
+EFL_START_TEST(freeq_tune)
{
void *p;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(freeq_reduce)
+EFL_START_TEST(freeq_reduce)
{
void *p;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
postponed_free(void *data)
return p;
}
-START_TEST(freeq_postponed)
+EFL_START_TEST(freeq_postponed)
{
Eina_FreeQ *fq;
unsigned int *values[20];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_freeq(TCase *tc)
return EINA_TRUE;
}
-START_TEST(eina_hash_simple)
+EFL_START_TEST(eina_hash_simple)
{
Eina_Hash *hash = NULL;
int *test;
/* Same comment as eina_init */
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_hash_crc)
+EFL_START_TEST(eina_test_hash_crc)
{
Eina_Hash *hash = NULL;
int *test;
/* Same comment as eina_init */
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hash_extended)
+EFL_START_TEST(eina_hash_extended)
{
Eina_Hash *hash = NULL;
int i;
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hash_double_item)
+EFL_START_TEST(eina_hash_double_item)
{
Eina_Hash *hash = NULL;
int i[] = { 7, 7 };
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hash_all_int)
+EFL_START_TEST(eina_hash_all_int)
{
Eina_Hash *hash;
int64_t j[] = { 4321312301243122, 6, 7, 128 };
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hash_int32_fuzze)
+EFL_START_TEST(eina_hash_int32_fuzze)
{
Eina_Hash *hash;
Eina_List *added = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hash_string_fuzze)
+EFL_START_TEST(eina_hash_string_fuzze)
{
Eina_Hash *hash;
Eina_List *added = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hash_seed)
+EFL_START_TEST(eina_hash_seed)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hash_add_del_by_hash)
+EFL_START_TEST(eina_hash_add_del_by_hash)
{
Eina_Hash *hash = NULL;
int array[] = { 1, 42, 4, 5, 6 };
fail_if(eina_hash_population(hash) != 3);
}
-END_TEST
+EFL_END_TEST
void eina_test_hash(TCase *tc)
{
#include "eina_suite.h"
-START_TEST(eina_inarray_test_simple)
+EFL_START_TEST(eina_inarray_test_simple)
{
const int test_members = 5;
Eina_Inarray *array;
eina_inarray_free(array);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_inarray_test_alloc_at)
+EFL_START_TEST(eina_inarray_test_alloc_at)
{
Eina_Inarray *array;
int *member;
eina_inarray_free(array);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static const short rand_numbers[] = {
9, 0, 2, 3, 6, 5, 4, 7, 8, 1, 10
return *a - *b;
}
-START_TEST(eina_inarray_test_insert_sort)
+EFL_START_TEST(eina_inarray_test_insert_sort)
{
Eina_Inarray *array;
int i, pos;
eina_inarray_free(array);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_inarray_test_sort)
+EFL_START_TEST(eina_inarray_test_sort)
{
Eina_Inarray *array;
int i;
eina_inarray_free(array);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_inarray_test_reverse)
+EFL_START_TEST(eina_inarray_test_reverse)
{
Eina_Inarray *array;
int i;
eina_inarray_free(array);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
array_foreach(const void *array EINA_UNUSED, void *p, void *user_data EINA_UNUSED)
return EINA_TRUE;
}
-START_TEST(eina_inarray_test_itr)
+EFL_START_TEST(eina_inarray_test_itr)
{
Eina_Inarray *array;
Eina_Iterator *it;
eina_inarray_free(array);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
int
cmp(const void *a, const void *b)
return EINA_FALSE;
}
-START_TEST(eina_inarray_test_search)
+EFL_START_TEST(eina_inarray_test_search)
{
Eina_Inarray *iarr;
int i, ret, temp=92, ret1;
eina_inarray_free(iarr);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_inarray(TCase *tc)
return tmp;
}
-START_TEST(eina_inlist_simple)
+EFL_START_TEST(eina_inlist_simple)
{
Eina_Inlist *lst = NULL;
Eina_Inlist *tmpl = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
typedef struct _Eina_Test_Inlist_Sorted Eina_Test_Inlist_Sorted;
struct _Eina_Test_Inlist_Sorted
}
}
-START_TEST(eina_inlist_sorted)
+EFL_START_TEST(eina_inlist_sorted)
{
Eina_Test_Inlist_Sorted *tmp;
Eina_Inlist *list = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_inlist_sorted_state)
+EFL_START_TEST(eina_inlist_sorted_state)
{
Eina_Test_Inlist_Sorted *tmp;
Eina_Inlist_Sorted_State *state;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_inlist(TCase *tc)
return numb->number % 2;
}
-START_TEST(eina_iterator_filter_simple)
+EFL_START_TEST(eina_iterator_filter_simple)
{
Eina_Iterator *it, *filtered;
Eina_Array *ea;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
struct Free_test {
Eina_Bool got_freed;
test->got_freed = EINA_TRUE;
}
-START_TEST(eina_iterator_filter_free)
+EFL_START_TEST(eina_iterator_filter_free)
{
Eina_Iterator *it, *filtered;
Eina_Array *ea;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
eina_iterator_array_check(EINA_UNUSED const Eina_Array *array,
int *data, int *fdata)
return EINA_TRUE;
}
-START_TEST(eina_iterator_array_simple)
+EFL_START_TEST(eina_iterator_array_simple)
{
Eina_Iterator *it;
Eina_Array *ea;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
eina_iterator_hash_key_check(const Eina_Hash *hash,
return EINA_TRUE;
}
-START_TEST(eina_iterator_hash_simple)
+EFL_START_TEST(eina_iterator_hash_simple)
{
Eina_Iterator *it;
Eina_Hash *hash;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
typedef struct _Eina_Test_Inlist Eina_Test_Inlist;
struct _Eina_Test_Inlist
return EINA_TRUE;
}
-START_TEST(eina_iterator_inlist_simple)
+EFL_START_TEST(eina_iterator_inlist_simple)
{
Eina_Inlist *lst = NULL;
Eina_Test_Inlist *tmp;
fail_if(i != 5);
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
eina_iterator_list_data_check(EINA_UNUSED const Eina_List *list,
return EINA_TRUE;
}
-START_TEST(eina_iterator_list_simple)
+EFL_START_TEST(eina_iterator_list_simple)
{
Eina_List *list = NULL;
Eina_Iterator *it;
eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_list_data_check), &i);
eina_iterator_free(it);
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
eina_reverse_iterator_list_data_check(EINA_UNUSED const Eina_List *list,
return EINA_TRUE;
}
-START_TEST(eina_reverse_iterator_list_simple)
+EFL_START_TEST(eina_reverse_iterator_list_simple)
{
Eina_List *list = NULL;
Eina_Iterator *it;
eina_iterator_foreach(it, EINA_EACH_CB(eina_reverse_iterator_list_data_check), &i);
eina_iterator_free(it);
}
-END_TEST
+EFL_END_TEST
typedef struct _Eina_Rbtree_Int Eina_Rbtree_Int;
struct _Eina_Rbtree_Int
return EINA_TRUE;
}
-START_TEST(eina_iterator_rbtree_simple)
+EFL_START_TEST(eina_iterator_rbtree_simple)
{
Eina_Rbtree *root = NULL;
Eina_Iterator *it;
&i);
eina_iterator_free(it);
}
-END_TEST
+EFL_END_TEST
void
eina_test_iterator(TCase *tc)
elat->num = 0;
}
-START_TEST(eina_lalloc_simple)
+EFL_START_TEST(eina_lalloc_simple)
{
Eina_Lazy_Allocator_Test *elat;
Eina_Lalloc *test;
eina_lalloc_free(test);
}
-END_TEST
+EFL_END_TEST
void
eina_test_lalloc(TCase *tc)
return *ia - *ib;
}
-START_TEST(eina_test_simple)
+EFL_START_TEST(eina_test_simple)
{
Eina_List *list = NULL;
Eina_List *tmp;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_merge)
+EFL_START_TEST(eina_test_merge)
{
Eina_List *l1;
Eina_List *l2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_sorted_insert)
+EFL_START_TEST(eina_test_sorted_insert)
{
const int data[] = {6, 9, 42, 1, 7, 9, 81, 1664, 1337, 3, 21, 10, 0, 5, 2008};
const int data2[] = {5, 0, 3, 2, 1, 0, 1, 2, 3, 4, 5};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_list_split)
+EFL_START_TEST(eina_test_list_split)
{
Eina_List *left = NULL, *right = NULL ;
Eina_List *list = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static int uicmp(const void *d1, const void *d2)
{
#define SHUFFLE_SZ 100
#define SHUFFLE_N 100000
-START_TEST(eina_test_shuffle)
+EFL_START_TEST(eina_test_shuffle)
{
double d;
unsigned int *p;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#define DATA_SIZE 100
-START_TEST(eina_test_clone)
+EFL_START_TEST(eina_test_clone)
{
unsigned int i;
unsigned int *d, *rd;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_move)
+EFL_START_TEST(eina_test_move)
{
Eina_List *list1 = NULL, *list2 = NULL;
Eina_Bool ret;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_list(TCase *tc)
return data;
}
-START_TEST(eina_test_spinlock)
+EFL_START_TEST(eina_test_spinlock)
{
unsigned int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_TLS key;
static int _eina_tls_free_count = 0;
return NULL;
}
-START_TEST(eina_test_tls)
+EFL_START_TEST(eina_test_tls)
{
fail_if(!eina_init());
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Barrier barrier;
static Eina_Lock mtcond;
return NULL;
}
-START_TEST(eina_test_rwlock)
+EFL_START_TEST(eina_test_rwlock)
{
struct timespec ts, ts2;
long delay;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_locking(TCase *tc)
#endif
}
-START_TEST(eina_log_macro)
+EFL_START_TEST(eina_log_macro)
{
struct log_ctx ctx;
int oldlevel;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_log_domains_macros)
+EFL_START_TEST(eina_log_domains_macros)
{
struct log_ctx ctx;
int oldlevel;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_log_domains_registry)
+EFL_START_TEST(eina_log_domains_registry)
{
fail_if(!eina_init());
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_log_domains_slot_reuse)
+EFL_START_TEST(eina_log_domains_slot_reuse)
{
fail_if(!eina_init());
fail_if(!eina_threads_init());
eina_threads_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_log_level_indexes)
+EFL_START_TEST(eina_log_level_indexes)
{
struct log_ctx ctx;
int maxlevel;
eina_threads_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_log_customize)
+EFL_START_TEST(eina_log_customize)
{
struct log_ctx ctx;
int d;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_log_level_name)
+EFL_START_TEST(eina_log_level_name)
{
char name[4];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_log(TCase *tc)
ctx.expected_level = EINA_LOG_LEVEL_ERR
#endif
-START_TEST(eina_magic_simple)
+EFL_START_TEST(eina_magic_simple)
{
Eina_Magic_Struct *ems = NULL;
struct log_ctx ctx;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void eina_test_magic(TCase *tc)
{
#include "eina_suite.h"
- START_TEST(eina_simple)
+ EFL_START_TEST(eina_simple)
{
fail_if(eina_init() != 2); /* one init by test suite */
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_cpu)
+EFL_START_TEST(eina_cpu)
{
fail_if(eina_init() != 2); /* one init by test suite */
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_hamster)
+EFL_START_TEST(eina_hamster)
{
fail_if(eina_init() != 2); /* one init by test suite */
fail_if(eina_shutdown() != 1);
}
-END_TEST
+EFL_END_TEST
void eina_test_main(TCase *tc)
{
#include "eina_suite.h"
-START_TEST(eina_matrix2)
+EFL_START_TEST(eina_matrix2)
{
Eina_Matrix2 m;
Eina_Matrix2 n;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_matrix2_operation)
+EFL_START_TEST(eina_matrix2_operation)
{
Eina_Matrix2 m1, m2, m3;
double xx, xy, yx, yy;
!EINA_DBL_EQ(xy, 5));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_matrix4)
+EFL_START_TEST(eina_matrix4)
{
Eina_Matrix4 m;
Eina_Matrix4 n;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_matrix4_operation)
+EFL_START_TEST(eina_matrix4_operation)
{
double det;
double l=5, r=4, b=4, t=3, dn=3, df=2;
!EINA_DBL_EQ(wz, 5) ||
!EINA_DBL_EQ(ww, 1));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_matrix4_2_3)
+EFL_START_TEST(eina_matrix4_2_3)
{
Eina_Matrix4 m4;
Eina_Matrix3 m3, m3b;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_matrix3)
+EFL_START_TEST(eina_matrix3)
{
Eina_Bool ret;
Eina_Matrix3 m, m1, m2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#define MATRIX3_CMP(XX, XY, XZ, YX, YY, YZ, ZX, ZY, ZZ, AXX, AXY, AXZ, AYX, AYY, AYZ, AZX, AZY, AZZ) \
(EINA_DBL_EQ(XX, AXX) && \
EINA_DBL_EQ(ZY, AZY) && \
EINA_DBL_EQ(ZZ, AZZ))
-START_TEST(eina_matrix3_operations)
+EFL_START_TEST(eina_matrix3_operations)
{
Eina_Matrix3 m1, m2, m3;
double xx, xy, xz,
fail_if (!EINA_DBL_EQ(xx, 6) ||
!EINA_DBL_EQ(yy, 7));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_matrix3_f16p16)
+EFL_START_TEST(eina_matrix3_f16p16)
{
Eina_Matrix3_F16p16 m1;
Eina_Matrix3 m2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_matrix3_map_transform)
+EFL_START_TEST(eina_matrix3_map_transform)
{
double x = 2, y = 3, x1, y1;
Eina_Matrix3 m;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_normal3_test)
+EFL_START_TEST(eina_normal3_test)
{
Eina_Matrix3 out;
Eina_Matrix4 m;
);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_matrix(TCase *tc)
}
}
-START_TEST(eina_test_simple)
+EFL_START_TEST(eina_test_simple)
{
Eina_Matrixsparse *matrix = NULL;
Eina_Matrixsparse_Cell *cell = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_resize)
+EFL_START_TEST(eina_test_resize)
{
Eina_Matrixsparse *matrix = NULL;
Eina_Bool r;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_iterators)
+EFL_START_TEST(eina_test_iterators)
{
Eina_Matrixsparse *matrix = NULL;
Eina_Matrixsparse_Cell *cell = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_matrixsparse(TCase *tc)
}
#ifdef EINA_BUILD_CHAINED_POOL
-START_TEST(eina_mempool_chained_mempool)
+EFL_START_TEST(eina_mempool_chained_mempool)
{
Eina_Mempool *mp;
_mempool_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
#ifdef EINA_BUILD_PASS_THROUGH
-START_TEST(eina_mempool_pass_through)
+EFL_START_TEST(eina_mempool_pass_through)
{
Eina_Mempool *mp;
_mempool_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void
}
-START_TEST(eina_module_load_unload)
+EFL_START_TEST(eina_module_load_unload)
{
Eina_Array *_modules;
unsigned int i;
eina_array_free(_modules);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_module_find_test)
+EFL_START_TEST(eina_module_find_test)
{
Eina_Array *_modules;
fail_if(eina_module_find(_modules, NULL) != NULL);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_module(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_quad_simple)
+EFL_START_TEST(eina_quad_simple)
{
Eina_Rectangle r1;
Eina_Quad r2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_quad(TCase *tc)
return EINA_QUAD_BOTH;
}
-START_TEST(eina_quadtree_collision)
+EFL_START_TEST(eina_quadtree_collision)
{
struct
{
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_quadtree(TCase *tc)
return EINA_FALSE;
}
-START_TEST(eina_test_quaternion_norm)
+EFL_START_TEST(eina_test_quaternion_norm)
{
static const Eina_Quaternion q = { 1, 3, 4, 5 };
double result = eina_quaternion_norm(&q);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_conjugate)
+EFL_START_TEST(eina_test_quaternion_conjugate)
{
static const Eina_Quaternion q1 = { 1, -1, -1, 3 }, q2 = { 1, 3, 4, 3 };
static const Eina_Quaternion r1 = { -1, 1, 1, 3 }, r2 = { -1, -3, -4, 3 };
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_matrix)
+EFL_START_TEST(eina_test_quaternion_matrix)
{
Eina_Quaternion q = { 7, 9, 5, 1 };
Eina_Quaternion q1 = {7, 9, 5, -1 };
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_op)
+EFL_START_TEST(eina_test_quaternion_op)
{
Eina_Quaternion q = { 7, 9, 5, 1 };
Eina_Quaternion z = { 0, 0, 0, 0 };
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_f16p16)
+EFL_START_TEST(eina_test_quaternion_f16p16)
{
Eina_F16p16 x = 65536, y = 65536;
Eina_F16p16 z = 65536, w = 65536;
t.z != 131072 ||
t.w != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_dot)
+EFL_START_TEST(eina_test_quaternion_dot)
{
Eina_Quaternion q = {1, 3, 4, 5};
Eina_Quaternion r = {7, 9, 5, 1};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_scale)
+EFL_START_TEST(eina_test_quaternion_scale)
{
Eina_Quaternion q = {1, 3, 4, 5};
double scale = 2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_set)
+EFL_START_TEST(eina_test_quaternion_set)
{
Eina_Quaternion q, r = {1, 3, 4, 5};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_mul)
+EFL_START_TEST(eina_test_quaternion_mul)
{
Eina_Quaternion p = {1, 3, 4, 5};
Eina_Quaternion q = {7, 9, 5, 1};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_matrix_recompose)
+EFL_START_TEST(eina_test_matrix_recompose)
{
const Eina_Point_3D translation = { 0, 0, 0 };
const Eina_Point_3D scale = { 1, 1, 1 };
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_normalized)
+EFL_START_TEST(eina_test_quaternion_normalized)
{
Eina_Quaternion p = {1, 1, 1, 1};
Eina_Quaternion res, q = {0.5, 0.5, 0.5, 0.5};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#if 0
-START_TEST(eina_test_matrix_quaternion)
+EFL_START_TEST(eina_test_matrix_quaternion)
{
const Eina_Point_3D rt = { -2, -3, 0 };
const Eina_Point_3D rsc = { 4, 5, 1 };
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(eina_test_quaternion_f16p16_lerp)
+EFL_START_TEST(eina_test_quaternion_f16p16_lerp)
{
Eina_Quaternion_F16p16 r, p = {0, 0, 0, 0};
Eina_Quaternion_F16p16 q = {65536, 65536, 65536, 0};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_lerp)
+EFL_START_TEST(eina_test_quaternion_lerp)
{
Eina_Quaternion rp = {0, 0, 1, 0};
Eina_Quaternion rq = {1, 0, 0, 0};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_f16p16_rotate_matrix)
+EFL_START_TEST(eina_test_quaternion_f16p16_rotate_matrix)
{
Eina_Quaternion_F16p16 q = {65536, 65536, 65536, 0};
Eina_Point_3D_F16p16 r = { 65536, 65536, 65536 };
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_rotate)
+EFL_START_TEST(eina_test_quaternion_rotate)
{
Eina_Point_3D r = { 3, 3, 3 };
Eina_Point_3D c = { 0, 0, 0}, res = {3.0, 3.0, 3.0};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_quaternion_operations)
+EFL_START_TEST(eina_test_quaternion_operations)
{
Eina_Quaternion in = {2, 2, 1, 1};
Eina_Quaternion in2 = {5, 5, 5, 5};
);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_quaternion(TCase *tc)
return it;
}
-START_TEST(eina_rbtree_insertion)
+EFL_START_TEST(eina_rbtree_insertion)
{
Eina_Rbtree_Int *root = NULL;
Eina_Rbtree_Int *item;
EINA_RBTREE_CMP_NODE_CB(
eina_rbtree_int_cmp));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rbtree_lookup)
+EFL_START_TEST(eina_rbtree_lookup)
{
Eina_Rbtree_Int *root = NULL;
Eina_Rbtree_Int *item;
NULL);
fail_if(item);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rbtree_remove)
+EFL_START_TEST(eina_rbtree_remove)
{
Eina_Rbtree_Int *root = NULL;
Eina_Rbtree_Int *item;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rbtree_simple_remove)
+EFL_START_TEST(eina_rbtree_simple_remove)
{
Eina_Rbtree *root = NULL;
Eina_Rbtree *lookup;
_eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rbtree_simple_remove2)
+EFL_START_TEST(eina_rbtree_simple_remove2)
{
Eina_Rbtree *root = NULL;
Eina_Rbtree *lookup;
_eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rbtree_simple_remove3)
+EFL_START_TEST(eina_rbtree_simple_remove3)
{
Eina_Rbtree *root = NULL;
Eina_Rbtree *lookup;
_eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rbtree_fuzzy)
+EFL_START_TEST(eina_rbtree_fuzzy)
{
Eina_Rbtree_Int *child;
Eina_Rbtree *root = NULL;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_rbtree(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_rectangle_pool)
+EFL_START_TEST(eina_rectangle_pool)
{
Eina_Rectangle_Pool *pool;
Eina_Rectangle *rects[8][8];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rectangle_pool_skyline)
+EFL_START_TEST(eina_rectangle_pool_skyline)
{
Eina_Rectangle_Pool *pool;
Eina_Rectangle *rects[8][8];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rectangle_union_intersect)
+EFL_START_TEST(eina_rectangle_union_intersect)
{
Eina_Rectangle r1, r2, r3, r4, r5, r6, r7, r8, rd;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_rectangle_position_test)
+EFL_START_TEST(eina_rectangle_position_test)
{
Eina_Rectangle middle, top, down, right, left;
EINA_RECTANGLE_SET(&middle, -1, -1, 2.0, 2.0);
ck_assert_int_eq(eina_rectangle_outside_position(&middle, &left), EINA_RECTANGLE_OUTSIDE_LEFT) ;
}
-END_TEST
+EFL_END_TEST
void
eina_test_rectangle(TCase *tc)
static int test_array2[64] = { 8, 9, 10, 11, 12, 13, 14 };
static const void *pointers[1088] = { NULL };
-START_TEST(eina_test_reusable)
+EFL_START_TEST(eina_test_reusable)
{
unsigned int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Barrier b;
return NULL;
}
-START_TEST(eina_test_threading)
+EFL_START_TEST(eina_test_threading)
{
Eina_Thread t1, t2;
unsigned int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_lowestbit)
+EFL_START_TEST(eina_test_lowestbit)
{
unsigned int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_safepointer(TCase *tc)
return NULL;
}
-START_TEST(eina_test_sched_prio_drop)
+EFL_START_TEST(eina_test_sched_prio_drop)
{
int niceval = getpriority(PRIO_PROCESS, 0);
int niceval2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#else
-START_TEST(eina_test_sched_prio_drop)
+EFL_START_TEST(eina_test_sched_prio_drop)
{
fprintf(stderr, "scheduler priority is not supported by your configuration.\n");
}
-END_TEST
+EFL_END_TEST
#endif
void
return NULL;
}
-START_TEST(eina_simple_xml_parser_node_dump)
+EFL_START_TEST(eina_simple_xml_parser_node_dump)
{
FILE *f;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_simple_xml_parser_null_node_dump)
+EFL_START_TEST(eina_simple_xml_parser_null_node_dump)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_simple_xml_parser_childs_count)
+EFL_START_TEST(eina_simple_xml_parser_childs_count)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
enum simple_xml_parser_current_state
{
return EINA_TRUE;
}
-START_TEST(eina_simple_xml_parser_parse_with_custom_callback)
+EFL_START_TEST(eina_simple_xml_parser_parse_with_custom_callback)
{
FILE *f;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_simple_xml_parser(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_test_slice_init)
+EFL_START_TEST(eina_test_slice_init)
{
Eina_Rw_Slice a = EINA_SLICE_STR_LITERAL("hello world");
char buf[1024] = "";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_slice_ro)
+EFL_START_TEST(eina_test_slice_ro)
{
Eina_Slice slice = EINA_SLICE_STR_LITERAL("hi there");
Eina_Slice a, needle;
r = eina_slice_endswith(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL(""));
fail_unless(r == EINA_FALSE);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_slice_rw)
+EFL_START_TEST(eina_test_slice_rw)
{
uint8_t buf[] = "hi there";
Eina_Rw_Slice rw_slice = EINA_SLICE_ARRAY(buf);
r = eina_rw_slice_endswith(rw_slice, (Eina_Slice)EINA_SLICE_STR_LITERAL(""));
fail_unless(r == EINA_FALSE);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_slice_print)
+EFL_START_TEST(eina_test_slice_print)
{
char buf[] = "Hello World";
Eina_Slice slice = {.len = strlen("Hello"), .mem = buf};
snprintf(a, sizeof(a), EINA_SLICE_STR_FMT, EINA_SLICE_STR_PRINT(slice));
fail_unless(strcmp(a, "Hello") == 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_slice_find)
+EFL_START_TEST(eina_test_slice_find)
{
Eina_Slice slice = EINA_SLICE_STR_LITERAL("abcdef");
const char *p;
p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL(""));
fail_unless(p == NULL);
}
-END_TEST
+EFL_END_TEST
void
eina_test_slice(TCase *tc)
return eina_slstr_copy_new(local);
}
-START_TEST(slstr_copy)
+EFL_START_TEST(slstr_copy)
{
Eina_Slstr *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Slstr *
_slstr_steal(void)
return eina_slstr_copy_new(local);
}
-START_TEST(slstr_steal)
+EFL_START_TEST(slstr_steal)
{
Eina_Slstr *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Slstr *
_slstr_stringshare(void)
return eina_slstr_stringshare_new(str);
}
-START_TEST(slstr_stringshare)
+EFL_START_TEST(slstr_stringshare)
{
Eina_Stringshare *ss;
Eina_Slstr *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Slstr *
_slstr_tmpstr(void)
return eina_slstr_tmpstr_new(str);
}
-START_TEST(slstr_tmpstr)
+EFL_START_TEST(slstr_tmpstr)
{
Eina_Slstr *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Slstr *
_slstr_strbuf(void)
return eina_slstr_strbuf_new(str);
}
-START_TEST(slstr_strbuf)
+EFL_START_TEST(slstr_strbuf)
{
Eina_Slstr *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Slstr *
_slstr_printf(int val)
return eina_slstr_printf("Hello %s %d", "world", val);
}
-START_TEST(slstr_slstr_printf)
+EFL_START_TEST(slstr_slstr_printf)
{
Eina_Slstr *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_many_do(void)
}
}
-START_TEST(slstr_many)
+EFL_START_TEST(slstr_many)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static void *
_thread_cb(void *data EINA_UNUSED, Eina_Thread th EINA_UNUSED)
return NULL;
}
-START_TEST(slstr_thread)
+EFL_START_TEST(slstr_thread)
{
const int threads = 8;
Eina_Thread th[threads];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_slstr(TCase *tc)
#include "eina_suite.h"
-START_TEST(str_simple)
+EFL_START_TEST(str_simple)
{
size_t i;
char *str, *ret;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(str_split)
+EFL_START_TEST(str_split)
{
char **result;
unsigned int elements;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(str_lcat_lcpy)
+EFL_START_TEST(str_lcat_lcpy)
{
char dst[9];
size_t ret;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(str_join_len)
+EFL_START_TEST(str_join_len)
{
char dst[9];
size_t ret;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(str_memdup)
+EFL_START_TEST(str_memdup)
{
struct temp {
int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(str_strftime)
+EFL_START_TEST(str_strftime)
{
time_t curr_time;
struct tm *info;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#ifdef HAVE_ICONV
-START_TEST(str_convert)
+EFL_START_TEST(str_convert)
{
char *utf8 = "\xc3\xa9\xc3\xa1\xc3\xba\xc3\xad\xc3\xa8\xc3\xa0\xc3\xb9\xc3\xac\xc3\xab\xc3\xa4\xc3\xbc\xc3\xaf";
char *utf16 = "\xe9\x0\xe1\x0\xfa\x0\xed\x0\xe8\x0\xe0\x0\xf9\x0\xec\x0\xeb\x0\xe4\x0\xfc\x0\xef\x0";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void
#include "eina_suite.h"
-START_TEST(strbuf_simple)
+EFL_START_TEST(strbuf_simple)
{
Eina_Strbuf *buf;
char *txt;
eina_shutdown();
#undef TEST_TEXT
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_manage_simple)
+EFL_START_TEST(strbuf_manage_simple)
{
Eina_Strbuf *buf;
char *txt;
eina_shutdown();
#undef TEST_TEXT
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_remove)
+EFL_START_TEST(strbuf_remove)
{
Eina_Strbuf *buf;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_append)
+EFL_START_TEST(strbuf_append)
{
Eina_Strbuf *buf;
Eina_Slice ro_slice = EINA_SLICE_STR_LITERAL("somethingELSE");
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_insert)
+EFL_START_TEST(strbuf_insert)
{
Eina_Strbuf *buf;
Eina_Slice ro_slice = EINA_SLICE_STR_LITERAL("EINA");
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_replace)
+EFL_START_TEST(strbuf_replace)
{
Eina_Strbuf *buf;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_realloc)
+EFL_START_TEST(strbuf_realloc)
{
Eina_Strbuf *buf;
char pattern[1024 * 16];
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_append_realloc)
+EFL_START_TEST(strbuf_append_realloc)
{
Eina_Strbuf *buf;
const size_t runs = 40960;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_prepend_realloc)
+EFL_START_TEST(strbuf_prepend_realloc)
{
Eina_Strbuf *buf;
const size_t runs = 40960;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_trim)
+EFL_START_TEST(strbuf_trim)
{
Eina_Strbuf* buf;
const char *str;
eina_strbuf_free(buf);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_tolower)
+EFL_START_TEST(strbuf_tolower)
{
Eina_Strbuf* buf;
const char *str;
eina_strbuf_free(buf);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_substr_get)
+EFL_START_TEST(strbuf_substr_get)
{
Eina_Strbuf* buf, *substr;
const char *str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
static const char*
test_prepend_vprintf(Eina_Strbuf *buf, char *fmt, va_list ap)
return str;
}
-START_TEST(strbuf_prepend_print)
+EFL_START_TEST(strbuf_prepend_print)
{
Eina_Bool ret;
Eina_Strbuf* buf;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_release_test)
+EFL_START_TEST(strbuf_release_test)
{
Eina_Strbuf *buf;
char *string;
string = eina_strbuf_release(buf);
ck_assert_str_eq(string, "strbuf_release_test");
}
-END_TEST
+EFL_END_TEST
-START_TEST(strbuf_strftime_test)
+EFL_START_TEST(strbuf_strftime_test)
{
Eina_Strbuf *buf;
time_t curr_time;
eina_strbuf_free(buf);
}
-END_TEST
+EFL_END_TEST
void
eina_test_strbuf(TCase *tc)
fail_if(i == 0);
}
-START_TEST(eina_test_tile_grid_slicer_iterator)
+EFL_START_TEST(eina_test_tile_grid_slicer_iterator)
{
Eina_Iterator *it;
struct test_rect *cur_test;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_tiler_all)
+EFL_START_TEST(eina_test_tiler_all)
{
Eina_Tiler *tl;
Eina_Iterator *it;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_tiler_stable)
+EFL_START_TEST(eina_test_tiler_stable)
{
Eina_Tiler *tl;
Eina_Rectangle *rp;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_tiler_calculation)
+EFL_START_TEST(eina_test_tiler_calculation)
{
Eina_Tiler *t1, *t2, *t;
Eina_Iterator *itr;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_tiler_size)
+EFL_START_TEST(eina_test_tiler_size)
{
Eina_Rectangle *r;
Eina_Iterator *it;
eina_tiler_free(t);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_tiler(TCase *tc)
#include "eina_suite.h"
-START_TEST(tmpstr_simple)
+EFL_START_TEST(tmpstr_simple)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(tmpstr_simple_len)
+EFL_START_TEST(tmpstr_simple_len)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(tmpstr_manage)
+EFL_START_TEST(tmpstr_manage)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(tmpstr_manage_len)
+EFL_START_TEST(tmpstr_manage_len)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(tmpstr_len)
+EFL_START_TEST(tmpstr_len)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_tmpstr(TCase *tc)
#include "eina_suite.h"
-START_TEST(trash_simple)
+EFL_START_TEST(trash_simple)
{
Eina_Trash *trash;
unsigned int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_trash(TCase *tc)
static const Eina_Unicode STR4[] = {'A', 0};
static const Eina_Unicode EMPTYSTR[] = {0};
-START_TEST(eina_unicode_strcmp_test)
+EFL_START_TEST(eina_unicode_strcmp_test)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_strcpy_test)
+EFL_START_TEST(eina_unicode_strcpy_test)
{
Eina_Unicode buf[10] = { 0 };
Eina_Unicode *rv;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_strncpy_test)
+EFL_START_TEST(eina_unicode_strncpy_test)
{
Eina_Unicode buf[10] = { 0 };
Eina_Unicode *rv;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_ustr_strlen_test)
+EFL_START_TEST(eina_ustr_strlen_test)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_strnlen_test)
+EFL_START_TEST(eina_unicode_strnlen_test)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_strdup_test)
+EFL_START_TEST(eina_unicode_strdup_test)
{
Eina_Unicode *buf;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_strstr_test)
+EFL_START_TEST(eina_unicode_strstr_test)
{
Eina_Unicode *buf;
Eina_Unicode on[] = { 'O', 'n', 0 };
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_escape_test)
+EFL_START_TEST(eina_unicode_escape_test)
{
Eina_Unicode str[][10] = {{'P', 'a', ' ', 'O', 'n', 0},
{'P', 'a', ' ', '\\', '\'',0},
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_utf8)
+EFL_START_TEST(eina_unicode_utf8)
{
int ind;
unsigned char ch;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_unicode_utf8_conversion)
+EFL_START_TEST(eina_unicode_utf8_conversion)
{
Eina_Unicode uni_in[] = {0x5D0, 0xFDF6, 0xDC80, 0x1F459, 0x3FFFFFF,
0x7FFFFFFF, 'a', 'b', 'c', 0};
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_ustr(TCase *tc)
static const Eina_Unicode TEST0[] = {'t', 'e', 's', 't', '/', '0', 0};
static const Eina_Unicode TEST1[] = {'t', 'e', 's', 't', '/', '1', 0};
-START_TEST(eina_ustringshare_simple)
+EFL_START_TEST(eina_ustringshare_simple)
{
const Eina_Unicode *t0;
const Eina_Unicode *t1;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_ustringshare_test_share)
+EFL_START_TEST(eina_ustringshare_test_share)
{
const Eina_Unicode *t0;
const Eina_Unicode *t1;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_ustringshare_putstuff)
+EFL_START_TEST(eina_ustringshare_putstuff)
{
const Eina_Unicode *tmp;
int i;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_ustringshare(TCase *tc)
#define FP_ERR (1)
#define CHECK_FP(a, b) ((a - b) <= FP_ERR)
-START_TEST(eina_value_test_simple)
+EFL_START_TEST(eina_value_test_simple)
{
Eina_Value *value;
char c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_compare)
+EFL_START_TEST(eina_value_test_compare)
{
Eina_Value *a, *b;
eina_value_free(b);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_string)
+EFL_START_TEST(eina_value_test_string)
{
Eina_Value *value;
const char *s;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_pvariant)
+EFL_START_TEST(eina_value_test_pvariant)
{
Eina_Value *value;
char c, in_c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_to_string)
+EFL_START_TEST(eina_value_test_to_string)
{
Eina_Value *value;
char c, in_c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_to_binbuf)
+EFL_START_TEST(eina_value_test_to_binbuf)
{
Eina_Value *value;
char c, in_c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_char)
+EFL_START_TEST(eina_value_test_convert_char)
{
Eina_Value *value, conv;
char c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_uchar)
+EFL_START_TEST(eina_value_test_convert_uchar)
{
Eina_Value *value, conv;
char c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_short)
+EFL_START_TEST(eina_value_test_convert_short)
{
Eina_Value *value, conv;
short s;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_ushort)
+EFL_START_TEST(eina_value_test_convert_ushort)
{
Eina_Value *value, conv;
int i;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_int)
+EFL_START_TEST(eina_value_test_convert_int)
{
Eina_Value *value, conv;
int i;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_uint)
+EFL_START_TEST(eina_value_test_convert_uint)
{
Eina_Value *value, conv;
unsigned int ui;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_long)
+EFL_START_TEST(eina_value_test_convert_long)
{
Eina_Value *value, conv;
char c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_ulong)
+EFL_START_TEST(eina_value_test_convert_ulong)
{
Eina_Value *value, conv;
char c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_convert_float)
+EFL_START_TEST(eina_value_test_convert_float)
{
Eina_Value *value, conv;
char c;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_array)
+EFL_START_TEST(eina_value_test_array)
{
Eina_Value *value, other;
Eina_Value_Array desc;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_list)
+EFL_START_TEST(eina_value_test_list)
{
Eina_Value *value, other;
Eina_Value_List desc;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_hash)
+EFL_START_TEST(eina_value_test_hash)
{
Eina_Value *value, other;
Eina_Value_Hash desc;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_timeval)
+EFL_START_TEST(eina_value_test_timeval)
{
Eina_Value *value, other;
struct timeval itv, otv;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_blob)
+EFL_START_TEST(eina_value_test_blob)
{
Eina_Value *value, other;
Eina_Value_Blob in, out;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_struct)
+EFL_START_TEST(eina_value_test_struct)
{
struct mybigst {
int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, x;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_array_of_struct)
+EFL_START_TEST(eina_value_test_array_of_struct)
{
struct myst {
int a, b, c;
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_optional_int)
+EFL_START_TEST(eina_value_test_optional_int)
{
eina_init();
/* eina_value_free(value); */
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_optional_string)
+EFL_START_TEST(eina_value_test_optional_string)
{
eina_init();
eina_value_free(value);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_optional_struct_members)
+EFL_START_TEST(eina_value_test_optional_struct_members)
{
eina_init();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_value)
+EFL_START_TEST(eina_value_test_value)
{
Eina_Value composed, v;
const int ivalue = 3500;
eina_value_flush(&composed);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_value_test_value_string)
+EFL_START_TEST(eina_value_test_value_string)
{
Eina_Value composed, v, str_v;
const char *msg = "A string", *str;
eina_value_flush(&v);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_value(TCase *tc)
#include "eina_suite.h"
-START_TEST(eina_test_vector2_operations)
+EFL_START_TEST(eina_test_vector2_operations)
{
Eina_Vector2 v1;
Eina_Vector2 v2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_vector3_operations)
+EFL_START_TEST(eina_test_vector3_operations)
{
Eina_Vector3 v1;
Eina_Vector3 v2;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eina_test_vector(TCase *tc)
#include <Eina.h>
#include <check.h>
+#include "eina_suite.h"
-
-START_TEST(eina_test_vpath_valid)
+EFL_START_TEST(eina_test_vpath_valid)
{
int ret;
char test[PATH_MAX];
ret = eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_vpath_invalid)
+EFL_START_TEST(eina_test_vpath_invalid)
{
int ret;
ret = eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void eina_test_vpath(TCase *tc)
{
}
#ifdef XATTR_TEST_DIR
-START_TEST(eina_test_xattr_set)
+EFL_START_TEST(eina_test_xattr_set)
{
char *filename = "tmpfile";
char *attribute1 = "user.comment1";
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_xattr_list)
+EFL_START_TEST(eina_test_xattr_list)
{
char *filename = "tmpfile";
char *filename_cp = "tmpfile_cp";
eina_tmpstr_del(cp_file_path);
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eina_test_xattr_types)
+EFL_START_TEST(eina_test_xattr_types)
{
char *filename = "tmpfile";
char *str_attr = "user.name", *ret_str;
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void
#include <algorithm>
#include <check.h>
-
+#include "../efl_check.h"
void eina_test_inlist(TCase* tc);
void eina_test_inarray(TCase* tc);
void eina_test_ptrlist(TCase* tc);
#include <Efl.h>
#include <stdio.h>
-#include <check.h>
-
+#include "eio_suite.h"
#define EFL_MODEL_TEST_FILENAME_PATH "/tmp"
#define EFL_MODEL_MAX_TEST_CHILDS 16
ecore_main_loop_quit();
}
-START_TEST(eio_model_test_test_file)
+EFL_START_TEST(eio_model_test_test_file)
{
Eo *filemodel = NULL;
ecore_shutdown();
eina_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eio_model_test_file(TCase *tc)
#include <Efl.h>
#include <stdio.h>
-#include <check.h>
+#include "eio_suite.h"
Eina_Tmpstr* temp_filename = NULL;
const char* tmpdir = NULL;
ecore_main_loop_quit();
}
-START_TEST(eio_model_test_test_monitor_add)
+EFL_START_TEST(eio_model_test_test_monitor_add)
{
Eo *filemodel = NULL;
fail_if(!children_deleted);
}
-END_TEST
+EFL_END_TEST
void
eio_model_test_monitor_add(TCase *tc)
#define _EIO_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void eio_test_monitor(TCase *tc);
void eio_test_sentry(TCase *tc);
void eio_model_test_file(TCase *tc);
ecore_main_loop_quit();
}
-START_TEST(eio_test_eet_cipher_decipher)
+EFL_START_TEST(eio_test_eet_cipher_decipher)
{
int ret;
char *data = "This is the data to save in file";
eet_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
typedef struct
{
ecore_main_loop_quit();
}
-START_TEST(eio_test_eet_data_cipher_decipher)
+EFL_START_TEST(eio_test_eet_data_cipher_decipher)
{
int ret;
const char *key = "This is a secret key";
eet_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eio_test_eet(TCase *tc)
ecore_main_loop_quit();
}
-START_TEST(eio_file_test_ls)
+EFL_START_TEST(eio_file_test_ls)
{
int number_of_listed_files = 0, ret;
const char *new_dir = "new_dir";
eio_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_file_test_file)
+EFL_START_TEST(eio_file_test_file)
{
int number_of_listed_files = 0, ret;
Eina_Bool is_dir;
eio_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_file_test_open)
+EFL_START_TEST(eio_file_test_open)
{
Eina_Bool opened_file;
int ret;
eio_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eio_test_file(TCase *tc)
efl_del(job);
}
-START_TEST(efl_io_manager_test_stat)
+EFL_START_TEST(efl_io_manager_test_stat)
{
Eina_Tmpstr *test_dirname;
Eina_Tmpstr *nested_dirname;
eio_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_io_manager_test_ls)
+EFL_START_TEST(efl_io_manager_test_ls)
{
Eina_Tmpstr *test_dirname;
Eina_Tmpstr *nested_dirname;
eio_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_io_manager_test_open)
+EFL_START_TEST(efl_io_manager_test_open)
{
Eina_Tmpstr *test_dirname;
Eina_Tmpstr *nested_dirname;
eina_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_io_instantiated)
+EFL_START_TEST(efl_io_instantiated)
{
Efl_Io_Manager *manager;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eio_test_job(TCase *tc)
return array;
}
-START_TEST(eio_test_job_xattr_set)
+EFL_START_TEST(eio_test_job_xattr_set)
{
char *filename = "eio-tmpfile";
Eina_Tmpstr *test_file_path;
eina_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void eio_test_job_xattr(TCase *tc)
{
ecore_main_loop_quit();
}
-START_TEST(eio_test_map_simple)
+EFL_START_TEST(eio_test_map_simple)
{
int fd;
const char *file = "eio_map_exampleXXXXXX.txt";
eina_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eio_test_map(TCase *tc)
/////// tests monitoring a directory
-START_TEST(eio_test_monitor_add_and_remove)
+EFL_START_TEST(eio_test_monitor_add_and_remove)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_add_remove_add)
+EFL_START_TEST(eio_test_monitor_add_remove_add)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_add_add_remove_remove)
+EFL_START_TEST(eio_test_monitor_add_add_remove_remove)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename1;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _file_created_cb(void *data, int type, void *event)
{
}
-START_TEST(eio_test_monitor_directory_file_created_notify)
+EFL_START_TEST(eio_test_monitor_directory_file_created_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
struct {
Eina_Stringshare *s;
ecore_main_loop_quit();
}
-START_TEST(eio_test_monitor_directory_multi_file_created_notify)
+EFL_START_TEST(eio_test_monitor_directory_multi_file_created_notify)
{
Eina_Tmpstr *dirname = _common_init();
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _file_deleted_cb(void *data, int type, void *event)
{
}
}
-START_TEST(eio_test_monitor_directory_file_deleted_notify)
+EFL_START_TEST(eio_test_monitor_directory_file_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _file_modified_cb(void *data, int type, void *event)
{
}
}
-START_TEST(eio_test_monitor_directory_file_modified_notify)
+EFL_START_TEST(eio_test_monitor_directory_file_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _file_closed_cb(void *data, int type, void *event)
{
}
}
-START_TEST(eio_test_monitor_directory_file_closed_notify)
+EFL_START_TEST(eio_test_monitor_directory_file_closed_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _directory_created_cb(void *data, int type, void *event)
{
}
}
-START_TEST(eio_test_monitor_directory_directory_created_notify)
+EFL_START_TEST(eio_test_monitor_directory_directory_created_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _directory_deleted_cb(void *data, int type, void *event)
{
}
}
-START_TEST(eio_test_monitor_directory_directory_deleted_notify)
+EFL_START_TEST(eio_test_monitor_directory_directory_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _directory_modified_cb(void *data, int type, void *event)
{
}
-START_TEST(eio_test_monitor_directory_directory_modified_notify)
+EFL_START_TEST(eio_test_monitor_directory_directory_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _directory_self_deleted_cb(void *data, int type, void *event)
}
-START_TEST(eio_test_monitor_directory_directory_self_deleted_notify)
+EFL_START_TEST(eio_test_monitor_directory_directory_self_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
//////// test monitoring a single file
-START_TEST(eio_test_monitor_file_file_modified_notify)
+EFL_START_TEST(eio_test_monitor_file_file_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_file_file_attrib_modified_notify)
+EFL_START_TEST(eio_test_monitor_file_file_attrib_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_file_file_closed_notify)
+EFL_START_TEST(eio_test_monitor_file_file_closed_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_file_file_self_deleted_notify)
+EFL_START_TEST(eio_test_monitor_file_file_self_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_two_monitors_one_event)
+EFL_START_TEST(eio_test_monitor_two_monitors_one_event)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Tmpstr *dirname2;
_delete_directory((void*)dirname2);
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_two_monitors_one_removed_one_event)
+EFL_START_TEST(eio_test_monitor_two_monitors_one_removed_one_event)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Tmpstr *dirname2;
_delete_directory((void*)dirname2);
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _unexpected_event_cb(void *data EINA_UNUSED, int type EINA_UNUSED, void *event EINA_UNUSED)
{
ck_abort_msg("unexpected event");
}
-START_TEST(eio_test_monitor_two_monitors_one_removed_no_event)
+EFL_START_TEST(eio_test_monitor_two_monitors_one_removed_no_event)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Tmpstr *dirname2;
_delete_directory((void*)dirname2);
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_two_files_in_same_directory)
+EFL_START_TEST(eio_test_monitor_two_files_in_same_directory)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_monitor_two_files_in_same_directory_one_removed)
+EFL_START_TEST(eio_test_monitor_two_files_in_same_directory_one_removed)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
void eio_test_monitor(TCase *tc)
/////// tests monitoring a directory
-START_TEST(eio_test_sentry_add_and_remove)
+EFL_START_TEST(eio_test_sentry_add_and_remove)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_add_remove_add)
+EFL_START_TEST(eio_test_sentry_add_remove_add)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_add_add_remove_remove)
+EFL_START_TEST(eio_test_sentry_add_add_remove_remove)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename1;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _target_notified_cb(void *data, const Efl_Event *event)
{
}
-START_TEST(eio_test_sentry_directory_file_created_notify)
+EFL_START_TEST(eio_test_sentry_directory_file_created_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_directory_file_deleted_notify)
+EFL_START_TEST(eio_test_sentry_directory_file_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_directory_file_modified_notify)
+EFL_START_TEST(eio_test_sentry_directory_file_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_directory_file_closed_notify)
+EFL_START_TEST(eio_test_sentry_directory_file_closed_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_directory_directory_created_notify)
+EFL_START_TEST(eio_test_sentry_directory_directory_created_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_directory_directory_deleted_notify)
+EFL_START_TEST(eio_test_sentry_directory_directory_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_directory_directory_modified_notify)
+EFL_START_TEST(eio_test_sentry_directory_directory_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_directory_directory_self_deleted_notify)
+EFL_START_TEST(eio_test_sentry_directory_directory_self_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eo *sentry = efl_add(EIO_SENTRY_CLASS, efl_main_loop_get());
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
// //////// test monitoring a single file
-START_TEST(eio_test_sentry_file_file_modified_notify)
+EFL_START_TEST(eio_test_sentry_file_file_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_file_file_attrib_modified_notify)
+EFL_START_TEST(eio_test_sentry_file_file_attrib_modified_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_file_file_closed_notify)
+EFL_START_TEST(eio_test_sentry_file_file_closed_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_file_file_self_deleted_notify)
+EFL_START_TEST(eio_test_sentry_file_file_self_deleted_notify)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_two_monitors_one_event)
+EFL_START_TEST(eio_test_sentry_two_monitors_one_event)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Tmpstr *dirname2;
_delete_directory((void*)dirname2);
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_two_monitors_one_removed_one_event)
+EFL_START_TEST(eio_test_sentry_two_monitors_one_removed_one_event)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Tmpstr *dirname2;
_delete_directory((void*)dirname2);
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
static void _unexpected_event_cb(void *data EINA_UNUSED, const Efl_Event *event EINA_UNUSED)
{
ck_abort_msg("unexpected event");
}
-START_TEST(eio_test_sentry_two_monitors_one_removed_no_event)
+EFL_START_TEST(eio_test_sentry_two_monitors_one_removed_no_event)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Tmpstr *dirname2;
_delete_directory((void*)dirname2);
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_two_files_in_same_directory)
+EFL_START_TEST(eio_test_sentry_two_files_in_same_directory)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_sentry_two_files_in_same_directory_one_removed)
+EFL_START_TEST(eio_test_sentry_two_files_in_same_directory_one_removed)
{
Eina_Tmpstr *dirname = _common_init();
Eina_Stringshare *filename;
//cleanup
_common_shutdown(dirname);
}
-END_TEST
+EFL_END_TEST
void eio_test_sentry(TCase *tc)
ecore_main_loop_quit();
}
-START_TEST(eio_test_xattr_set)
+EFL_START_TEST(eio_test_xattr_set)
{
char *filename = "eio-tmpfile";
Eina_Tmpstr *test_file_path;
eina_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eio_test_xattr_types_set)
+EFL_START_TEST(eio_test_xattr_types_set)
{
char *filename = "eio-tmpfile";
eina_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void eio_test_xattr(TCase *tc)
#define _ELDBUS_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void eldbus_test_eldbus_init(TCase *tc);
void eldbus_test_eldbus_model(TCase *tc);
void eldbus_test_eldbus_model_connection(TCase *tc);
return EINA_FALSE;
}
-START_TEST(eldbus_test_eldbus)
+EFL_START_TEST(eldbus_test_eldbus)
{
int ret;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eldbus_test_eldbus_main_loop)
+EFL_START_TEST(eldbus_test_eldbus_main_loop)
{
Ecore_Timer *timer;
int ret;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
#if 0
/* TODO: This test assumes an existing dbus-daemon running. It
* afterwards.
*/
-START_TEST(eldbus_test_eldbus_conn)
+EFL_START_TEST(eldbus_test_eldbus_conn)
{
Eldbus_Connection *conn;
int ret;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eldbus_test_eldbus_conn_object)
+EFL_START_TEST(eldbus_test_eldbus_conn_object)
{
Eldbus_Connection *conn;
Eldbus_Object *obj;
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void name_owner_changed_cb(void *data, const char *bus EINA_UNUSED, const char *old_id EINA_UNUSED, const char *new_id)
{
*id = new_id;
}
-START_TEST(eldbus_test_eldbus_name_owner_changed)
+EFL_START_TEST(eldbus_test_eldbus_name_owner_changed)
{
Eldbus_Connection *conn;
const char *id = NULL;
eldbus_shutdown();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void eldbus_test_eldbus_init(TCase *tc)
* @}
*/
-START_TEST(utc_eldbus_message_iterator_activatable_list_p)
+EFL_START_TEST(utc_eldbus_message_iterator_activatable_list_p)
{
_activable_list_get(_response_message_cb);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
*/
-START_TEST(utc_eldbus_message_info_data_get_p)
+EFL_START_TEST(utc_eldbus_message_info_data_get_p)
{
const int timeout_send_ms = 1000;
eldbus_message_unref(msg);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
*/
-START_TEST(utc_eldbus_message_signal_new_p)
+EFL_START_TEST(utc_eldbus_message_signal_new_p)
{
const int timeout_send_ms = 1000;
eldbus_message_unref(msg);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
*/
-START_TEST(utc_eldbus_message_ref_unref_p)
+EFL_START_TEST(utc_eldbus_message_ref_unref_p)
{
Eldbus_Connection *conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
ck_assert_ptr_ne(NULL, conn);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
*/
-START_TEST(utc_eldbus_message_basic_eina_value_p)
+EFL_START_TEST(utc_eldbus_message_basic_eina_value_p)
{
is_success = EINA_FALSE;
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
*/
-START_TEST(utc_eldbus_message_iter_next_p)
+EFL_START_TEST(utc_eldbus_message_iter_next_p)
{
_activable_list_get(_activatable_list_response_cb);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_message_arguments_vappend_p)
+EFL_START_TEST(utc_eldbus_message_arguments_vappend_p)
{
is_success = EINA_FALSE;
Eldbus_Connection *conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
eldbus_message_unref(message_vparam);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_message_arguments_vget_p)
+EFL_START_TEST(utc_eldbus_message_arguments_vget_p)
{
is_success = EINA_FALSE;
Eldbus_Connection *conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
eldbus_message_unref(message);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_message_eina_p)
+EFL_START_TEST(utc_eldbus_message_eina_p)
{
is_success = EINA_FALSE;
is_register_service = EINA_FALSE;
eldbus_service_interface_unregister(iface);
eldbus_connection_unref(conn_server);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_message_container_p)
+EFL_START_TEST(utc_eldbus_message_container_p)
{
int i;
eldbus_service_interface_unregister(iface);
eldbus_connection_unref(conn_server);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_message_error_new_p)
+EFL_START_TEST(utc_eldbus_message_error_new_p)
{
is_success = EINA_FALSE;
ck_assert_msg(is_success, "Can't get response");
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_message_iter_del_p)
+EFL_START_TEST(utc_eldbus_message_iter_del_p)
{
Eldbus_Connection *conn_server = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
ck_assert_ptr_ne(NULL, conn_server);
eldbus_service_interface_unregister(iface);
eldbus_connection_unref(conn_server);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_message_iter_fixed_array_get_p)
+EFL_START_TEST(utc_eldbus_message_iter_fixed_array_get_p)
{
is_success = EINA_FALSE;
ck_assert_msg(is_success, "Can't get response");
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_message
* @}
* @}
*/
-START_TEST(utc_eldbus_hello_p)
+EFL_START_TEST(utc_eldbus_hello_p)
{
is_success = EINA_FALSE;
ck_assert_msg(is_success, "Can't get response");
}
-END_TEST
+EFL_END_TEST
void eldbus_test_eldbus_message(TCase *tc)
{
efl_unref(future);
}
-START_TEST(smoke)
+EFL_START_TEST(smoke)
{
check_init();
check_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(object)
+EFL_START_TEST(object)
{
check_init();
check_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(proxy)
+EFL_START_TEST(proxy)
{
check_init();
check_shutdown();
}
-END_TEST
+EFL_END_TEST
void
eldbus_test_eldbus_model(TCase *tc)
check_shutdown();
}
-START_TEST(properties_get)
+EFL_START_TEST(properties_get)
{
const Eina_Array *properties = NULL;
properties = efl_model_properties_get(connection);
unsigned int actual_properties_count = eina_array_count(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_get)
+EFL_START_TEST(property_get)
{
Efl_Future *future;
future = efl_model_property_get(connection, UNIQUE_NAME_PROPERTY);
future = efl_model_property_get(connection, "nonexistent");
check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_FOUND);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_set)
+EFL_START_TEST(property_set)
{
Eina_Value value;
Efl_Future *future;
eina_value_flush(&value);
}
-END_TEST
+EFL_END_TEST
static void
_test_children_count(Eo *efl_model)
check_efl_model_children_count_ge(efl_model, 2);
}
-START_TEST(children_count)
+EFL_START_TEST(children_count)
{
_test_children_count(connection);
}
-END_TEST
+EFL_END_TEST
-START_TEST(children_slice_get)
+EFL_START_TEST(children_slice_get)
{
check_efl_model_children_slice_get(connection);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_add)
+EFL_START_TEST(child_add)
{
Eo *child;
child = efl_model_child_add(connection);
ck_assert_ptr_eq(NULL, child);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_del)
+EFL_START_TEST(child_del)
{
unsigned int expected_children_count = 0;
Efl_Future *future;
ck_assert_int_le(expected_children_count, actual_children_count);
}
-END_TEST
+EFL_END_TEST
void eldbus_test_eldbus_model_connection(TCase *tc)
{
check_shutdown();
}
-START_TEST(properties_get)
+EFL_START_TEST(properties_get)
{
const Eina_Array *properties = NULL;
properties = efl_model_properties_get(method);
const unsigned int actual_properties_count = eina_array_count(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_get)
+EFL_START_TEST(property_get)
{
// Input only property returns error
Efl_Future *future;
future = efl_model_property_get(method, "nonexistent");
check_efl_model_future_error(future, NULL);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_set)
+EFL_START_TEST(property_set)
{
// Output argument returns error
Efl_Future *future;
future = efl_model_property_set(method, ARGUMENT_RESULT, &dummy);
check_efl_model_future_error(future, NULL);
}
-END_TEST
+EFL_END_TEST
static void
_test_method_children_count(Eo *efl_model)
check_efl_model_children_count_eq(efl_model, 0);
}
-START_TEST(children_count)
+EFL_START_TEST(children_count)
{
_test_method_children_count(method);
}
-END_TEST
+EFL_END_TEST
-START_TEST(children_slice_get)
+EFL_START_TEST(children_slice_get)
{
Efl_Future *future;
future = efl_model_children_slice_get(method, 1, 1);
check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_SUPPORTED);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_add)
+EFL_START_TEST(child_add)
{
Eo *child;
child = efl_model_child_add(method);
ck_assert_ptr_eq(NULL, child);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_del)
+EFL_START_TEST(child_del)
{
// efl_model_child_del always returns ERROR
Eo *child = NULL;
efl_model_child_del(method, child);
//ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
}
-END_TEST
+EFL_END_TEST
-START_TEST(call)
+EFL_START_TEST(call)
{
check_efl_model_property_int_set(method, ARGUMENT_A, 12345678);
check_efl_model_property_int_set(method, ARGUMENT_B, 87654321);
efl_model_wait_for_event(method, ELDBUS_MODEL_METHOD_EVENT_SUCCESSFUL_CALL);
check_efl_model_property_int_eq(method, ARGUMENT_RESULT, 99999999);
}
-END_TEST
+EFL_END_TEST
void eldbus_test_eldbus_model_method(TCase *tc)
{
check_shutdown();
}
-START_TEST(properties_get)
+EFL_START_TEST(properties_get)
{
const Eina_Array *properties = NULL;
properties = efl_model_properties_get(object);
unsigned int actual_properties_count = eina_array_count(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_get)
+EFL_START_TEST(property_get)
{
Efl_Future *future;
future = efl_model_property_get(object, UNIQUE_NAME_PROPERTY);
future = efl_model_property_get(object, "nonexistent");
check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_FOUND);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_set)
+EFL_START_TEST(property_set)
{
Eina_Value value;
Efl_Future *future;
eina_value_flush(&value);
}
-END_TEST
+EFL_END_TEST
static void
_test_children_count(Eo *efl_model)
check_efl_model_children_count_ge(efl_model, 2);
}
-START_TEST(children_count)
+EFL_START_TEST(children_count)
{
_test_children_count(object);
}
-END_TEST
+EFL_END_TEST
-START_TEST(children_slice_get)
+EFL_START_TEST(children_slice_get)
{
check_efl_model_children_slice_get(object);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_add)
+EFL_START_TEST(child_add)
{
Eo *child;
child = efl_model_child_add(object);
ck_assert_ptr_eq(NULL, child);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_del)
+EFL_START_TEST(child_del)
{
unsigned int expected_children_count = 0;
Efl_Future *future;
actual_children_count = efl_model_future_then_u(future);
ck_assert_int_le(expected_children_count, actual_children_count);
}
-END_TEST
+EFL_END_TEST
void eldbus_test_eldbus_model_object(TCase *tc)
{
check_shutdown();
}
-START_TEST(properties_get)
+EFL_START_TEST(properties_get)
{
const Eina_Array *properties = NULL;
// ELDBUS_FDO_INTERFACE have no properties
// properties contains 2 properties, "Interfaces" and "Features".
//ck_assert_int_eq(0, eina_array_count(properties));
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_get)
+EFL_START_TEST(property_get)
{
// Nonexistent property must return ERROR
Efl_Future *future;
future = efl_model_property_get(dbus_proxy, "nonexistent");
check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_FOUND);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_set)
+EFL_START_TEST(property_set)
{
Eina_Value value;
Efl_Future *future;
check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_FOUND);
eina_value_flush(&value);
}
-END_TEST
+EFL_END_TEST
static void
_test_dbus_proxy_children_count(Eo *efl_model)
check_efl_model_children_count_ge(efl_model, 2);
}
-START_TEST(children_count)
+EFL_START_TEST(children_count)
{
_test_dbus_proxy_children_count(dbus_proxy);
}
-END_TEST
+EFL_END_TEST
-START_TEST(children_slice_get)
+EFL_START_TEST(children_slice_get)
{
check_efl_model_children_slice_get(dbus_proxy);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_add)
+EFL_START_TEST(child_add)
{
Eo *child;
child = efl_model_child_add(dbus_proxy);
ck_assert_ptr_eq(NULL, child);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_del)
+EFL_START_TEST(child_del)
{
unsigned int expected_children_count = 0;
Efl_Future *future;
ck_assert_int_le(expected_children_count, actual_children_count);
}
-END_TEST
+EFL_END_TEST
void eldbus_test_eldbus_model_proxy(TCase *tc)
{
check_shutdown();
}
-START_TEST(properties_get)
+EFL_START_TEST(properties_get)
{
const Eina_Array *properties = NULL;
properties = efl_model_properties_get(pong_signal);
const unsigned int actual_properties_count = eina_array_count(properties);
ck_assert_int_eq(expected_properties_count, actual_properties_count);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_get)
+EFL_START_TEST(property_get)
{
// Signal properties always have output direction
Efl_Future *future;
future = efl_model_property_get(pong_signal, "nonexistent");
check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_FOUND);
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_set)
+EFL_START_TEST(property_set)
{
// Signals have output arguments only. All returns error
Efl_Future *future;
future = efl_model_property_set(pong_signal, ARGUMENT_A, &dummy);
check_efl_model_future_error(future, NULL);
}
-END_TEST
+EFL_END_TEST
static void
_test_signal_children_count(Eo *efl_model)
check_efl_model_children_count_eq(efl_model, 0);
}
-START_TEST(children_count)
+EFL_START_TEST(children_count)
{
_test_signal_children_count(pong_signal);
}
-END_TEST
+EFL_END_TEST
-START_TEST(children_slice_get)
+EFL_START_TEST(children_slice_get)
{
Efl_Future *future;
future = efl_model_children_slice_get(pong_signal, 1, 1);
check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_SUPPORTED);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_add)
+EFL_START_TEST(child_add)
{
Eo *child;
child = efl_model_child_add(pong_signal);
ck_assert_ptr_eq(NULL, child);
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_del)
+EFL_START_TEST(child_del)
{
// efl_model_child_del always returns ERROR FIXME catch error
Eo *child = NULL;
efl_model_child_del(pong_signal, child);
}
-END_TEST
+EFL_END_TEST
-START_TEST(signals)
+EFL_START_TEST(signals)
{
Eldbus_Model_Method *ping_method = eldbus_model_method_from_proxy_get(fake_server_proxy, FAKE_SERVER_PING_METHOD_NAME);
ck_assert_ptr_ne(NULL, ping_method);
check_efl_model_property_int_eq(pong_signal, ARGUMENT_A, 100);
}
-END_TEST
+EFL_END_TEST
void eldbus_test_eldbus_model_signal(TCase *tc)
{
* @}
*/
-START_TEST(utc_eldbus_object_send_info_get_p)
+EFL_START_TEST(utc_eldbus_object_send_info_get_p)
{
is_success = EINA_FALSE;
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_object
* @}
*/
-START_TEST(utc_eldbus_introspect_p)
+EFL_START_TEST(utc_eldbus_introspect_p)
{
is_success = EINA_FALSE;
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_object
* @}
* @}
*/
-START_TEST(utc_eldbus_object_peer_p)
+EFL_START_TEST(utc_eldbus_object_peer_p)
{
const char *dbus_path = "/org/freedesktop/Test";
const char *bus_session = "org.freedesktop.Test";
eldbus_service_interface_unregister(iface);
eldbus_connection_unref(conn_server);
}
-END_TEST
+EFL_END_TEST
/**
*@}
* @}
*/
-START_TEST(utc_eldbus_pending_info_get_cancel_p)
+EFL_START_TEST(utc_eldbus_pending_info_get_cancel_p)
{
Eldbus_Pending *pending = _pending_connection_get();
ck_assert_ptr_ne(NULL, pending);
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
void
eldbus_test_eldbus_pending_cancel(TCase *tc)
* @}
*/
-START_TEST(utc_eldbus_pending_data_p)
+EFL_START_TEST(utc_eldbus_pending_data_p)
{
const char *bus = "org.freedesktop.DBus";
const char *path = "/org/freedesktop/DBus";
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
void
eldbus_test_eldbus_pending_data(TCase *tc)
* @}
*/
-START_TEST(utc_eldbus_proxy_info_get_call_p)
+EFL_START_TEST(utc_eldbus_proxy_info_get_call_p)
{
is_success = EINA_FALSE;
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_proxy
* @}
*/
-START_TEST(utc_eldbus_proxy_send_call_p)
+EFL_START_TEST(utc_eldbus_proxy_send_call_p)
{
is_success = EINA_FALSE;
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_proxy
* @}
*/
-START_TEST(utc_eldbus_proxy_send_and_block_p)
+EFL_START_TEST(utc_eldbus_proxy_send_and_block_p)
{
const int timeout = 1000;
is_success = EINA_FALSE;
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_proxy
* @}
*/
-START_TEST(utc_eldbus_proxy_data_p)
+EFL_START_TEST(utc_eldbus_proxy_data_p)
{
is_success = EINA_FALSE;
eldbus_object_unref(obj);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
*@}
* @}
* @}
*/
-START_TEST(utc_eldbus_signal_handler_add_p)
+EFL_START_TEST(utc_eldbus_signal_handler_add_p)
{
is_success_cb = EINA_FALSE;
eldbus_signal_handler_unref(signal_handler);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_signal_handler
* @}
* @}
*/
-START_TEST(utc_eldbus_signal_handler_del_p)
+EFL_START_TEST(utc_eldbus_signal_handler_del_p)
{
is_success_cb = EINA_FALSE;
eldbus_signal_handler_unref(signal_handler);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_signal_handler
* @}
* @}
*/
-START_TEST(utc_eldbus_signal_handler_get_p)
+EFL_START_TEST(utc_eldbus_signal_handler_get_p)
{
Eldbus_Connection *conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
ck_assert_ptr_ne(NULL, conn);
eldbus_signal_handler_unref(signal_handler);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_signal_handler
* @}
*/
-START_TEST(utc_eldbus_signal_handler_ref_unref_p)
+EFL_START_TEST(utc_eldbus_signal_handler_ref_unref_p)
{
is_success_cb = EINA_FALSE;
eldbus_message_unref(msg);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
* @addtogroup eldbus_signal_handler
* @}
*/
-START_TEST(utc_eldbus_signal_handler_free_cb_add_del_p)
+EFL_START_TEST(utc_eldbus_signal_handler_free_cb_add_del_p)
{
Eldbus_Connection *conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
ck_assert_ptr_ne(NULL, conn);
eldbus_connection_unref(conn);
}
-END_TEST
+EFL_END_TEST
/**
*@}
check_shutdown();
}
-START_TEST(properties_get)
+EFL_START_TEST(properties_get)
{
const Eina_Array *properties = efl_model_properties_get(fake_server_proxy);
ck_assert_ptr_ne(NULL, properties);
_teardown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(property_get)
+EFL_START_TEST(property_get)
{
check_efl_model_property_int_eq(fake_server_proxy, FAKE_SERVER_READONLY_PROPERTY, FAKE_SERVER_READONLY_PROPERTY_VALUE);
check_efl_model_property_int_eq(fake_server_proxy, FAKE_SERVER_READWRITE_PROPERTY, FAKE_SERVER_READWRITE_PROPERTY_VALUE);
_teardown();
}
-END_TEST
+EFL_END_TEST
static void
_check_property_set(const char *property_name, int expected_property_value, int *actual_property_value)
ck_assert_int_eq(expected_property_value, *actual_property_value);
}
-START_TEST(property_set)
+EFL_START_TEST(property_set)
{
_check_property_set(FAKE_SERVER_WRITEONLY_PROPERTY, 0x12345678, &fake_server_data.writeonly_property);
_check_property_set(FAKE_SERVER_READWRITE_PROPERTY, 0x76543210, &fake_server_data.readwrite_property);
_teardown();
}
-END_TEST
+EFL_END_TEST
static void
_test_fake_server_proxy_children_count(Eo *efl_model)
check_efl_model_children_count_eq(efl_model, 3);
}
-START_TEST(children_count)
+EFL_START_TEST(children_count)
{
_test_fake_server_proxy_children_count(fake_server_proxy);
_teardown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(children_slice_get)
+EFL_START_TEST(children_slice_get)
{
Eldbus_Model_Arguments *method1 = efl_model_nth_child_get(fake_server_proxy, 0);
Eldbus_Model_Arguments *method2 = efl_model_nth_child_get(fake_server_proxy, 1);
_teardown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_add)
+EFL_START_TEST(child_add)
{
Eo *child = efl_model_child_add(fake_server_proxy);
ck_assert_ptr_eq(NULL, child);
_teardown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(child_del)
+EFL_START_TEST(child_del)
{
// Tests that it is not possible to delete children
Efl_Future *future;
_teardown();
}
-END_TEST
+EFL_END_TEST
void eldbus_test_fake_server_eldbus_model_proxy(TCase *tc)
{
#include <algorithm>
#include <check.h>
-
+#include "../efl_check.h"
void eldbus_test_connection(TCase* tc);
void eldbus_test_client(TCase* tc);
efl_loop_quit(ev->object, eina_value_string_init("success"));
}
-START_TEST(efl_ui_test_init)
+EFL_START_TEST(efl_ui_test_init)
{
/* EFL_MAIN */
Eina_Value *ret__;
ecore_shutdown_ex();
ecore_shutdown();
}
-END_TEST
+EFL_END_TEST
void efl_ui_test(TCase *tc)
{
#include "elm_suite.h"
#include "Elementary.h"
-START_TEST (elm_code_file_load)
+EFL_START_TEST (elm_code_file_load)
{
char *path = TESTS_SRC_DIR "/testfile.txt";
char real[EINA_PATH_MAX];
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_file_load_lines)
+EFL_START_TEST (elm_code_file_load_lines)
{
char *path = TESTS_SRC_DIR "/testfile.txt";
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_file_load_blank_lines)
+EFL_START_TEST (elm_code_file_load_blank_lines)
{
char *path = TESTS_SRC_DIR "/testfile-withblanks.txt";
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_file_load_windows)
+EFL_START_TEST (elm_code_file_load_windows)
{
char *path = TESTS_SRC_DIR "/testfile-windows.txt";
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
static void _assert_line_content_eq(const char *content, Elm_Code_Line *line)
{
ck_assert_uint_eq(content[c], line->content[c]);
}
-START_TEST (elm_code_file_load_content)
+EFL_START_TEST (elm_code_file_load_content)
{
char *path = TESTS_SRC_DIR "/testfile.txt";
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_file_line_ending_unix)
+EFL_START_TEST (elm_code_file_line_ending_unix)
{
char *path = TESTS_SRC_DIR "/testfile.txt";
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_file_line_ending_windows)
+EFL_START_TEST (elm_code_file_line_ending_windows)
{
char *path = TESTS_SRC_DIR "/testfile-windows.txt";
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_file_test_load(TCase *tc)
{
#include "elm_suite.h"
#include "Elementary.h"
-START_TEST (elm_code_file_memory_lines)
+EFL_START_TEST (elm_code_file_memory_lines)
{
Elm_Code *code;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_file_memory_tokens)
+EFL_START_TEST (elm_code_file_memory_tokens)
{
Elm_Code_File *file;
Elm_Code_Line *line;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_file_test_memory(TCase *tc)
{
#include "elm_suite.h"
#include "Elementary.h"
-START_TEST (elm_code_create_test)
+EFL_START_TEST (elm_code_create_test)
{
Elm_Code *code;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_open_test)
+EFL_START_TEST (elm_code_open_test)
{
char *path = TESTS_SRC_DIR "/testfile.txt";
char realpath1[PATH_MAX], realpath2[PATH_MAX];
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_basic(TCase *tc)
free(str);
}
-START_TEST (elm_code_indent_whitespace_test)
+EFL_START_TEST (elm_code_indent_whitespace_test)
{
Elm_Code *code;
Elm_Code_File *file;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_indent_comments_test)
+EFL_START_TEST (elm_code_indent_comments_test)
{
Elm_Code *code;
Elm_Code_File *file;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_indent_simple_braces)
+EFL_START_TEST (elm_code_indent_simple_braces)
{
Elm_Code *code;
Elm_Code_File *file;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_indent_matching_braces)
+EFL_START_TEST (elm_code_indent_matching_braces)
{
Elm_Code_File *file;
Elm_Code_Line *line;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_indent_startswith_keyword)
+EFL_START_TEST (elm_code_indent_startswith_keyword)
{
Elm_Code_File *file;
Elm_Code *code;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_indent(TCase *tc)
{
#include "elm_suite.h"
#include "Elementary.h"
-START_TEST (elm_code_line_create_test)
+EFL_START_TEST (elm_code_line_create_test)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_line_token_count_test)
+EFL_START_TEST (elm_code_line_token_count_test)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_line_split_test)
+EFL_START_TEST (elm_code_line_split_test)
{
Elm_Code *code;
Elm_Code_File *file;
ck_assert_int_eq(5, newline->length);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_line(TCase *tc)
{
file_calls++;
}
-START_TEST (elm_code_parse_hook_memory_test)
+EFL_START_TEST (elm_code_parse_hook_memory_test)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_parse_hook_file_test)
+EFL_START_TEST (elm_code_parse_hook_file_test)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_parse_todo_test)
+EFL_START_TEST (elm_code_parse_todo_test)
{
Elm_Code *code;
Elm_Code_File *file;
ck_assert_int_eq(ELM_CODE_STATUS_TYPE_DEFAULT, line->status);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_parse(TCase *tc)
{
}
}
-START_TEST (elm_code_syntax_lookup)
+EFL_START_TEST (elm_code_syntax_lookup)
{
Elm_Code_Syntax *syntax;
syntax = elm_code_syntax_for_mime_get("text/unknown");
ck_assert(!syntax);
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_syntax_c)
+EFL_START_TEST (elm_code_syntax_c)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_syntax_scope_change_braces_test)
+EFL_START_TEST (elm_code_syntax_scope_change_braces_test)
{
Elm_Code_File *file;
Elm_Code_Line *line;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_syntax(TCase *tc)
{
#include "Elementary.h"
#include "elm_code_text.h"
-START_TEST (elm_code_text_get_test)
+EFL_START_TEST (elm_code_text_get_test)
{
Elm_Code *code;
Elm_Code_File *file;
ck_assert_strn_eq("test", str, len);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_text_insert_test)
+EFL_START_TEST (elm_code_text_insert_test)
{
Elm_Code *code;
Elm_Code_File *file;
ck_assert_strn_eq("testing", text, length);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_text_contains_test)
+EFL_START_TEST (elm_code_text_contains_test)
{
Elm_Code *code;
Elm_Code_File *file;
ck_assert_int_eq(EINA_TRUE, elm_code_line_text_contains(line, "..."));
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_text_strpos_test)
+EFL_START_TEST (elm_code_text_strpos_test)
{
Elm_Code *code;
Elm_Code_File *file;
ck_assert_int_eq(13, elm_code_line_text_strpos(line, "...", 0));
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_text_newline_position_test)
+EFL_START_TEST (elm_code_text_newline_position_test)
{
short nllen;
const char *unixtext = "a test\nwith newline";
ck_assert_int_eq(2, nllen);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_text_is_whitespace_test)
+EFL_START_TEST (elm_code_text_is_whitespace_test)
{
const char *text;
ck_assert_int_eq(0, elm_code_text_is_whitespace(text, strlen(text)));
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_text(TCase *tc)
{
#undef DBG
#define DBG(...) do { } while (0);
-START_TEST (elm_code_widget_construct)
+EFL_START_TEST (elm_code_widget_construct)
{
Elm_Code *code;
Elm_Code_Widget *widget;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_widget_construct_nocode)
+EFL_START_TEST (elm_code_widget_construct_nocode)
{
Elm_Code_Widget *widget;
Evas_Object *win;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_widget_position)
+EFL_START_TEST (elm_code_widget_position)
{
Elm_Code *code;
Elm_Code_Widget *widget;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_widget(TCase *tc)
{
#include "elm_code_widget_private.h"
#include "elm_code_widget_selection.h"
-START_TEST (elm_code_test_widget_selection_set)
+EFL_START_TEST (elm_code_test_widget_selection_set)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_normalized_get)
+EFL_START_TEST (elm_code_test_widget_selection_normalized_get)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_text_get)
+EFL_START_TEST (elm_code_test_widget_selection_text_get)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_reverse_text_get)
+EFL_START_TEST (elm_code_test_widget_selection_reverse_text_get)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_text_get_twoline)
+EFL_START_TEST (elm_code_test_widget_selection_text_get_twoline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_reverse_text_get_twoline)
+EFL_START_TEST (elm_code_test_widget_selection_reverse_text_get_twoline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_text_get_multiline)
+EFL_START_TEST (elm_code_test_widget_selection_text_get_multiline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_reverse_text_get_multiline)
+EFL_START_TEST (elm_code_test_widget_selection_reverse_text_get_multiline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_delete)
+EFL_START_TEST (elm_code_test_widget_selection_delete)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_reverse_delete)
+EFL_START_TEST (elm_code_test_widget_selection_reverse_delete)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_delete_twoline)
+EFL_START_TEST (elm_code_test_widget_selection_delete_twoline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_reverse_delete_twoline)
+EFL_START_TEST (elm_code_test_widget_selection_reverse_delete_twoline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_delete_multiline)
+EFL_START_TEST (elm_code_test_widget_selection_delete_multiline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_reverse_delete_multiline)
+EFL_START_TEST (elm_code_test_widget_selection_reverse_delete_multiline)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_select_line)
+EFL_START_TEST (elm_code_test_widget_selection_select_line)
{
Elm_Code *code;
Elm_Code_File *file;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_select_word)
+EFL_START_TEST (elm_code_test_widget_selection_select_word)
{
Elm_Code *code;
Elm_Code_File *file;
free(selection);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_select_word_punctuation)
+EFL_START_TEST (elm_code_test_widget_selection_select_word_punctuation)
{
Elm_Code *code;
Elm_Code_File *file;
free(selection);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_selection_select_word_symbols)
+EFL_START_TEST (elm_code_test_widget_selection_select_word_symbols)
{
Elm_Code *code;
Elm_Code_File *file;
free(selection);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_widget_selection(TCase *tc)
{
#include "elm_suite.h"
#include "Elementary.h"
-START_TEST (elm_code_test_widget_text_tab_width)
+EFL_START_TEST (elm_code_test_widget_text_tab_width)
{
Elm_Code *code;
Elm_Code_Widget *widget;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_text_position)
+EFL_START_TEST (elm_code_test_widget_text_position)
{
Elm_Code *code;
Elm_Code_File *file;
ck_assert_int_eq(1, elm_code_widget_line_text_position_for_column_get(widget, line, 7));
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_widget_text(TCase *tc)
{
#include "Elementary.h"
#include "elm_code_widget_private.h"
-START_TEST (elm_code_test_widget_undo_text_insert)
+EFL_START_TEST (elm_code_test_widget_undo_text_insert)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_code_test_widget_undo_text_insert_multiple)
+EFL_START_TEST (elm_code_test_widget_undo_text_insert_multiple)
{
Elm_Code *code;
Elm_Code_File *file;
elm_code_free(code);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_code_test_widget_undo(TCase *tc)
{
#include <check.h>
#include "elm_test_helper.h"
-
+#include "../efl_check.h"
void elm_test_init(TCase *tc);
void elm_test_config(TCase *tc);
void elm_test_check(TCase *tc);
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_actionslider_legacy_type_check)
+EFL_START_TEST (elm_actionslider_legacy_type_check)
{
Evas_Object *win, *actionslider;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *actionslider;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_actionslider(TCase *tc)
{
evas_object_show(g_win);
}
-START_TEST (test_efl_access_app_obj_name_get)
+EFL_START_TEST (test_efl_access_app_obj_name_get)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(root);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_i18n_name_get)
+EFL_START_TEST (test_efl_access_i18n_name_get)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_i18n_name_set)
+EFL_START_TEST (test_efl_access_i18n_name_set)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_role_get)
+EFL_START_TEST (test_efl_access_role_get)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(root);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_role_set)
+EFL_START_TEST (test_efl_access_role_set)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_role_name_get)
+EFL_START_TEST (test_efl_access_role_name_get)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(root);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_localized_role_name_get)
+EFL_START_TEST (test_efl_access_localized_role_name_get)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(root);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_description_set)
+EFL_START_TEST (test_efl_access_description_set)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(root);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Test if initial description value is NULL */
-START_TEST (test_efl_access_description_get)
+EFL_START_TEST (test_efl_access_description_get)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_children_and_parent)
+EFL_START_TEST (test_efl_access_children_and_parent)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(root);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_children_and_parent2)
+EFL_START_TEST (test_efl_access_children_and_parent2)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(root);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Initial value of translation domain should be NULL */
-START_TEST (test_efl_access_translation_domain_get)
+EFL_START_TEST (test_efl_access_translation_domain_get)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_translation_domain_set)
+EFL_START_TEST (test_efl_access_translation_domain_set)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_relationship_append)
+EFL_START_TEST (test_efl_access_relationship_append)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_relationship_remove)
+EFL_START_TEST (test_efl_access_relationship_remove)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_access_relation_set_free(set);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (test_efl_access_relationships_clear)
+EFL_START_TEST (test_efl_access_relationships_clear)
{
Efl_Access_Relation_Set set;
Efl_Access_Relation *rel;
efl_access_relation_set_free(set);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_atspi(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_bg_legacy_type_check)
+EFL_START_TEST (elm_bg_legacy_type_check)
{
Evas_Object *win, *bg;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_bg_legacy_file_set_get_check)
+EFL_START_TEST (elm_bg_legacy_file_set_get_check)
{
Evas_Object *win, *bg;
const char *file = NULL, *key = NULL;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_bg(TCase *tc EINA_UNUSED)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_box_legacy_type_check)
+EFL_START_TEST (elm_box_legacy_type_check)
{
Evas_Object *win, *box;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *box;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_box(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_bubble_legacy_type_check)
+EFL_START_TEST (elm_bubble_legacy_type_check)
{
Evas_Object *win, *bubble;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *bubble;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_bubble(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_button_legacy_type_check)
+EFL_START_TEST (elm_button_legacy_type_check)
{
Evas_Object *win, *button;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *button;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_interfaces_check)
+EFL_START_TEST (elm_atspi_interfaces_check)
{
Evas_Object *win, *button;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_button(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_calendar_legacy_type_check)
+EFL_START_TEST (elm_calendar_legacy_type_check)
{
Evas_Object *win, *calendar;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *calendar;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_calendar(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_check_legacy_type_check)
+EFL_START_TEST (elm_check_legacy_type_check)
{
Evas_Object *win, *check;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_check_onoff_text)
+EFL_START_TEST (elm_check_onoff_text)
{
Evas_Object *win, *check;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_check_state)
+EFL_START_TEST (elm_check_state)
{
Evas_Object *win, *check;
Eina_Bool state = EINA_TRUE;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *check;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_check(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_clock_legacy_type_check)
+EFL_START_TEST (elm_clock_legacy_type_check)
{
Evas_Object *win, *clock;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *clk;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_clock(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_colorselector_legacy_type_check)
+EFL_START_TEST (elm_colorselector_legacy_type_check)
{
Evas_Object *win, *colorselector;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_colorselector_palette)
+EFL_START_TEST (elm_colorselector_palette)
{
Evas_Object *win, *c;
unsigned int palette_cnt;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *c;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_colorselector(TCase *tc)
{
#include <stdbool.h>
typedef unsigned int uint;
-START_TEST (elm_config_eoapi)
+EFL_START_TEST (elm_config_eoapi)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_config_win)
+EFL_START_TEST (elm_config_win)
{
char *args[] = { "exe" };
elm_init(1, args);
efl_del(win);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
static inline Eina_Bool
_eina_list_string_has(const Eina_List *list, const char *str)
return EINA_FALSE;
}
-START_TEST (elm_config_profiles)
+EFL_START_TEST (elm_config_profiles)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_config(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_conformant_legacy_type_check)
+EFL_START_TEST (elm_conformant_legacy_type_check)
{
Evas_Object *win, *conformant;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *conformant;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_conformant(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_ctxpopup_legacy_type_check)
+EFL_START_TEST (elm_ctxpopup_legacy_type_check)
{
Evas_Object *win, *ctxpopup;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *ctxpopup;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_ctxpopup(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_datetime_legacy_type_check)
+EFL_START_TEST (elm_datetime_legacy_type_check)
{
Evas_Object *win, *datetime;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *datetime;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_datetime(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_dayselector_legacy_type_check)
+EFL_START_TEST (elm_dayselector_legacy_type_check)
{
Evas_Object *win, *dayselector;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *dayselector;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_dayselector(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_diskselector_legacy_type_check)
+EFL_START_TEST (elm_diskselector_legacy_type_check)
{
Evas_Object *win, *diskselector;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *diskselector;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_diskselector(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_entry_legacy_type_check)
+EFL_START_TEST (elm_entry_legacy_type_check)
{
Evas_Object *win, *entry;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_del)
+EFL_START_TEST (elm_entry_del)
{
Evas_Object *win, *entry;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void
_dummy_cb(void *data EINA_UNUSED, Eo *obj EINA_UNUSED,
{
}
-START_TEST (elm_entry_signal_callback)
+EFL_START_TEST (elm_entry_signal_callback)
{
Evas_Object *win, *entry;
void *data;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_char_get)
+EFL_START_TEST (elm_entry_atspi_text_char_get)
{
Evas_Object *win, *entry;
Eina_Unicode *expected;
free(expected);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_char_count)
+EFL_START_TEST (elm_entry_atspi_text_char_count)
{
Evas_Object *win, *entry;
int val;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_string_get_char)
+EFL_START_TEST (elm_entry_atspi_text_string_get_char)
{
Evas_Object *win, *entry;
char *val;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_string_get_word)
+EFL_START_TEST (elm_entry_atspi_text_string_get_word)
{
Evas_Object *win, *entry;
char *val;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_string_get_paragraph)
+EFL_START_TEST (elm_entry_atspi_text_string_get_paragraph)
{
Evas_Object *win, *entry;
char *val;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_string_get_line)
+EFL_START_TEST (elm_entry_atspi_text_string_get_line)
{
Evas_Object *win, *entry;
char *val;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_text_get)
+EFL_START_TEST (elm_entry_atspi_text_text_get)
{
Evas_Object *win, *entry;
char *val;
if (val) free(val);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_entry_atspi_text_selections)
+EFL_START_TEST (elm_entry_atspi_text_selections)
{
Evas_Object *win, *entry;
int val, start, end;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *entry;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_entry(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_fileselector_legacy_type_check)
+EFL_START_TEST (elm_fileselector_legacy_type_check)
{
Evas_Object *win, *fileselector;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *fileselector;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_ready_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
*ret = EINA_TRUE;
}
-START_TEST (elm_fileselector_selected)
+EFL_START_TEST (elm_fileselector_selected)
{
Evas_Object *win, *fileselector;
Eina_Tmpstr *tmp_path;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_fileselector(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_fileselector_button_legacy_type_check)
+EFL_START_TEST (elm_fileselector_button_legacy_type_check)
{
Evas_Object *win, *fs_button;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *fs_button;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_fileselector_button(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_fileselector_entry_legacy_type_check)
+EFL_START_TEST (elm_fileselector_entry_legacy_type_check)
{
Evas_Object *win, *fileselector_entry;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *fs_entry;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_fileselector_entry(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_flip_legacy_type_check)
+EFL_START_TEST (elm_flip_legacy_type_check)
{
Evas_Object *win, *flip;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *flip;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_flip(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_flipselector_legacy_type_check)
+EFL_START_TEST (elm_flipselector_legacy_type_check)
{
Evas_Object *win, *flipselector;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *flipselector;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_flipselector(TCase *tc)
{
#include "elm_test_focus_common.h"
-START_TEST(focus_unregister_twice)
+EFL_START_TEST(focus_unregister_twice)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(focus_register_twice)
+EFL_START_TEST(focus_register_twice)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(pos_check)
+EFL_START_TEST(pos_check)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *middle, *east, *west, *north, *south, *root;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
_equal_set(Eina_List *elems, Efl_Ui_Focus_Object *lst[])
return EINA_TRUE;
}
-START_TEST(pos_check2)
+EFL_START_TEST(pos_check2)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Relations *rel;
elm_shutdown();
}
-END_TEST
-START_TEST(redirect)
+EFL_END_TEST
+EFL_START_TEST(redirect)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(border_check)
+EFL_START_TEST(border_check)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *middle, *east, *west, *north, *south, *root;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(logical_chain)
+EFL_START_TEST(logical_chain)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *lroot;
}
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(finalize_check)
+EFL_START_TEST(finalize_check)
{
Efl_Ui_Focus_Manager *m;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(redirect_param)
+EFL_START_TEST(redirect_param)
{
Efl_Ui_Focus_Manager *m, *m2;
efl_del(m2);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(invalid_args_check)
+EFL_START_TEST(invalid_args_check)
{
Efl_Ui_Focus_Manager *m;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(order_check)
+EFL_START_TEST(order_check)
{
Efl_Ui_Focus_Manager *m;
Eina_List *order = NULL;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(logical_shift)
+EFL_START_TEST(logical_shift)
{
Efl_Ui_Focus_Manager *m;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(root_redirect_chain)
+EFL_START_TEST(root_redirect_chain)
{
Efl_Ui_Focus_Manager *m, *m2;
efl_del(m2);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(root_redirect_chain_unset)
+EFL_START_TEST(root_redirect_chain_unset)
{
Efl_Ui_Focus_Manager *m, *m2, *m3, *m4;
efl_del(m4);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
static Efl_Ui_Focus_Manager_Calc*
_recursive_triangle_manager(int recusion_depth, Efl_Ui_Focus_Object **most_right, Efl_Ui_Focus_Object **most_left, Eina_List **managers)
return manager;
}
-START_TEST(first_touch_check)
+EFL_START_TEST(first_touch_check)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *most_left, *most_right;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_request_subchild_empty)
+EFL_START_TEST(test_request_subchild_empty)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_request_subchild_one_element)
+EFL_START_TEST(test_request_subchild_one_element)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_request_subchild_child_alongside)
+EFL_START_TEST(test_request_subchild_child_alongside)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1, *c2;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_request_subchild_child_logical_regular)
+EFL_START_TEST(test_request_subchild_child_logical_regular)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1, *c2;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_request_subchild_child_regular_regular)
+EFL_START_TEST(test_request_subchild_child_regular_regular)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1, *c2;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_unregister_last_focused_no_history)
+EFL_START_TEST(test_unregister_last_focused_no_history)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1, *c2, *c3;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_unregister_last_focused)
+EFL_START_TEST(test_unregister_last_focused)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1, *c2, *c3;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_unregister_last_focused_no_child)
+EFL_START_TEST(test_unregister_last_focused_no_child)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(test_pop_history_element)
+EFL_START_TEST(test_pop_history_element)
{
Efl_Ui_Focus_Manager *m;
Efl_Ui_Focus_Object *root, *c1, *c2, *c3;
efl_del(m);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_focus(TCase *tc)
{
*r = root;
}
-START_TEST(correct_register)
+EFL_START_TEST(correct_register)
{
Eina_List *set1 = NULL;
Efl_Ui_Focus_Object *root;
efl_del(manager);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(correct_unregister)
+EFL_START_TEST(correct_unregister)
{
Eina_List *set = NULL;
Efl_Ui_Focus_Object *root;
efl_del(child3);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(correct_un_register)
+EFL_START_TEST(correct_un_register)
{
Eina_List *set_add = NULL, *set_del = NULL;
Efl_Ui_Focus_Object *root;
efl_del(child3);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_focus_sub(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_frame_legacy_type_check)
+EFL_START_TEST (elm_frame_legacy_type_check)
{
Evas_Object *win, *frame;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *frame;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_frame(TCase *tc)
{
#include "elm_suite.h"
#include "elm_test_helper.h"
-START_TEST (elm_gengrid_legacy_type_check)
+EFL_START_TEST (elm_gengrid_legacy_type_check)
{
Evas_Object *win, *gengrid;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *gengrid;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
// Temporary commnted since gengrid fields_update function do not call content callbacks
// (different behaviour then genlist - which calls)
* Validate if gengrid implementation properly reset AT-SPI parent to Elm_Gengrid_Item
* from Elm_Gengrid
*/
-START_TEST(elm_atspi_children_parent)
+EFL_START_TEST(elm_atspi_children_parent)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void elm_test_gengrid(TCase *tc)
ck_assert_ptr_eq(it, git);
}
-START_TEST (elm_genlist_group)
+EFL_START_TEST (elm_genlist_group)
{
const char *type;
Elm_Object_Item *git;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_genlist_legacy_type_check)
+EFL_START_TEST (elm_genlist_legacy_type_check)
{
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void test_init(void)
{
genlist = elm_genlist_add(win);
}
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
test_init();
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(elm_atspi_children_get1)
+EFL_START_TEST(elm_atspi_children_get1)
{
test_init();
Eina_List *children;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(elm_atspi_children_get2)
+EFL_START_TEST(elm_atspi_children_get2)
{
test_init();
Eina_List *children;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_children_changed_cb(void *data EINA_UNUSED, const Efl_Event *event)
counter++;
}
-START_TEST(elm_atspi_children_events_add)
+EFL_START_TEST(elm_atspi_children_events_add)
{
test_init();
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(elm_atspi_children_events_del1)
+EFL_START_TEST(elm_atspi_children_events_del1)
{
test_init();
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(elm_atspi_children_events_del2)
+EFL_START_TEST(elm_atspi_children_events_del2)
{
test_init();
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_genlist(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_glview_legacy_type_check)
+EFL_START_TEST (elm_glview_legacy_type_check)
{
Evas_Object *win, *glview;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *glview;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_glview(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_grid_legacy_type_check)
+EFL_START_TEST (elm_grid_legacy_type_check)
{
Evas_Object *win, *grid;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *grid;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_grid(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_hover_legacy_type_check)
+EFL_START_TEST (elm_hover_legacy_type_check)
{
Evas_Object *win, *hover;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *hover;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_hover(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_hoversel_legacy_type_check)
+EFL_START_TEST (elm_hoversel_legacy_type_check)
{
Evas_Object *win, *hoversel;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *hoversel;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_hoversel(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_icon_legacy_type_check)
+EFL_START_TEST (elm_icon_legacy_type_check)
{
Evas_Object *win, *icon;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *icon;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_icon(TCase *tc)
{
int success;
};
-START_TEST (elm_image_legacy_type_check)
+EFL_START_TEST (elm_image_legacy_type_check)
{
Evas_Object *win, *image;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *image;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_async_error_cb(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
return ECORE_CALLBACK_CANCEL;
}
-START_TEST (elm_image_async_path)
+EFL_START_TEST (elm_image_async_path)
{
Evas_Object *win, *image;
Eina_Bool ok;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_image_async_mmap)
+EFL_START_TEST (elm_image_async_mmap)
{
Evas_Object *win, *image;
Eina_Bool ok;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (efl_ui_image_icon)
+EFL_START_TEST (efl_ui_image_icon)
{
Evas_Object *win, *image;
Eina_Bool ok;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_image(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_index_legacy_type_check)
+EFL_START_TEST (elm_index_legacy_type_check)
{
Evas_Object *win, *index;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *idx;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_index(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_main)
+EFL_START_TEST (elm_main)
{
char *args[] = { "exe" };
ck_assert(elm_init(1, args) == 1);
ck_assert(ecore_init() == 1);
ck_assert(ecore_shutdown() == 0);
}
-END_TEST
+EFL_END_TEST
void elm_test_init(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_inwin_legacy_type_check)
+EFL_START_TEST (elm_inwin_legacy_type_check)
{
Evas_Object *win, *inwin;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *inwin;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_inwin(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_label_legacy_type_check)
+EFL_START_TEST (elm_label_legacy_type_check)
{
Evas_Object *win, *label;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *label;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_label(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_layout_legacy_type_check)
+EFL_START_TEST (elm_layout_legacy_type_check)
{
Evas_Object *win, *layout;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(elm_atspi_role_get)
+EFL_START_TEST(elm_atspi_role_get)
{
Evas_Object *win, *layout;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(elm_layout_swallows)
+EFL_START_TEST(elm_layout_swallows)
{
char buf[PATH_MAX];
Evas_Object *win, *ly, *bt, *bt2;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(elm_layout_model_connect)
+EFL_START_TEST(elm_layout_model_connect)
{
char buf[PATH_MAX];
Evas_Object *win, *ly;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_layout(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_list_legacy_type_check)
+EFL_START_TEST (elm_list_legacy_type_check)
{
Evas_Object *win, *list;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
#if 0
// Skip following tests until Elm_Widget_Item will migrate to Eo infrastructure
// and following features can be implemented
-START_TEST (elm_list_atspi_selection_selected_children_count_get)
+EFL_START_TEST (elm_list_atspi_selection_selected_children_count_get)
{
Evas_Object *win, *list;
Elm_Object_Item *item;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_list_atspi_selection_child_select)
+EFL_START_TEST (elm_list_atspi_selection_child_select)
{
Evas_Object *win, *list;
Elm_Object_Item *item;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_list_atspi_selection_selected_child_deselect)
+EFL_START_TEST (elm_list_atspi_selection_selected_child_deselect)
{
Evas_Object *win, *list;
Elm_Object_Item *item;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_list_atspi_selection_is_child_selected)
+EFL_START_TEST (elm_list_atspi_selection_is_child_selected)
{
Evas_Object *win, *list;
Elm_Object_Item *item;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_list_atspi_selection_all_children_select)
+EFL_START_TEST (elm_list_atspi_selection_all_children_select)
{
Evas_Object *win, *list;
Elm_Object_Item *item1, *item2;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_list_atspi_selection_clear)
+EFL_START_TEST (elm_list_atspi_selection_clear)
{
Evas_Object *win, *list;
Elm_Object_Item *item1, *item2;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_list_atspi_selection_child_deselect)
+EFL_START_TEST (elm_list_atspi_selection_child_deselect)
{
Evas_Object *win, *list;
Elm_Object_Item *item;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *list;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
/**
* Validate if genlist implementation properly reset parent to Elm_Genlist_Item
* from Elm_Genlist
*/
-START_TEST(elm_atspi_children_parent)
+EFL_START_TEST(elm_atspi_children_parent)
{
Efl_Access *parent;
Elm_Object_Item *it;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_list(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_map_legacy_type_check)
+EFL_START_TEST (elm_map_legacy_type_check)
{
Evas_Object *win, *map;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *map;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_map(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_mapbuf_legacy_type_check)
+EFL_START_TEST (elm_mapbuf_legacy_type_check)
{
Evas_Object *win, *mapbuf;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *mapbuf;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_mapbuf(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_menu_legacy_type_check)
+EFL_START_TEST (elm_menu_legacy_type_check)
{
Evas_Object *win, *menu;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *menu;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_menu(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_multibuttonentry_legacy_type_check)
+EFL_START_TEST (elm_multibuttonentry_legacy_type_check)
{
Evas_Object *win, *multibuttonentry;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *multibuttonentry;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_multibuttonentry(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_naviframe_legacy_type_check)
+EFL_START_TEST (elm_naviframe_legacy_type_check)
{
Evas_Object *win, *naviframe;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *naviframe;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_naviframe(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_notify_legacy_type_check)
+EFL_START_TEST (elm_notify_legacy_type_check)
{
Evas_Object *win, *notify;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *notify;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_notify(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_panel_legacy_type_check)
+EFL_START_TEST (elm_panel_legacy_type_check)
{
Evas_Object *win, *panel;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *panel;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_panel(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_panes_legacy_type_check)
+EFL_START_TEST (elm_panes_legacy_type_check)
{
Evas_Object *win, *panes;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *panes;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_panes(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_photo_legacy_type_check)
+EFL_START_TEST (elm_photo_legacy_type_check)
{
Evas_Object *win, *photo;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *photo;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_photo(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_photocam_legacy_type_check)
+EFL_START_TEST (elm_photocam_legacy_type_check)
{
Evas_Object *win, *photocam;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *photocam;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (efl_ui_image_zoomable_icon)
+EFL_START_TEST (efl_ui_image_zoomable_icon)
{
Evas_Object *win, *img_zoomable;
Eina_Bool ok;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_photocam(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_player_legacy_type_check)
+EFL_START_TEST (elm_player_legacy_type_check)
{
Evas_Object *win, *player;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *player;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_player(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_plug_legacy_type_check)
+EFL_START_TEST (elm_plug_legacy_type_check)
{
Evas_Object *win, *plug;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *plug;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_plug(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_popup_legacy_type_check)
+EFL_START_TEST (elm_popup_legacy_type_check)
{
Evas_Object *win, *popup;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *popup;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_popup(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_prefs_legacy_type_check)
+EFL_START_TEST (elm_prefs_legacy_type_check)
{
Evas_Object *win, *prefs;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
#if 0
Evas_Object *win, *prefs;
elm_shutdown();
#endif
}
-END_TEST
+EFL_END_TEST
void elm_test_prefs(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_progressbar_legacy_type_check)
+EFL_START_TEST (elm_progressbar_legacy_type_check)
{
Evas_Object *win, *progressbar;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *progressbar;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_progressbar(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_radio_legacy_type_check)
+EFL_START_TEST (elm_radio_legacy_type_check)
{
Evas_Object *win, *radio;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *radio;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_radio(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_scroller_legacy_type_check)
+EFL_START_TEST (elm_scroller_legacy_type_check)
{
Evas_Object *win, *scroller;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *scroller;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_scroller(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_segment_control_legacy_type_check)
+EFL_START_TEST (elm_segment_control_legacy_type_check)
{
Evas_Object *win, *segment_control;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *segmentcontrol;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_segmentcontrol(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_separator_legacy_type_check)
+EFL_START_TEST (elm_separator_legacy_type_check)
{
Evas_Object *win, *separator;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *separator;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_separator(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_slider_legacy_type_check)
+EFL_START_TEST (elm_slider_legacy_type_check)
{
Evas_Object *win, *slider;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *slider;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_slider(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_slideshow_legacy_type_check)
+EFL_START_TEST (elm_slideshow_legacy_type_check)
{
Evas_Object *win, *slideshow;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *slideshow;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_slideshow(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_spinner_legacy_type_check)
+EFL_START_TEST (elm_spinner_legacy_type_check)
{
Evas_Object *win, *spinner;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *spinner;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_spinner(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_table_legacy_type_check)
+EFL_START_TEST (elm_table_legacy_type_check)
{
Evas_Object *win, *table;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *table;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_table(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_thumb_legacy_type_check)
+EFL_START_TEST (elm_thumb_legacy_type_check)
{
Evas_Object *win, *thumb;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *thumb;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_thumb(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_toolbar_legacy_type_check)
+EFL_START_TEST (elm_toolbar_legacy_type_check)
{
Evas_Object *win, *toolbar;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *toolbar;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_toolbar(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_video_legacy_type_check)
+EFL_START_TEST (elm_video_legacy_type_check)
{
Evas_Object *win, *video;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *video;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_video(TCase *tc)
{
#include <Elementary.h>
#include "elm_suite.h"
-START_TEST (elm_web_legacy_type_check)
+EFL_START_TEST (elm_web_legacy_type_check)
{
Evas_Object *win, *web;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win, *web;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_web(TCase *tc)
{
return EINA_FALSE;
}
-START_TEST (elm_win_legacy_type_check)
+EFL_START_TEST (elm_win_legacy_type_check)
{
Evas_Object *win;
const char *type;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_role_get)
+EFL_START_TEST (elm_atspi_role_get)
{
Evas_Object *win;
Efl_Access_Role role;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_atspi_component_screen_position)
+EFL_START_TEST (elm_atspi_component_screen_position)
{
Eina_Bool ret;
int x, y;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_win_autohide)
+EFL_START_TEST (elm_win_autohide)
{
char *args[] = { "exe" };
elm_init(1, args);
}
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_win_policy_quit_last_window_hidden)
+EFL_START_TEST (elm_win_policy_quit_last_window_hidden)
{
char *args[] = { "exe" };
elm_init(1, args);
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST (elm_win_autohide_and_policy_quit_last_window_hidden)
+EFL_START_TEST (elm_win_autohide_and_policy_quit_last_window_hidden)
{
char *args[] = { "exe" };
elm_init(1, args);
}
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
/* a very lax definition of == for doubles */
#define VALEQ(a, b) ((fabs((a) - (b))) <= 0.001)
return ECORE_CALLBACK_DONE;
}
-START_TEST (efl_ui_win_multi_touch_inputs)
+EFL_START_TEST (efl_ui_win_multi_touch_inputs)
{
Eina_Bool fail_flag = EINA_FALSE;
Eo *win;
elm_shutdown();
}
-END_TEST
+EFL_END_TEST
void elm_test_win(TCase *tc)
{
/* Test the init and shutdown pathes only. Good to do that as we don't set up
* other things and already triggered problems with this.
*/
-START_TEST(elocation_test_init)
+EFL_START_TEST(elocation_test_init)
{
Eina_Bool ret;
elocation_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Basic address object testing. Creating and freeing the object */
-START_TEST(elocation_test_address_object)
+EFL_START_TEST(elocation_test_address_object)
{
Eina_Bool ret;
Elocation_Address *address = NULL;
elocation_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Basic position object testing. Creating and freeing the object */
-START_TEST(elocation_test_position_object)
+EFL_START_TEST(elocation_test_position_object)
{
Eina_Bool ret;
Elocation_Position *position = NULL;
elocation_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Basic testing for the various functions of the GeoCode API */
static int cb_count = 0;
return ECORE_CALLBACK_DONE;
}
-START_TEST(elocation_test_api_geocode)
+EFL_START_TEST(elocation_test_api_geocode)
{
Eina_Bool ret;
Elocation_Position *position = NULL;
elocation_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Basic testing for position API */
-START_TEST(elocation_test_api_position)
+EFL_START_TEST(elocation_test_api_position)
{
Eina_Bool ret;
Elocation_Position *position = NULL;
elocation_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Basic testing for address API */
-START_TEST(elocation_test_api_address)
+EFL_START_TEST(elocation_test_api_address)
{
Eina_Bool ret;
Elocation_Address *address = NULL;
elocation_shutdown();
}
-END_TEST
+EFL_END_TEST
/* Basic testing for status API */
-START_TEST(elocation_test_api_status)
+EFL_START_TEST(elocation_test_api_status)
{
Eina_Bool ret;
int status = 0;
elocation_shutdown();
}
-END_TEST
+EFL_END_TEST
Suite *
elocation_suite(void)
# define _ELPUT_SUITE_H
# include <check.h>
-
+#include "../efl_check.h"
void elput_test_elput(TCase *tc);
#endif
#include "elput_suite.h"
-START_TEST(elput_test_elput_init)
+EFL_START_TEST(elput_test_elput_init)
{
int ret;
ret = elput_shutdown();
fail_if(ret != 0);
}
-END_TEST
+EFL_END_TEST
void elput_test_elput(TCase *tc)
{
#include "elua_suite.h"
-START_TEST(elua_api)
+EFL_START_TEST(elua_api)
{
Elua_State *st;
lua_State *lst;
elua_shutdown();
}
-END_TEST
+EFL_END_TEST
void elua_lib_test(TCase *tc)
{
#define _ELUA_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void elua_lib_test(TCase *tc);
#endif /* _ELUA_SUITE_H */
#define _EMILE_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void emile_test_base(TCase *tc);
void emile_test_base64(TCase *tc);
#include "emile_suite.h"
-START_TEST(emile_test_init)
+EFL_START_TEST(emile_test_init)
{
fail_if(emile_init() <= 0);
fail_if(emile_shutdown() != 0);
}
-END_TEST
+EFL_END_TEST
void emile_test_base(TCase *tc)
{
{ "abc123!?$*&()'-=@~", "YWJjMTIzIT8kKiYoKSctPUB+", "YWJjMTIzIT8kKiYoKSctPUB-", 18 }
};
-START_TEST(emile_test_base64_normal)
+EFL_START_TEST(emile_test_base64_normal)
{
Eina_Binbuf *buffer, *decoded;
Eina_Strbuf *str, *encoded;
eina_strbuf_reset(str);
fail_if(decoded);
}
-END_TEST
+EFL_END_TEST
-START_TEST(emile_test_base64_url)
+EFL_START_TEST(emile_test_base64_url)
{
Eina_Binbuf *buffer, *decoded;
Eina_Strbuf *str, *encoded;
decoded = emile_base64url_decode(str);
fail_if(memcmp(eina_binbuf_string_get(decoded), "Man", 3));
}
-END_TEST
+EFL_END_TEST
void
emile_test_base64(TCase *tc)
#define _EO_SUITE_H
#include <check.h>
-
+#include "../../efl_check.h"
void eo_test_init(TCase *tc);
void eo_test_general(TCase *tc);
void eo_test_class_errors(TCase *tc);
static struct log_ctx ctx;
-START_TEST(eo_pure_virtual_fct_call)
+EFL_START_TEST(eo_pure_virtual_fct_call)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_api_not_implemented_call)
+EFL_START_TEST(eo_api_not_implemented_call)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_op_not_found_in_super)
+EFL_START_TEST(eo_op_not_found_in_super)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
//the fallback code that will be called
EFL_DEFINE_CLASS(simple_errorcase_class_get, &errorcase_class_desc, EO_CLASS, NULL)
-START_TEST(eo_fallbackcall_execute)
+EFL_START_TEST(eo_fallbackcall_execute)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
void eo_test_call_errors(TCase *tc)
{
return efl_class_functions_set(klass2, &ops, NULL);
}
-START_TEST(efl_destructor_unref)
+EFL_START_TEST(efl_destructor_unref)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_destructor_double_del)
+EFL_START_TEST(efl_destructor_double_del)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
void eo_test_class_behaviour_errors(TCase *tc)
{
static struct log_ctx ctx;
-START_TEST(eo_inherit_errors)
+EFL_START_TEST(eo_inherit_errors)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_inconsistent_mro)
+EFL_START_TEST(eo_inconsistent_mro)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static void _stub_class_constructor(Efl_Class *klass EINA_UNUSED) {}
-START_TEST(eo_bad_interface)
+EFL_START_TEST(eo_bad_interface)
{
efl_object_init();
eina_log_print_cb_set(eo_test_safety_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static void _null_fct(Eo *eo_obj EINA_UNUSED, void *d EINA_UNUSED) { }
void null_fct (void) {}
return efl_class_functions_set(klass, &ops, NULL);
}
-START_TEST(eo_null_api)
+EFL_START_TEST(eo_null_api)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
_redefined_class_initializer(Efl_Class *klass)
return efl_class_functions_set(klass, &ops, NULL);
}
-START_TEST(eo_api_redefined)
+EFL_START_TEST(eo_api_redefined)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool
_dich_func_class_initializer(Efl_Class *klass)
return efl_class_functions_set(klass, &ops, NULL);
}
-START_TEST(eo_dich_func_override)
+EFL_START_TEST(eo_dich_func_override)
{
efl_object_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
void eo_test_class_errors(TCase *tc)
{
efl_event_callback_add(event->object, EFL_TEST_EVENT_EVENT_TESTER, _cb3, data);
}
-START_TEST(eo_event)
+EFL_START_TEST(eo_event)
{
Test_Data data;
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_cb_rec_3(void *data EINA_UNUSED, const Efl_Event *event)
}
}
-START_TEST(eo_event_call_in_call)
+EFL_START_TEST(eo_event_call_in_call)
{
Test_Data data;
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool emitted = 0;
}
-START_TEST(eo_event_generation_bug)
+EFL_START_TEST(eo_event_generation_bug)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
void eo_test_event(TCase *tc)
/* Loading this internal header for testing purposes. */
#include "eo_ptr_indirection.h"
-START_TEST(eo_simple)
+EFL_START_TEST(eo_simple)
{
efl_object_init();
Eo *obj = efl_add_ref(EO_CLASS, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_singleton)
+EFL_START_TEST(eo_singleton)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
#define OVERRIDE_A_SIMPLE 100859
#define OVERRIDE_A 324000
simple_a_set(efl_super(obj, EFL_OBJECT_OVERRIDE_CLASS), 2 * a);
}
-START_TEST(efl_object_override_tests)
+EFL_START_TEST(efl_object_override_tests)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static int _eo_signals_cb_current = 0;
static int _eo_signals_cb_flag = 0;
{ EV_A_CHANGED, _eo_signals_a_changed_never },
{ EFL_EVENT_DEL, _eo_signals_efl_del_cb });
-START_TEST(eo_signals)
+EFL_START_TEST(eo_signals)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_data_fetch)
+EFL_START_TEST(efl_data_fetch)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_data_safe_fetch)
+EFL_START_TEST(efl_data_safe_fetch)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_isa_tests)
+EFL_START_TEST(efl_isa_tests)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_composite_tests)
+EFL_START_TEST(efl_composite_tests)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static Eina_Bool _man_should_con = EINA_TRUE;
static Eina_Bool _man_should_des = EINA_TRUE;
return efl_class_functions_set(klass, &ops, NULL);
}
-START_TEST(eo_man_free)
+EFL_START_TEST(eo_man_free)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_refs)
+EFL_START_TEST(efl_refs)
{
efl_object_init();
Eo *obj = efl_add_ref(SIMPLE_CLASS, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_weak_reference)
+EFL_START_TEST(efl_weak_reference)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_generic_data)
+EFL_START_TEST(eo_generic_data)
{
efl_object_init();
Eo *obj = efl_add_ref(SIMPLE_CLASS, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_magic_checks)
+EFL_START_TEST(eo_magic_checks)
{
char _buf[sizeof(long)]; /* Just enough to hold eina magic + a bit more. */
char *buf = _buf;
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
/* resolve issues */
return efl_class_functions_set(klass, &ops, NULL);
}
-START_TEST(efl_func_resolve)
+EFL_START_TEST(efl_func_resolve)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_add_do_and_custom)
+EFL_START_TEST(efl_add_do_and_custom)
{
Simple_Public_Data *pd = NULL;
Eo *obj = NULL;
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_pointers_indirection)
+EFL_START_TEST(eo_pointers_indirection)
{
#ifdef HAVE_EO_ID
efl_object_init();
efl_object_shutdown();
#endif
}
-END_TEST
+EFL_END_TEST
static Eo *
return efl_class_functions_set(klass, &ops, NULL);
}
-START_TEST(efl_add_failures)
+EFL_START_TEST(efl_add_failures)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
#ifdef HAVE_EO_ID
static Eina_Bool intercepted = EINA_FALSE;
}
#endif
-START_TEST(efl_del_intercept)
+EFL_START_TEST(efl_del_intercept)
{
#ifdef HAVE_EO_ID
efl_object_init();
efl_object_shutdown();
#endif
}
-END_TEST
+EFL_END_TEST
-START_TEST(efl_name)
+EFL_START_TEST(efl_name)
{
efl_object_init();
Eo *obj = efl_add_ref(SIMPLE_CLASS, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_comment)
+EFL_START_TEST(eo_comment)
{
efl_object_init();
Eo *obj = efl_add_ref(SIMPLE_CLASS, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_rec_interface)
+EFL_START_TEST(eo_rec_interface)
{
efl_object_init();
Eo *s = efl_add_ref(SEARCHABLE_CLASS, NULL);
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
typedef struct
{
}
#endif
-START_TEST(eo_domain)
+EFL_START_TEST(eo_domain)
{
Eo *obj, *objs;
signal(SIGALRM, NULL);
#endif
}
-END_TEST
+EFL_END_TEST
static int
return efl_class_functions_set(klass, &ops, NULL);
}
-START_TEST(efl_cast_test)
+EFL_START_TEST(efl_cast_test)
{
efl_object_init();
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static void _destruct_test_del_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
//ck_assert_int_ne(efl_destructed_is(ev->object), 0);
}
-START_TEST(efl_object_destruct_test)
+EFL_START_TEST(efl_object_destruct_test)
{
int var = 0;
Eo *obj;
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
static void
_auto_unref_del_cb(void *data, const Efl_Event *ev EINA_UNUSED)
*((int *) data) = 1;
}
-START_TEST(efl_object_auto_unref_test)
+EFL_START_TEST(efl_object_auto_unref_test)
{
int _auto_unref_del;
Eo *obj, *parent;
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
void eo_test_general(TCase *tc)
{
#include "eo_suite.h"
#include "eo_test_class_simple.h"
-START_TEST(eo_test_simple)
+EFL_START_TEST(eo_test_simple)
{
fail_if(!efl_object_init()); /* one init by test suite */
fail_if(!efl_object_init());
fail_if(!efl_object_shutdown());
fail_if(efl_object_shutdown());
}
-END_TEST
+EFL_END_TEST
-START_TEST(eo_test_init_shutdown)
+EFL_START_TEST(eo_test_init_shutdown)
{
Eo *obj;
ck_assert_int_eq(0xBEEF, simple2_class_beef_get(SIMPLE2_CLASS));
fail_if(efl_object_shutdown());
}
-END_TEST
+EFL_END_TEST
void eo_test_init(TCase *tc)
{
return (void *) (uintptr_t) v;
}
-START_TEST(eo_threaded_calls_test)
+EFL_START_TEST(eo_threaded_calls_test)
{
Eina_Thread threads[2];
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
void eo_test_threaded_calls(TCase *tc)
{
#include "eo_suite.h"
#include "eo_test_class_simple.h"
-START_TEST(eo_value)
+EFL_START_TEST(eo_value)
{
efl_object_init();
char *str, *str2;
efl_object_shutdown();
}
-END_TEST
+EFL_END_TEST
void eo_test_value(TCase *tc)
{
#include <algorithm>
#include <check.h>
-
+#include "../efl_check.h"
void eo_cxx_test_promise(TCase* tc);
#endif /* _EINA_CXX_SUITE_H */
return system(command);
}
-START_TEST(eolian_dev_impl_code)
+EFL_START_TEST(eolian_dev_impl_code)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_object_impl",
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/object_impl_add.eo", "-gi", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/object_impl_add_ref.c", output_filepath, "c"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_types_generation)
+EFL_START_TEST(eolian_types_generation)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_typedef",
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/struct.eo", "-gs", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/struct_ref_stub.h", output_filepath, "eo.stub.h"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_default_values_generation)
+EFL_START_TEST(eolian_default_values_generation)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_class_simple",
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/class_simple.eo", "-gc", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/class_simple_ref.c", output_filepath, "eo.c"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_override_generation)
+EFL_START_TEST(eolian_override_generation)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_override",
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/override.eo", "-gc", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/override_ref.c", output_filepath, "eo.c"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_functions_descriptions)
+EFL_START_TEST(eolian_functions_descriptions)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_class_simple",
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/class_simple.eo", "-gl", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/class_simple_ref_legacy.h", output_filepath, "eo.legacy.h"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_import)
+EFL_START_TEST(eolian_import)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_import_types",
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/import_types.eot", "-gh", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/import_types_ref.h", output_filepath, "eot.h"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_docs)
+EFL_START_TEST(eolian_docs)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_docs",
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/docs.eo", "-gl", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/docs_ref_legacy.h", output_filepath, "eo.legacy.h"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_function_pointers)
+EFL_START_TEST(eolian_function_pointers)
{
// .eot
fail_if(0 != _eolian_gen_execute(TESTS_SRC_DIR"/data/function_as_argument.eo", "-gi", output_filepath));
fail_if(!_files_compare(TESTS_SRC_DIR"/data/function_as_argument_impl_ref.c", output_filepath, "c"));
}
-END_TEST
+EFL_END_TEST
-START_TEST(owning)
+EFL_START_TEST(owning)
{
char output_filepath[PATH_MAX] = "";
snprintf(output_filepath, PATH_MAX, "%s/eolian_owning",
fail_if(!_files_compare(TESTS_SRC_DIR"/data/owning.eo.c", output_filepath, "eo.c"));
}
-END_TEST
+EFL_END_TEST
void eolian_generation_test(TCase *tc)
{
#include "eolian_suite.h"
-START_TEST(eolian_namespaces)
+EFL_START_TEST(eolian_namespaces)
{
const Eolian_Class *class11, *class112, *class21, *class_no, *impl_class,
*iclass;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_events)
+EFL_START_TEST(eolian_events)
{
const Eolian_Class *class;
Eina_Iterator *iter;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_override)
+EFL_START_TEST(eolian_override)
{
Eina_Iterator *iter;
const Eolian_Class *impl_class = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_consts)
+EFL_START_TEST(eolian_consts)
{
const Eolian_Function *fid = NULL;
const Eolian_Class *class;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_ctor_dtor)
+EFL_START_TEST(eolian_ctor_dtor)
{
Eina_Iterator *iter;
const Eolian_Class *impl_class = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_typedef)
+EFL_START_TEST(eolian_typedef)
{
const Eolian_Type *type = NULL;
const Eolian_Typedecl *tdl = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_complex_type)
+EFL_START_TEST(eolian_complex_type)
{
const Eolian_Function *fid = NULL;
const Eolian_Function_Parameter *param = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_scope)
+EFL_START_TEST(eolian_scope)
{
const Eolian_Function *fid = NULL;
const Eolian_Class *class;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_simple_parsing)
+EFL_START_TEST(eolian_simple_parsing)
{
const Eolian_Function *fid = NULL;
const char *string = NULL, *ptype = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_struct)
+EFL_START_TEST(eolian_struct)
{
const Eolian_Struct_Type_Field *field = NULL;
const Eolian_Type *type = NULL, *ftype = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_extern)
+EFL_START_TEST(eolian_extern)
{
const Eolian_Typedecl *tdl = NULL;
const Eolian_Class *class;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_var)
+EFL_START_TEST(eolian_var)
{
const Eolian_Variable *var = NULL;
const Eolian_Expression *exp = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_enum)
+EFL_START_TEST(eolian_enum)
{
const Eolian_Enum_Type_Field *field = NULL;
const Eolian_Variable *var = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_class_funcs)
+EFL_START_TEST(eolian_class_funcs)
{
const Eolian_Function *fid = NULL;
const Eolian_Class *class;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_free_func)
+EFL_START_TEST(eolian_free_func)
{
const Eolian_Class *class;
const Eolian_Typedecl *tdl;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_null)
+EFL_START_TEST(eolian_null)
{
const Eolian_Class *class;
const Eolian_Function *func;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_import)
+EFL_START_TEST(eolian_import)
{
const Eolian_Class *class;
const Eolian_Typedecl *tdl;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_decl)
+EFL_START_TEST(eolian_decl)
{
const Eolian_Object *decl;
const Eolian_Typedecl *tdl;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_docs)
+EFL_START_TEST(eolian_docs)
{
const Eolian_Typedecl *tdl;
const Eolian_Class *class;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_function_types)
+EFL_START_TEST(eolian_function_types)
{
const Eolian_Typedecl *decl = NULL;
const Eolian_Typedecl *arg_decl = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_function_as_arguments)
+EFL_START_TEST(eolian_function_as_arguments)
{
const Eolian_Class *cls = NULL;
const Eolian_Function *fid = NULL;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(eolian_parts)
+EFL_START_TEST(eolian_parts)
{
const Eolian_Unit *unit;
const Eolian_Class *cls;
eolian_state_free(eos);
eolian_shutdown();
}
-END_TEST
+EFL_END_TEST
void eolian_parsing_test(TCase *tc)
{
#define _EOLIAN_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void eolian_parsing_test(TCase *tc);
void eolian_generation_test(TCase *tc);
#define _EOLIAN_CXX_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void eolian_cxx_test_parse(TCase* tc);
void eolian_cxx_test_wrapper(TCase* tc);
void eolian_cxx_test_generate(TCase* tc);
#define _EVAS_SUITE_H
#include <check.h>
-
+#include "../efl_check.h"
void evas_test_init(TCase *tc);
void evas_test_object(TCase *tc);
void evas_test_textblock(TCase *tc);
counter++;
}
-START_TEST(evas_object_event_callbacks_priority)
+EFL_START_TEST(evas_object_event_callbacks_priority)
{
START_CALLBACK_TEST();
counter = 1;
END_CALLBACK_TEST();
}
-END_TEST
+EFL_END_TEST
static void
_event_cb(void *data, Evas *e, void *event_info)
counter++;
}
-START_TEST(evas_event_callbacks_priority)
+EFL_START_TEST(evas_event_callbacks_priority)
{
START_CALLBACK_TEST();
evas_object_focus_set(rect, EINA_FALSE);
END_CALLBACK_TEST();
}
-END_TEST
+EFL_END_TEST
void evas_test_callbacks(TCase *tc)
{
}
#define TEST_ADD_OPT(name, opt) \
- START_TEST(evas ## name ## _opengl_x11) \
+ EFL_START_TEST(evas ## name ## _opengl_x11) \
{ name("opengl_x11"); } \
- END_TEST \
- START_TEST(evas ## name ## _buffer) \
+ EFL_END_TEST \
+ EFL_START_TEST(evas ## name ## _buffer) \
{ name("buffer"); } \
- END_TEST
+ EFL_END_TEST
#define TEST_ADD(name) TEST_ADD_OPT(name, NULL)
TEST_ADD(_test_evasgl_init)
#endif
-START_TEST(evas_filter_parser)
+EFL_START_TEST(evas_filter_parser)
{
Evas_Filter_Program *pgm;
// fillmodes are parsed when converting from instructions to commands
}
-END_TEST
+EFL_END_TEST
struct Filter_Test_Case {
int l, r, t, b;
static const int _test_cases_count = sizeof(_test_cases) / sizeof(_test_cases[0]);
-START_TEST(evas_filter_text_padding_test)
+EFL_START_TEST(evas_filter_text_padding_test)
{
START_FILTER_TEST();
Evas_Coord x, y, w, h, W, H;
END_FILTER_TEST();
}
-END_TEST
+EFL_END_TEST
/* This will only check that all pixels are valid premultiplied values
* and that they are not all zero.
return nonzero;
}
-START_TEST(evas_filter_text_render_test)
+EFL_START_TEST(evas_filter_text_render_test)
{
Evas_Filter_Program *pgm;
}
}
-END_TEST
+EFL_END_TEST
static inline Eina_Bool
strequal(const char *a, const char *b)
return !strcmp(a, b);
}
-START_TEST(evas_filter_state_test)
+EFL_START_TEST(evas_filter_state_test)
{
/* dumb code testing state values */
static const char *code =
END_FILTER_TEST();
}
-END_TEST
+EFL_END_TEST
void evas_test_filters(TCase *tc)
{
#endif
};
-START_TEST(evas_object_image_loader)
+EFL_START_TEST(evas_object_image_loader)
{
Evas *e = _setup_evas();
Evas_Object *o;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
typedef struct _Orientation_Test_Res Orientation_Test_Res;
struct _Orientation_Test_Res {
return 0;
}
-START_TEST(evas_object_image_loader_orientation)
+EFL_START_TEST(evas_object_image_loader_orientation)
{
Evas *e = _setup_evas();
Evas_Object *orig, *rot;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(evas_object_image_orient)
+EFL_START_TEST(evas_object_image_orient)
{
Evas *e = _setup_evas();
Evas_Object *orig;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
#ifdef BUILD_LOADER_TGV
-START_TEST(evas_object_image_tgv_loader_data)
+EFL_START_TEST(evas_object_image_tgv_loader_data)
{
Evas *e = _setup_evas();
Evas_Object *obj, *ref;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(evas_object_image_all_loader_data)
+EFL_START_TEST(evas_object_image_all_loader_data)
{
Evas *e = _setup_evas();
Evas_Object *obj, *ref;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
const char *buggy[] = {
"BMP301K"
};
-START_TEST(evas_object_image_buggy)
+EFL_START_TEST(evas_object_image_buggy)
{
Evas *e = _setup_evas();
Evas_Object *obj, *ref;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
static void check_rotate_region(Evas_Image_Orient orientation, int *r_x, int *r_y, int *r_w, int *r_h, int w, int h)
{
}
-START_TEST(evas_object_image_partially_load_orientation)
+EFL_START_TEST(evas_object_image_partially_load_orientation)
{
static const Orientation_Test_Res res[] = {
{ TESTS_IMG_DIR"/Light_exif.jpg", "Original", EVAS_IMAGE_ORIENT_NONE, _compare_img },
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
-START_TEST(evas_object_image_defaults)
+EFL_START_TEST(evas_object_image_defaults)
{
Evas *e = _setup_evas();
Evas_Object *o;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
// FIXME: belongs to another file
-START_TEST(evas_object_image_map_unmap)
+EFL_START_TEST(evas_object_image_map_unmap)
{
Evas *e = _setup_evas();
Evas_Object *o, *o2;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
#if BUILD_LOADER_JP2K
-START_TEST(evas_object_image_jp2k_loader_data)
+EFL_START_TEST(evas_object_image_jp2k_loader_data)
{
Evas *e = _setup_evas();
Evas_Object *obj, *ref;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
#endif
void evas_test_image_object(TCase *tc)
#include "evas_suite.h"
-START_TEST(evas_simple)
+EFL_START_TEST(evas_simple)
{
}
-END_TEST
+EFL_END_TEST
void evas_test_init(TCase *tc)
{
}
// The usual useless unit test
-START_TEST(evas_mask_test_setget)
+EFL_START_TEST(evas_mask_test_setget)
{
Evas *e = _setup_evas();
Evas_Object *obj = NULL, *mask = NULL;
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
// This test is also very basic but will check the pixels
-START_TEST(evas_mask_test_compare_clip)
+EFL_START_TEST(evas_mask_test_compare_clip)
{
Evas_Object *obj, *mask, *rect, *bg, *clip, *text;
unsigned int *data, *refdata[3];
free(data);
END_MASK_TEST();
}
-END_TEST
+EFL_END_TEST
// This will simply check that a mask is recursively applied to children
-START_TEST(evas_mask_test_mask_of_mask)
+EFL_START_TEST(evas_mask_test_mask_of_mask)
{
Evas_Object *bg, *tbl, *rect0, *mask0, *mask1, *obj;
unsigned int *data, *refdata;
free(data);
END_MASK_TEST();
}
-END_TEST
+EFL_END_TEST
// NOTE: Much more extensive tests are required. But they should
// be based on "exactness" or a pixel similarity tool.
#include "evas_suite.h"
#include "evas_tests_helpers.h"
-START_TEST(evas_matrix)
+EFL_START_TEST(evas_matrix)
{
Eina_Vector3 position;
Eina_Quaternion orientation;
fail_if((mat.xx - 0.99 < DBL_EPSILON) || (mat.xy - 0.0 < DBL_EPSILON) ||
(mat.yx -0.0 < DBL_EPSILON) || (mat.yy -0.49 < DBL_EPSILON));
}
-END_TEST
+EFL_END_TEST
void evas_test_matrix(TCase *tc)
{
return 0;
}
-START_TEST(evas_object_mesh_loader_saver)
+EFL_START_TEST(evas_object_mesh_loader_saver)
{
char buffer[PATH_MAX];
Evas *e = _setup_evas();
evas_free(e);
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
void evas_test_mesh(TCase *tc)
{
#include "evas_suite.h"
#include "evas_tests_helpers.h"
-START_TEST(evas_object_various)
+EFL_START_TEST(evas_object_various)
{
Evas *evas = EVAS_TEST_INIT_EVAS();
ecore_evas_shutdown();
ecore_evas_shutdown();
}
-END_TEST
+EFL_END_TEST
void evas_test_object(TCase *tc)
{
} \
while (0)
-START_TEST(evas_object_smart_paragraph_direction)
+EFL_START_TEST(evas_object_smart_paragraph_direction)
{
START_EVAS_OBJECT_SMART_TEST();
DELETE_EVAS_TEXT();
END_EVAS_OBJECT_SMART_TEST();
}
-END_TEST
+EFL_END_TEST
void evas_test_object_smart(TCase *tc)
{
NULL
};
-START_TEST(evas_render_engines)
+EFL_START_TEST(evas_render_engines)
{
Eina_List *lst = evas_render_method_list();
const char **itr;
evas_render_method_list_free(lst);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evas_render_lookup)
+EFL_START_TEST(evas_render_lookup)
{
const char **itr;
fail_if(id == 0, "could not load engine: %s", *itr);
}
}
-END_TEST
+EFL_END_TEST
void evas_test_render_engines(TCase *tc)
{
} \
while (0)
-START_TEST(evas_text_simple)
+EFL_START_TEST(evas_text_simple)
{
START_TEXT_TEST();
const char *buf = "Test - בדיקה";
fail_if(strcmp(evas_object_text_text_get(to), buf));
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
/* Various text related geometries */
-START_TEST(evas_text_geometries)
+EFL_START_TEST(evas_text_geometries)
{
START_TEXT_TEST();
const char *buf = "Tests";
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
/* Various evas stuff, such as scale */
-START_TEST(evas_text_evas)
+EFL_START_TEST(evas_text_evas)
{
Evas_Coord w, h, bw, bh;
START_TEXT_TEST();
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
static void
_test_ellipsis(Evas_Object *to, const char *buf, const char *font, Evas_Font_Size size, double ellipsis)
fail_if(w < 100);
}
-START_TEST(evas_text_ellipsis)
+EFL_START_TEST(evas_text_ellipsis)
{
START_TEXT_TEST();
const char *buf = "× ×¡×™×•×Ÿ בלה בלה בלה בלה";
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
/* Tests for functions that are in evas_object_text.c but
* don't really have anything to do with it. */
-START_TEST(evas_text_unrelated)
+EFL_START_TEST(evas_text_unrelated)
{
START_TEXT_TEST();
const char *buf = "× ×¡×™×•×Ÿ";
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
#define _CHECK_SET_GET(x) \
do \
} \
while (0)
-START_TEST(evas_text_set_get)
+EFL_START_TEST(evas_text_set_get)
{
START_TEXT_TEST();
const char *buf = "Test - בדיקה";
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
-START_TEST(evas_text_style)
+EFL_START_TEST(evas_text_style)
{
Evas_Coord l, r, t, b;
START_TEXT_TEST();
fail_if(strcmp(evas_object_text_text_get(to), buf));
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
#ifdef HAVE_FRIBIDI
-START_TEST(evas_text_bidi)
+EFL_START_TEST(evas_text_bidi)
{
START_TEXT_TEST();
const char *buf = "Test - בדיקה";
END_TEXT_TEST();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(evas_text_render)
+EFL_START_TEST(evas_text_render)
{
Ecore_Evas *ee = ecore_evas_buffer_new(500, 500);
Evas *evas = ecore_evas_get(ee);
ecore_evas_free(ee);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evas_text_font_load)
+EFL_START_TEST(evas_text_font_load)
{
Ecore_Evas *ee = ecore_evas_buffer_new(500, 500);
Evas *evas = ecore_evas_get(ee);
ecore_evas_free(ee);
}
-END_TEST
+EFL_END_TEST
void evas_test_text(TCase *tc)
{
} \
while (0)
-START_TEST(evas_textblock_simple)
+EFL_START_TEST(evas_textblock_simple)
{
START_TB_TEST();
const char *buf = "Th<i>i</i>s is a <br/> te<b>s</b>t.";
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
#define _CHECK_CURSOR_COORDS() \
do \
fail_if(ret == -1); \
} \
while (0)
-START_TEST(evas_textblock_cursor)
+EFL_START_TEST(evas_textblock_cursor)
{
START_TB_TEST();
Evas_Coord x, y, w, h;
}
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
#ifdef HAVE_FRIBIDI
-START_TEST(evas_textblock_split_cursor)
+EFL_START_TEST(evas_textblock_split_cursor)
{
START_TB_TEST();
Evas_Coord x, w, x2, w2;
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
#endif
-START_TEST(evas_textblock_format_removal)
+EFL_START_TEST(evas_textblock_format_removal)
{
START_TB_TEST();
int i;
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Testing items */
-START_TEST(evas_textblock_items)
+EFL_START_TEST(evas_textblock_items)
{
Evas_Coord x, y, w, h, w2, h2, nw, nh, ih;
START_TB_TEST();
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Wrapping tests */
-START_TEST(evas_textblock_wrapping)
+EFL_START_TEST(evas_textblock_wrapping)
{
Evas_Coord bw, bh, w, h, nw, nh;
int i;
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Various textblock stuff */
-START_TEST(evas_textblock_various)
+EFL_START_TEST(evas_textblock_various)
{
Evas_Coord w, h, bw, bh;
START_TB_TEST();
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Various geometries. e.g. range geometry. */
-START_TEST(evas_textblock_geometries)
+EFL_START_TEST(evas_textblock_geometries)
{
START_TB_TEST();
const char *buf = "This is a <br/> test.";
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Should handle all the text editing. */
-START_TEST(evas_textblock_editing)
+EFL_START_TEST(evas_textblock_editing)
{
START_TB_TEST();
const char *buf = "First par.<ps/>Second par.";
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Text getters */
-START_TEST(evas_textblock_text_getters)
+EFL_START_TEST(evas_textblock_text_getters)
{
START_TB_TEST();
const char *buf = "This is a <br/> test.<ps/>"
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Formats */
-START_TEST(evas_textblock_formats)
+EFL_START_TEST(evas_textblock_formats)
{
START_TB_TEST();
const char *buf = "Th<b>i<font_size=15 wrap=none>s i</font_size=13>s</> a <br/> te<ps/>st<item></>.";
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Different text styles, for example, shadow. */
-START_TEST(evas_textblock_style)
+EFL_START_TEST(evas_textblock_style)
{
Evas_Coord w, h, nw, nh;
Evas_Coord l, r, t, b;
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Basic test for style user push/peek/pop. */
START_TEST(evas_textblock_style_user)
END_TEST
/* Various setters and getters */
-START_TEST(evas_textblock_set_get)
+EFL_START_TEST(evas_textblock_set_get)
{
START_TB_TEST();
const char *buf = "";
evas_font_hinting_set(evas, EVAS_FONT_HINTING_BYTECODE);
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* Aux evas stuff, such as scale. */
-START_TEST(evas_textblock_evas)
+EFL_START_TEST(evas_textblock_evas)
{
Evas_Coord w, h, sw, sh;
START_TB_TEST();
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
/* All the string escaping stuff */
-START_TEST(evas_textblock_escaping)
+EFL_START_TEST(evas_textblock_escaping)
{
int len;
START_TB_TEST();
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
-START_TEST(evas_textblock_size)
+EFL_START_TEST(evas_textblock_size)
{
START_TB_TEST();
Evas_Coord w, h, h2, nw, nh;
/* FIXME: There is a lot more to be done. */
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
-START_TEST(evas_textblock_delete)
+EFL_START_TEST(evas_textblock_delete)
{
START_TB_TEST();
const Evas_Object_Textblock_Node_Format *fmt;
END_TB_TEST();
}
-END_TEST;
+EFL_END_TEST;
/* Runs x,y in [from,to] range */
static void
}
}
-START_TEST(evas_textblock_obstacle)
+EFL_START_TEST(evas_textblock_obstacle)
{
START_TB_TEST();
Evas_Coord fw, fh;
_obstacle_run(tb, rect3, 0, fw, 0, 0, fh);
END_TB_TEST();
}
-END_TEST;
+EFL_END_TEST;
#ifdef HAVE_HYPHEN
static void
ck_assert_int_eq(w, bw);
}
-START_TEST(evas_textblock_hyphenation)
+EFL_START_TEST(evas_textblock_hyphenation)
{
START_TB_TEST();
Evas_Coord w, fw;
END_TB_TEST();
}
-END_TEST;
+EFL_END_TEST;
#endif
-START_TEST(evas_textblock_text_iface)
+EFL_START_TEST(evas_textblock_text_iface)
{
START_TB_TEST();
Evas_Coord nw, nh;
END_TB_TEST();
}
-END_TEST;
+EFL_END_TEST;
static void
_test_check_annotation(Evas_Object *tb,
#define _CREATE_PARAMS(X) (sizeof(X) / sizeof(X[0])), (X)
#define _COMP_PARAMS(...) _CREATE_PARAMS(_COMP_STR(__VA_ARGS__))
-START_TEST(evas_textblock_annotation)
+EFL_START_TEST(evas_textblock_annotation)
{
START_TB_TEST();
Efl_Text_Annotate_Annotation *an, *an2;
END_TB_TEST();
}
-END_TEST;
+EFL_END_TEST;
-START_TEST(efl_canvas_text_cursor)
+EFL_START_TEST(efl_canvas_text_cursor)
{
START_TB_TEST();
END_TB_TEST();
}
-END_TEST
+EFL_END_TEST
void evas_test_textblock(TCase *tc)
{
#define EVIL_SUITE_H_
#include <check.h>
-
+#include "../efl_check.h"
void evil_test_dlfcn(TCase *tc);
/* void evil_test_fcntl(TCase *tc); */
/* void evil_test_fnmatch(TCase *tc); */
typedef int (*_evil_shutdwon)(void);
-START_TEST(evil_dlfcn_dlopen_success)
+EFL_START_TEST(evil_dlfcn_dlopen_success)
{
void *mod;
int res;
res = dlclose(mod);
fail_if(res != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_dlfcn_dlopen_failure)
+EFL_START_TEST(evil_dlfcn_dlopen_failure)
{
void *mod;
mod = dlopen("c:\\windows\\system32\\kernel32.dl", 0);
fail_if(mod != NULL);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_dlfcn_dlsym_success)
+EFL_START_TEST(evil_dlfcn_dlsym_success)
{
_evil_init sym_init;
_evil_shutdwon sym_shutdown;
res = dlclose(mod);
fail_if(res != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_dlfcn_dlsym_failure)
+EFL_START_TEST(evil_dlfcn_dlsym_failure)
{
void *mod;
void *sym;
res = dlclose(mod);
fail_if(res != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_dlfcn_dladdr)
+EFL_START_TEST(evil_dlfcn_dladdr)
{
Dl_info info;
void *mod;
res = dlclose(mod);
fail_if(res != 0);
}
-END_TEST
+EFL_END_TEST
void evil_test_dlfcn(TCase *tc)
{
#include "evil_suite.h"
-START_TEST(evil_libgen_null)
+EFL_START_TEST(evil_libgen_null)
{
char *dname;
char *bname;
bname = basename(NULL);
fail_if(strcmp(bname, ".") != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_empty)
+EFL_START_TEST(evil_libgen_empty)
{
const char *path = "";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_path)
+EFL_START_TEST(evil_libgen_path)
{
const char *path = "/usr/lib";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_path_with_slash)
+EFL_START_TEST(evil_libgen_path_with_slash)
{
const char *path = "/usr/";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_folder)
+EFL_START_TEST(evil_libgen_folder)
{
const char *path = "usr";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_slash)
+EFL_START_TEST(evil_libgen_slash)
{
const char *path = "/";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_dot)
+EFL_START_TEST(evil_libgen_dot)
{
const char *path = ".";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_dot_dot)
+EFL_START_TEST(evil_libgen_dot_dot)
{
const char *path = "..";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_win_dir_1)
+EFL_START_TEST(evil_libgen_win_dir_1)
{
const char *path = "c:/foo/bar";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_win_dir_2)
+EFL_START_TEST(evil_libgen_win_dir_2)
{
const char *path = "c:/foo\\bar";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_win_dir_3)
+EFL_START_TEST(evil_libgen_win_dir_3)
{
const char *path = "c:\\foo/bar";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_libgen_win_dir_4)
+EFL_START_TEST(evil_libgen_win_dir_4)
{
const char *path = "c:\\foo\\bar";
char *dirc;
free(dirc);
free(basec);
}
-END_TEST
+EFL_END_TEST
void evil_test_libgen(TCase *tc)
{
#include "evil_suite.h"
-START_TEST(evil_main_simple)
+EFL_START_TEST(evil_main_simple)
{
fail_if(evil_init() != 1);
fail_if(evil_shutdown() != 0);
}
-END_TEST
+EFL_END_TEST
void evil_test_main(TCase *tc)
{
return f;
}
-START_TEST(evil_stdio_rename_src_file_none)
+EFL_START_TEST(evil_stdio_rename_src_file_none)
{
int res;
res = rename("evil_foo.txt", NULL);
fail_if(res != -1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdio_rename_dst_file_none)
+EFL_START_TEST(evil_stdio_rename_dst_file_none)
{
int res1;
int res2;
fail_if(res3 == -1);
fail_if(res4 == 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdio_rename_dst_file_exists)
+EFL_START_TEST(evil_stdio_rename_dst_file_exists)
{
int res1;
int res2;
fail_if(res2 == -1);
fail_if(res3 == 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdio_rename_dst_file_used)
+EFL_START_TEST(evil_stdio_rename_dst_file_used)
{
FILE *f;
int res1;
fail_if(res2 == -1);
fail_if(res3 == -1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdio_rename_dst_file_move_to_dir)
+EFL_START_TEST(evil_stdio_rename_dst_file_move_to_dir)
{
int res1;
int res2;
fail_if(res3 == -1);
fail_if(res4 == 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdio_rename_dst_dir_none)
+EFL_START_TEST(evil_stdio_rename_dst_dir_none)
{
int res1;
int res2;
fail_if(res2 == -1);
fail_if(res3 == 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdio_rename_dst_dir_exists)
+EFL_START_TEST(evil_stdio_rename_dst_dir_exists)
{
int res1;
int res2;
fail_if(res2 == -1);
fail_if(res3 == 0);
}
-END_TEST
+EFL_END_TEST
void evil_test_stdio(TCase *tc)
{
#include "evil_suite.h"
-START_TEST(evil_stdlib_setenv_NULL)
+EFL_START_TEST(evil_stdlib_setenv_NULL)
{
char *val;
int res;
val = getenv("EVIL_TEST_ENV");
fail_if(val != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_setenv_NULL_after_set)
+EFL_START_TEST(evil_stdlib_setenv_NULL_after_set)
{
char *val;
int res;
val = getenv("EVIL_TEST_ENV");
fail_if(val != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_getenv_one)
+EFL_START_TEST(evil_stdlib_getenv_one)
{
char *val;
int res;
val = getenv("EVIL_TEST_ENV");
fail_if(val != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_getenv_two)
+EFL_START_TEST(evil_stdlib_getenv_two)
{
char *val;
int res;
val = getenv("EVIL_TEST_ENV2");
fail_if(val != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_getenv_two_swapped)
+EFL_START_TEST(evil_stdlib_getenv_two_swapped)
{
char *val;
int res;
val = getenv("EVIL_TEST_ENV2");
fail_if(val != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_unsetenv)
+EFL_START_TEST(evil_stdlib_unsetenv)
{
char *val;
int res;
val = getenv("EVIL_TEST_ENV");
fail_if(val != 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_mkdtemp)
+EFL_START_TEST(evil_stdlib_mkdtemp)
{
char template[] = "file_XXXXXX";
char *res;
fail_if(rmdir(res) < 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_mkdtemp_fail)
+EFL_START_TEST(evil_stdlib_mkdtemp_fail)
{
char template[] = "file_XXX";
char *res;
res = mkdtemp(template);
fail_if(res != NULL);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_mkstemp)
+EFL_START_TEST(evil_stdlib_mkstemp)
{
char template[] = "file_XXXXXX";
int fd;
fail_if(unlink(template) == -1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_mkstemp_fail)
+EFL_START_TEST(evil_stdlib_mkstemp_fail)
{
char template[] = "file_XXX";
int fd;
fd = mkstemp(template);
fail_if(fd >= 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_mkstemps)
+EFL_START_TEST(evil_stdlib_mkstemps)
{
char template[] = "file_XXXXXX.ext";
int fd;
fail_if(unlink(template) == -1);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_mkstemps_fail_1)
+EFL_START_TEST(evil_stdlib_mkstemps_fail_1)
{
char template[] = "file_XXX.ext";
int fd;
fd = mkstemps(template, 4);
fail_if(fd >= 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_mkstemps_fail_2)
+EFL_START_TEST(evil_stdlib_mkstemps_fail_2)
{
char template[] = "file_XXX";
int fd;
fd = mkstemps(template, 4);
fail_if(fd >= 0);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_realpath_1)
+EFL_START_TEST(evil_stdlib_realpath_1)
{
char buf[PATH_MAX];
char *filename = "C:\\Windows\\System32\\kernel32.dll";
res = realpath(filename, buf);
fail_if(res == NULL);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_realpath_2)
+EFL_START_TEST(evil_stdlib_realpath_2)
{
char buf[PATH_MAX];
char *filename = "C:\\Windows\\System32\\.\\kernel32.dll";
res = realpath(filename, buf);
fail_if(res == NULL);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_realpath_3)
+EFL_START_TEST(evil_stdlib_realpath_3)
{
char buf[PATH_MAX];
char *filename = "C:\\Windows\\System32\\..\\System32\\kernel32.dll";
res = realpath(filename, buf);
fail_if(res == NULL);
}
-END_TEST
+EFL_END_TEST
-START_TEST(evil_stdlib_realpath_fail)
+EFL_START_TEST(evil_stdlib_realpath_fail)
{
char buf[PATH_MAX];
char *filename = "C:\\Windows\\System32\\System32\\kernel.dll";
res = realpath(filename, buf);
fail_if(res != NULL);
}
-END_TEST
+EFL_END_TEST
void evil_test_stdlib(TCase *tc)
{
return 0;
}
-START_TEST(evil_unistd_pipe)
+EFL_START_TEST(evil_unistd_pipe)
{
int sockets[2];
struct timeval t;
evil_shutdown();
}
-END_TEST
+EFL_END_TEST
void evil_test_unistd(TCase *tc)
{
projects / platform / upstream / efl.git / commitdiff