2012-05-01 00:40:14 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
2015-05-08 06:21:23 -07:00
|
|
|
#define EO_BASE_BETA
|
2015-05-06 09:05:38 -07:00
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
#include "Eo.h"
|
2012-09-07 14:56:44 -07:00
|
|
|
#include "eo_suite.h"
|
2012-09-25 23:56:52 -07:00
|
|
|
#include "eo_test_class_simple.h"
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-10-22 03:43:45 -07:00
|
|
|
/* Loading this internal header for testing purposes. */
|
|
|
|
#include "eo_ptr_indirection.h"
|
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
START_TEST(eo_simple)
|
|
|
|
{
|
|
|
|
eo_init();
|
2014-04-02 04:01:16 -07:00
|
|
|
Eo *obj = eo_add(EO_CLASS, NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(obj);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
2012-06-10 07:04:58 -07:00
|
|
|
fail_if(!obj);
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_constructor());
|
|
|
|
eo_do(obj, eo_destructor());
|
2012-06-10 07:04:58 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2013-12-30 06:24:44 -08:00
|
|
|
START_TEST(eo_stack)
|
|
|
|
{
|
|
|
|
eo_init();
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
2013-12-30 06:24:44 -08:00
|
|
|
fail_if(!obj);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, simple_recursive(123));
|
2013-12-30 06:24:44 -08:00
|
|
|
|
|
|
|
eo_unref(obj);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2014-05-20 07:31:53 -07:00
|
|
|
static int _eo_signals_cb_current = 0;
|
2013-04-12 03:06:30 -07:00
|
|
|
static int _eo_signals_cb_flag = 0;
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eo_signals_a_changed_cb(void *_data, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
int data = (intptr_t) _data;
|
2014-05-20 07:31:53 -07:00
|
|
|
_eo_signals_cb_current++;
|
|
|
|
ck_assert_int_eq(data, _eo_signals_cb_current);
|
2013-04-12 03:06:30 -07:00
|
|
|
_eo_signals_cb_flag |= 0x1;
|
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eo_signals_a_changed_cb2(void *_data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
_eo_signals_cb_flag |= 0x2;
|
2013-04-12 05:46:30 -07:00
|
|
|
return EO_CALLBACK_STOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eo_signals_a_changed_never(void *_data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
/* This one should never be called. */
|
|
|
|
fail_if(1);
|
2013-04-12 03:06:30 -07:00
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eo_signals_eo_del_cb(void *_data EINA_UNUSED, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
_eo_signals_cb_flag |= 0x4;
|
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
_eo_signals_cb_added_deled(void *data, Eo *obj EINA_UNUSED, const Eo_Event_Description *desc EINA_UNUSED, void *event_info)
|
|
|
|
{
|
|
|
|
const Eo_Callback_Array_Item *callback_array = event_info;
|
|
|
|
|
|
|
|
fail_if((callback_array != data) &&
|
|
|
|
(callback_array->func != _eo_signals_cb_added_deled));
|
|
|
|
|
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
START_TEST(eo_signals)
|
|
|
|
{
|
|
|
|
eo_init();
|
|
|
|
static const Eo_Callback_Array_Item callbacks[] = {
|
|
|
|
{ EV_A_CHANGED, _eo_signals_a_changed_cb },
|
|
|
|
{ EV_A_CHANGED, _eo_signals_a_changed_cb2 },
|
2013-04-12 05:46:30 -07:00
|
|
|
{ EV_A_CHANGED, _eo_signals_a_changed_never },
|
2013-04-12 03:06:30 -07:00
|
|
|
{ EO_EV_DEL, _eo_signals_eo_del_cb },
|
|
|
|
{ NULL, NULL }
|
|
|
|
};
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
|
|
|
|
eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_ADD, _eo_signals_cb_added_deled, callbacks));
|
|
|
|
eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_DEL, _eo_signals_cb_added_deled, callbacks));
|
|
|
|
eo_do(obj, eo_event_callback_array_priority_add(callbacks, -100, (void *) 1));
|
|
|
|
eo_do(obj, eo_event_callback_array_add(callbacks, (void *) 3));
|
|
|
|
eo_do(obj, eo_event_callback_array_priority_add(callbacks, -50, (void *) 2));
|
|
|
|
eo_do(obj, simple_a_set(1));
|
2013-04-12 03:06:30 -07:00
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 1));
|
|
|
|
eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 2));
|
|
|
|
eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 3));
|
2013-04-12 05:46:30 -07:00
|
|
|
/* Try to delete something that doesn't exist. */
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 4));
|
2013-04-12 03:06:30 -07:00
|
|
|
_eo_signals_cb_flag = 0;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, simple_a_set(1));
|
2013-04-12 03:06:30 -07:00
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x0);
|
|
|
|
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2014-05-20 07:31:53 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
/* Legacy support signals. */
|
|
|
|
{
|
|
|
|
const Eo_Event_Description *a_desc = eo_base_legacy_only_event_description_get("a,changed");
|
|
|
|
fail_if(!a_desc);
|
2015-09-28 16:45:34 -07:00
|
|
|
ck_assert_str_eq(a_desc->name, "\x01" "a,changed");
|
2014-05-20 07:31:53 -07:00
|
|
|
fail_if(a_desc == EV_A_CHANGED);
|
|
|
|
|
|
|
|
const Eo_Event_Description *bad_desc = eo_base_legacy_only_event_description_get("bad");
|
|
|
|
fail_if(!bad_desc);
|
2015-09-28 16:45:34 -07:00
|
|
|
ck_assert_str_eq(bad_desc->name, "\x01" "bad");
|
2014-05-20 07:31:53 -07:00
|
|
|
|
|
|
|
/* Call Eo event with legacy and non-legacy callbacks. */
|
|
|
|
_eo_signals_cb_current = 0;
|
|
|
|
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, -100, _eo_signals_a_changed_cb, (void *) 1));
|
|
|
|
eo_do(obj, eo_event_callback_add(a_desc, _eo_signals_a_changed_cb2, NULL));
|
|
|
|
eo_do(obj, simple_a_set(1));
|
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
|
|
|
|
|
|
|
|
/* Call legacy event with legacy and non-legacy callbacks. */
|
|
|
|
int a = 3;
|
|
|
|
_eo_signals_cb_current = 0;
|
|
|
|
_eo_signals_cb_flag = 0;
|
|
|
|
eo_do(obj, eo_event_callback_call(a_desc, &a));
|
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
|
|
|
|
}
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2013-04-12 03:06:30 -07:00
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2012-05-02 06:59:18 -07:00
|
|
|
START_TEST(eo_data_fetch)
|
|
|
|
{
|
|
|
|
eo_init();
|
|
|
|
|
2012-05-06 07:18:44 -07:00
|
|
|
/* Usually should be const, not const only for the test... */
|
|
|
|
static Eo_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-05-02 06:59:18 -07:00
|
|
|
"Simple2",
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_CLASS_DESCRIPTION_NOOPS(),
|
2012-05-02 06:59:18 -07:00
|
|
|
NULL,
|
|
|
|
10,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2014-04-02 04:01:16 -07:00
|
|
|
const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
|
2012-05-02 06:59:18 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(klass, NULL);
|
2012-05-02 06:59:18 -07:00
|
|
|
fail_if(!obj);
|
2013-01-18 08:57:57 -08:00
|
|
|
#ifdef EO_DEBUG
|
2013-03-19 23:56:15 -07:00
|
|
|
fail_if(eo_data_scope_get(obj, SIMPLE_CLASS));
|
2012-05-06 05:03:16 -07:00
|
|
|
#endif
|
|
|
|
eo_unref(obj);
|
2012-05-02 06:59:18 -07:00
|
|
|
|
2012-05-06 07:18:44 -07:00
|
|
|
class_desc.data_size = 0;
|
2014-04-02 04:01:16 -07:00
|
|
|
klass = eo_class_new(&class_desc, EO_CLASS, NULL);
|
2012-05-06 07:18:44 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(klass, NULL);
|
2012-05-06 07:18:44 -07:00
|
|
|
fail_if(!obj);
|
2013-03-19 23:56:15 -07:00
|
|
|
fail_if(eo_data_scope_get(obj, klass));
|
2012-05-06 07:18:44 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
|
2012-05-02 06:59:18 -07:00
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2012-06-14 03:29:39 -07:00
|
|
|
START_TEST(eo_isa_tests)
|
|
|
|
{
|
|
|
|
eo_init();
|
|
|
|
|
2013-09-27 08:26:25 -07:00
|
|
|
const Eo_Class *klass, *iface, *mixin;
|
2012-06-14 03:29:39 -07:00
|
|
|
|
|
|
|
{
|
|
|
|
/* Usually should be const, not const only for the test... */
|
|
|
|
static Eo_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-06-14 03:29:39 -07:00
|
|
|
"Iface",
|
|
|
|
EO_CLASS_TYPE_INTERFACE,
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_CLASS_DESCRIPTION_NOOPS(),
|
2012-06-14 03:29:39 -07:00
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2012-08-20 00:56:17 -07:00
|
|
|
iface = eo_class_new(&class_desc, NULL, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!iface);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
/* Usually should be const, not const only for the test... */
|
|
|
|
static Eo_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-06-14 03:29:39 -07:00
|
|
|
"Mixin",
|
|
|
|
EO_CLASS_TYPE_MIXIN,
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_CLASS_DESCRIPTION_NOOPS(),
|
2012-06-14 03:29:39 -07:00
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2012-08-20 00:56:17 -07:00
|
|
|
mixin = eo_class_new(&class_desc, NULL, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!mixin);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
/* Usually should be const, not const only for the test... */
|
|
|
|
static Eo_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-06-14 03:29:39 -07:00
|
|
|
"Simple2",
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_CLASS_DESCRIPTION_NOOPS(),
|
2012-06-14 03:29:39 -07:00
|
|
|
NULL,
|
|
|
|
10,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2014-04-02 04:01:16 -07:00
|
|
|
klass = eo_class_new(&class_desc, EO_CLASS, iface, mixin, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
}
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(klass, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
fail_if(eo_isa(obj, SIMPLE_CLASS));
|
|
|
|
fail_if(!eo_isa(obj, iface));
|
|
|
|
fail_if(!eo_isa(obj, mixin));
|
|
|
|
fail_if(!eo_isa(obj, klass));
|
2014-04-02 04:01:16 -07:00
|
|
|
fail_if(!eo_isa(obj, EO_CLASS));
|
2012-06-14 03:29:39 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
fail_if(eo_isa(obj, klass));
|
|
|
|
fail_if(eo_isa(obj, iface));
|
|
|
|
fail_if(eo_isa(obj, mixin));
|
|
|
|
fail_if(!eo_isa(obj, SIMPLE_CLASS));
|
2014-04-02 04:01:16 -07:00
|
|
|
fail_if(!eo_isa(obj, EO_CLASS));
|
2012-06-14 03:29:39 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
|
|
|
|
2012-06-07 03:54:15 -07:00
|
|
|
START_TEST(eo_composite_tests)
|
|
|
|
{
|
Eo: Remove GCCism and make it more portable.
This affects eo_do() and eo_add() that used to use the ({}) GCCism.
Following a discussion with Peter de Ridder after my talk at FOSDEM,
we've decided to reopen the GCCism (works with other gcc compatible
compilers like clang and intelc) discussion, and after a bit of back and
forth it was decided to make things more portable, at the cost of ease
of use.
For example:
if (eo_do(obj, visible_get()))
is no longer allowed, the portable alternative
Eina_Bool tmp;
if (eo_do_ret(obj, tmp, visible_get()))
is to be used instead.
However:
eo_do(obj, a = a_get(), b = b_get(), bool_set(!bool_get))
are still allowed and OK.
eo_do(obj, if (a_get()) return;);
is no longer allowed, but:
eo_do(obj, if (a_get()) something());
is still allowed.
For clarity, this commit only incorporates the Eo changes, and not the
EFL changes to make the efl conform with this change.
Thanks again to Peter de Ridder for triggering this important discussion
which led to this change.
2015-02-23 08:06:40 -08:00
|
|
|
Eina_Bool tmp;
|
2012-06-07 03:54:15 -07:00
|
|
|
eo_init();
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
2012-06-07 03:54:15 -07:00
|
|
|
fail_if(!obj);
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
|
2012-06-07 03:54:15 -07:00
|
|
|
fail_if(!obj2);
|
|
|
|
|
2014-10-21 04:37:00 -07:00
|
|
|
eo_do(obj, eo_composite_attach(obj2));
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj2, eo_parent_set(NULL));
|
Eo: Remove GCCism and make it more portable.
This affects eo_do() and eo_add() that used to use the ({}) GCCism.
Following a discussion with Peter de Ridder after my talk at FOSDEM,
we've decided to reopen the GCCism (works with other gcc compatible
compilers like clang and intelc) discussion, and after a bit of back and
forth it was decided to make things more portable, at the cost of ease
of use.
For example:
if (eo_do(obj, visible_get()))
is no longer allowed, the portable alternative
Eina_Bool tmp;
if (eo_do_ret(obj, tmp, visible_get()))
is to be used instead.
However:
eo_do(obj, a = a_get(), b = b_get(), bool_set(!bool_get))
are still allowed and OK.
eo_do(obj, if (a_get()) return;);
is no longer allowed, but:
eo_do(obj, if (a_get()) something());
is still allowed.
For clarity, this commit only incorporates the Eo changes, and not the
EFL changes to make the efl conform with this change.
Thanks again to Peter de Ridder for triggering this important discussion
which led to this change.
2015-02-23 08:06:40 -08:00
|
|
|
fail_if(eo_do_ret(obj2, tmp, eo_composite_part_is()));
|
2012-06-07 03:54:15 -07:00
|
|
|
|
|
|
|
eo_unref(obj2);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2012-06-10 07:04:53 -07:00
|
|
|
static Eina_Bool _man_should_con = EINA_TRUE;
|
|
|
|
static Eina_Bool _man_should_des = EINA_TRUE;
|
2013-09-27 08:26:25 -07:00
|
|
|
static const Eo_Class *cur_klass = NULL;
|
2012-06-10 07:04:53 -07:00
|
|
|
|
2015-05-19 03:41:27 -07:00
|
|
|
static Eo *
|
2012-06-10 07:04:53 -07:00
|
|
|
_man_con(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
|
2012-05-21 04:45:32 -07:00
|
|
|
{
|
2012-06-10 07:04:53 -07:00
|
|
|
if (_man_should_con)
|
|
|
|
eo_manual_free_set(obj, EINA_TRUE);
|
2015-05-19 03:41:27 -07:00
|
|
|
return eo_do_super_ret(obj, cur_klass, obj, eo_constructor());
|
2012-06-10 07:04:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
|
|
|
|
{
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do_super(obj, cur_klass, eo_destructor());
|
2012-06-10 07:04:53 -07:00
|
|
|
if (_man_should_des)
|
|
|
|
eo_manual_free_set(obj, EINA_FALSE);
|
2012-05-21 04:45:32 -07:00
|
|
|
}
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
static Eo_Op_Description op_descs[] = {
|
|
|
|
EO_OP_FUNC_OVERRIDE(eo_constructor, _man_con),
|
|
|
|
EO_OP_FUNC_OVERRIDE(eo_destructor, _man_des),
|
2013-11-08 04:25:39 -08:00
|
|
|
};
|
2012-05-21 04:45:32 -07:00
|
|
|
|
|
|
|
START_TEST(eo_man_free)
|
|
|
|
{
|
|
|
|
eo_init();
|
|
|
|
|
|
|
|
/* Usually should be const, not const only for the test... */
|
|
|
|
static Eo_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-05-21 04:45:32 -07:00
|
|
|
"Simple2",
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_CLASS_DESCRIPTION_OPS(op_descs),
|
2012-05-21 04:45:32 -07:00
|
|
|
NULL,
|
|
|
|
10,
|
2013-11-08 04:25:39 -08:00
|
|
|
NULL,
|
2012-05-21 04:45:32 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2014-04-02 04:01:16 -07:00
|
|
|
const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!klass);
|
2013-03-13 09:04:04 -07:00
|
|
|
cur_klass = klass;
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2013-11-26 04:10:53 -08:00
|
|
|
fail_if(eo_manual_free(obj));
|
2012-05-21 04:45:32 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
|
2012-06-10 07:04:53 -07:00
|
|
|
_man_should_des = EINA_FALSE;
|
2014-04-02 04:01:16 -07:00
|
|
|
klass = eo_class_new(&class_desc, EO_CLASS, NULL);
|
2013-03-13 09:04:04 -07:00
|
|
|
cur_klass = klass;
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2013-11-26 04:10:53 -08:00
|
|
|
fail_if(eo_manual_free(obj));
|
2012-09-12 04:31:58 -07:00
|
|
|
fail_if(eo_destructed_is(obj));
|
2012-05-21 04:45:32 -07:00
|
|
|
eo_unref(obj);
|
2012-09-12 04:31:58 -07:00
|
|
|
fail_if(!eo_destructed_is(obj));
|
2013-11-26 04:10:53 -08:00
|
|
|
fail_if(!eo_manual_free(obj));
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
eo_unref(obj);
|
2012-09-12 04:31:58 -07:00
|
|
|
fail_if(!eo_destructed_is(obj));
|
2013-11-26 04:10:53 -08:00
|
|
|
fail_if(!eo_manual_free(obj));
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2012-06-10 07:04:53 -07:00
|
|
|
_man_should_con = EINA_FALSE;
|
2014-04-02 04:01:16 -07:00
|
|
|
klass = eo_class_new(&class_desc, EO_CLASS, NULL);
|
2013-03-13 09:04:04 -07:00
|
|
|
cur_klass = klass;
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2013-11-26 04:10:53 -08:00
|
|
|
fail_if(eo_manual_free(obj));
|
2012-05-21 04:45:32 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(klass, NULL);
|
2012-06-10 00:53:43 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
eo_manual_free_set(obj, EINA_TRUE);
|
|
|
|
eo_unref(obj);
|
|
|
|
eo_ref(obj);
|
|
|
|
eo_unref(obj);
|
|
|
|
eo_unref(obj);
|
2013-11-26 04:10:53 -08:00
|
|
|
fail_if(!eo_manual_free(obj));
|
2012-08-23 03:37:46 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(klass, NULL);
|
2012-08-23 03:37:46 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
eo_manual_free_set(obj, EINA_TRUE);
|
|
|
|
eo_unref(obj);
|
|
|
|
eo_ref(obj);
|
|
|
|
eo_unref(obj);
|
|
|
|
eo_unref(obj);
|
|
|
|
eo_unref(obj);
|
|
|
|
eo_unref(obj);
|
2013-11-26 04:10:53 -08:00
|
|
|
fail_if(!eo_manual_free(obj));
|
2012-06-10 00:53:43 -07:00
|
|
|
|
2012-05-21 04:45:32 -07:00
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
START_TEST(eo_refs)
|
|
|
|
{
|
|
|
|
eo_init();
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj3 = eo_add(SIMPLE_CLASS, NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
|
|
|
eo_xref(obj, obj2);
|
|
|
|
fail_if(eo_ref_get(obj) != 2);
|
|
|
|
eo_xref(obj, obj3);
|
|
|
|
fail_if(eo_ref_get(obj) != 3);
|
|
|
|
|
|
|
|
eo_xunref(obj, obj2);
|
|
|
|
fail_if(eo_ref_get(obj) != 2);
|
|
|
|
eo_xunref(obj, obj3);
|
|
|
|
fail_if(eo_ref_get(obj) != 1);
|
|
|
|
|
2013-01-18 08:57:57 -08:00
|
|
|
#ifdef EO_DEBUG
|
2012-05-01 00:40:14 -07:00
|
|
|
eo_xunref(obj, obj3);
|
|
|
|
fail_if(eo_ref_get(obj) != 1);
|
|
|
|
|
|
|
|
eo_xref(obj, obj2);
|
|
|
|
fail_if(eo_ref_get(obj) != 2);
|
|
|
|
|
|
|
|
eo_xunref(obj, obj3);
|
|
|
|
fail_if(eo_ref_get(obj) != 2);
|
|
|
|
|
|
|
|
eo_xunref(obj, obj2);
|
|
|
|
fail_if(eo_ref_get(obj) != 1);
|
|
|
|
#endif
|
|
|
|
|
2012-06-07 03:54:17 -07:00
|
|
|
/* Check we don't seg if there's an extra xref. */
|
|
|
|
eo_xref(obj, obj2);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
eo_unref(obj2);
|
|
|
|
eo_unref(obj3);
|
|
|
|
|
2012-06-07 03:54:17 -07:00
|
|
|
/* Check hierarchy */
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
2014-09-25 07:51:17 -07:00
|
|
|
obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj));
|
2012-06-07 03:54:17 -07:00
|
|
|
|
2013-12-30 13:16:55 -08:00
|
|
|
Eo *wref = NULL;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj2, eo_wref_add(&wref));
|
2012-06-07 03:54:17 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
|
|
|
|
eo_unref(obj2);
|
|
|
|
|
|
|
|
fail_if(!wref); /* Parent is still holding a reference. */
|
|
|
|
|
|
|
|
eo_unref(obj);
|
|
|
|
|
|
|
|
fail_if(wref);
|
|
|
|
|
2014-09-25 07:51:17 -07:00
|
|
|
/* eo_add_ref and normal eo_add */
|
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj2 = eo_add(SIMPLE_CLASS, obj);
|
|
|
|
obj3 = eo_add_ref(SIMPLE_CLASS, obj);
|
|
|
|
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj), 1);
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj2), 1);
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj3), 2);
|
|
|
|
|
2015-08-26 02:47:06 -07:00
|
|
|
/* Setting and removing parents. */
|
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj));
|
|
|
|
obj3 = eo_ref(eo_add(SIMPLE_CLASS, NULL));
|
|
|
|
|
|
|
|
eo_do(obj2, eo_parent_set(obj3));
|
|
|
|
eo_do(obj3, eo_parent_set(obj));
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj2), 2);
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj3), 2);
|
|
|
|
|
|
|
|
eo_do(obj2, eo_parent_set(NULL));
|
|
|
|
eo_do(obj3, eo_parent_set(NULL));
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj2), 1);
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj3), 1);
|
|
|
|
|
|
|
|
eo_do(obj2, eo_parent_set(obj));
|
|
|
|
eo_do(obj3, eo_parent_set(obj));
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj2), 1);
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj3), 1);
|
|
|
|
|
|
|
|
eo_del(obj);
|
|
|
|
eo_del(obj2);
|
|
|
|
eo_del(obj3);
|
2014-09-25 07:51:17 -07:00
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
/* Just check it doesn't seg atm. */
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
eo_ref(obj);
|
2012-06-03 01:42:08 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
eo_unref(obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj2 = eo_add(SIMPLE_CLASS, obj);
|
2012-06-07 00:17:45 -07:00
|
|
|
eo_unref(obj2);
|
|
|
|
eo_ref(obj2);
|
|
|
|
eo_del(obj2);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
|
|
|
START_TEST(eo_weak_reference)
|
|
|
|
{
|
|
|
|
eo_init();
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
|
2013-12-30 13:16:55 -08:00
|
|
|
Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_add(&wref));
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
|
|
|
|
eo_unref(obj);
|
|
|
|
fail_if(wref);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
eo_do(obj, eo_wref_add(&wref));
|
2012-05-01 00:40:14 -07:00
|
|
|
|
|
|
|
eo_ref(obj);
|
|
|
|
fail_if(!wref);
|
|
|
|
|
2012-06-03 01:42:08 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
fail_if(!wref);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
|
|
|
eo_unref(obj);
|
|
|
|
fail_if(wref);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_add(&wref));
|
|
|
|
eo_do(obj, eo_wref_del(&wref));
|
2012-05-01 04:25:00 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_add(&wref));
|
|
|
|
eo_do(obj2, eo_wref_del(&wref));
|
2012-05-01 04:25:00 -07:00
|
|
|
fail_if(!wref);
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_wref_del_safe(&wref);
|
2012-05-01 04:25:00 -07:00
|
|
|
fail_if(wref);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2012-05-01 05:38:14 -07:00
|
|
|
wref = obj;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_del(&wref));
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
|
|
|
wref = wref2 = wref3 = NULL;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_add(&wref), eo_wref_add(&wref2), eo_wref_add(&wref3));
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
fail_if(!wref2);
|
|
|
|
fail_if(!wref3);
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_del(&wref), eo_wref_del(&wref2), eo_wref_del(&wref3));
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
fail_if(wref2);
|
|
|
|
fail_if(wref3);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_add(&wref2), eo_wref_add(&wref3));
|
2012-05-01 07:00:14 -07:00
|
|
|
wref = obj;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_del(&wref));
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_wref_del(&wref2), eo_wref_del(&wref3));
|
2012-05-01 05:38:14 -07:00
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
eo_unref(obj);
|
2012-05-01 04:25:00 -07:00
|
|
|
eo_unref(obj2);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
|
|
|
START_TEST(eo_generic_data)
|
|
|
|
{
|
|
|
|
eo_init();
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
2013-12-30 13:16:55 -08:00
|
|
|
void *data = NULL;
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2015-05-28 09:47:33 -07:00
|
|
|
eo_do(obj, eo_key_data_set("test1", (void *) 1));
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, data = eo_key_data_get("test1"));
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, eo_key_data_del("test1"));
|
|
|
|
eo_do(obj, data = eo_key_data_get("test1"));
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
2015-05-28 09:47:33 -07:00
|
|
|
eo_do(obj, eo_key_data_set("test1", (void *) 1));
|
|
|
|
eo_do(obj, eo_key_data_set("test2", (void *) 2));
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, data = eo_key_data_get("test1"));
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, data = eo_key_data_get("test2"));
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(2 != (intptr_t) data);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, data = eo_key_data_get("test2"));
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(2 != (intptr_t) data);
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, eo_key_data_del("test2"));
|
|
|
|
eo_do(obj, data = eo_key_data_get("test2"));
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, data = eo_key_data_get("test1"));
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2014-04-02 03:42:00 -07:00
|
|
|
eo_do(obj, eo_key_data_del("test1"));
|
|
|
|
eo_do(obj, data = eo_key_data_get("test1"));
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
|
|
|
eo_unref(obj);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2013-11-08 04:25:39 -08:00
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
START_TEST(eo_magic_checks)
|
|
|
|
{
|
2012-05-21 04:45:37 -07:00
|
|
|
char _buf[sizeof(long)]; /* Just enough to hold eina magic + a bit more. */
|
|
|
|
char *buf = _buf;
|
2012-05-01 00:40:14 -07:00
|
|
|
eo_init();
|
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
memset(_buf, 1, sizeof(_buf));
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, (Eo *) buf);
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(obj);
|
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
while (1)
|
|
|
|
{
|
2013-11-08 04:25:39 -08:00
|
|
|
int i = 20, a = 0;
|
2013-09-24 23:29:19 -07:00
|
|
|
Eo *parent = NULL;
|
|
|
|
Eo *wref = NULL;
|
2013-11-20 04:16:47 -08:00
|
|
|
Eo *obj2 = NULL;
|
2013-09-24 23:29:19 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add((Eo_Class *) buf, NULL);
|
2012-05-21 04:45:37 -07:00
|
|
|
fail_if(obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL);
|
2012-05-21 04:45:37 -07:00
|
|
|
fail_if(!obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do((Eo *) buf, simple_a_set(++i), a = simple_a_get());
|
2013-11-08 04:25:39 -08:00
|
|
|
ck_assert_int_ne(i, a);
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do_super((Eo *) buf, SIMPLE_CLASS, simple_a_set(++i));
|
|
|
|
eo_do_super((Eo *) buf, SIMPLE_CLASS, a = simple_a_get());
|
2013-11-08 04:25:39 -08:00
|
|
|
ck_assert_int_ne(i, a);
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do_super(obj, (const Eo_Class *) buf, simple_a_set(++i));
|
|
|
|
eo_do_super(obj, (const Eo_Class *) buf, a = simple_a_get());
|
2013-11-11 02:47:13 -08:00
|
|
|
ck_assert_int_ne(i, a);
|
2012-05-21 04:45:37 -07:00
|
|
|
fail_if(eo_class_get((Eo *) buf));
|
2013-09-27 08:26:25 -07:00
|
|
|
fail_if(eo_class_name_get((Eo_Class*) buf));
|
2013-10-12 14:56:17 -07:00
|
|
|
fail_if(eo_class_get(obj) != SIMPLE_CLASS);
|
2014-06-02 05:09:21 -07:00
|
|
|
fail_if(eo_class_get(SIMPLE_CLASS) != EO_ABSTRACT_CLASS_CLASS);
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do((Eo_Class *) buf,(void) NULL);
|
|
|
|
eo_do_super((Eo_Class *) buf, SIMPLE_CLASS, simple_a_set(++i));
|
|
|
|
eo_do_super(SIMPLE_CLASS, (Eo_Class *) buf, simple_a_set(++i));
|
2013-09-27 08:26:25 -07:00
|
|
|
fail_if(eo_class_new(NULL, (Eo_Class *) buf), NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
eo_xref(obj, (Eo *) buf);
|
|
|
|
eo_xunref(obj, (Eo *) buf);
|
|
|
|
eo_xref((Eo *) buf, obj);
|
|
|
|
eo_xunref((Eo *) buf, obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
eo_ref((Eo *) buf);
|
|
|
|
eo_unref((Eo *) buf);
|
2012-06-07 00:17:45 -07:00
|
|
|
eo_del((Eo *) buf);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2012-06-14 03:29:39 -07:00
|
|
|
eo_isa((Eo *) buf, SIMPLE_CLASS);
|
2013-09-27 08:26:25 -07:00
|
|
|
eo_isa(obj, (Eo_Class *) buf);
|
2012-06-14 03:29:39 -07:00
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
fail_if(0 != eo_ref_get((Eo *) buf));
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do((Eo *) buf,
|
|
|
|
eo_wref_add(&wref),
|
|
|
|
parent = eo_parent_get());
|
2012-05-21 04:45:37 -07:00
|
|
|
fail_if(wref);
|
2013-09-24 23:29:19 -07:00
|
|
|
fail_if(parent);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2013-03-19 23:56:15 -07:00
|
|
|
fail_if(eo_data_scope_get((Eo *) buf, SIMPLE_CLASS));
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-10-21 04:37:00 -07:00
|
|
|
eo_do(obj, eo_composite_attach((Eo *) buf));
|
|
|
|
eo_do(obj, eo_composite_detach((Eo *) buf));
|
|
|
|
eo_do((Eo *) buf, eo_composite_part_is());
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, eo_event_callback_forwarder_add(NULL, (Eo *) buf));
|
|
|
|
eo_do(obj, eo_event_callback_forwarder_del(NULL, (Eo *) buf));
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
eo_manual_free_set((Eo *) buf, EINA_TRUE);
|
|
|
|
eo_manual_free((Eo *) buf);
|
2012-09-12 04:31:58 -07:00
|
|
|
eo_destructed_is((Eo *) buf);
|
2012-05-21 04:45:37 -07:00
|
|
|
|
2013-11-20 04:16:47 -08:00
|
|
|
obj2 = NULL;
|
|
|
|
eo_do(obj, eo_parent_set((Eo *) buf));
|
2014-04-02 07:30:13 -07:00
|
|
|
eo_do(obj, obj2 = eo_parent_get());
|
2013-11-20 04:16:47 -08:00
|
|
|
fail_if(obj2 && (obj2 == (Eo *) buf));
|
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
eo_unref(obj);
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
buf = NULL;
|
|
|
|
}
|
2012-05-01 00:40:14 -07:00
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2012-07-23 01:43:35 -07:00
|
|
|
/* MULTI */
|
|
|
|
|
2013-11-08 04:25:39 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
|
2012-07-23 01:43:35 -07:00
|
|
|
{
|
|
|
|
printf("Hey\n");
|
|
|
|
|
2013-11-08 04:25:39 -08:00
|
|
|
return EINA_TRUE;
|
2012-07-23 01:43:35 -07:00
|
|
|
}
|
|
|
|
|
2013-11-08 04:25:39 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_class_hi_print(Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
|
2012-07-23 01:43:35 -07:00
|
|
|
{
|
2013-11-08 04:25:39 -08:00
|
|
|
printf("Hi\n");
|
2012-07-23 01:43:35 -07:00
|
|
|
|
2013-11-08 04:25:39 -08:00
|
|
|
return EINA_TRUE;
|
2012-07-23 01:43:35 -07:00
|
|
|
}
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE);
|
|
|
|
EO_FUNC_BODY(multi_class_hi_print, Eina_Bool, EINA_FALSE);
|
2012-07-23 01:43:35 -07:00
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
static Eo_Op_Description _multi_do_op_descs[] = {
|
2015-09-28 06:15:15 -07:00
|
|
|
EO_OP_FUNC(multi_a_print, _a_print),
|
|
|
|
EO_OP_FUNC(multi_class_hi_print, _class_hi_print),
|
2013-11-08 04:25:39 -08:00
|
|
|
};
|
2012-07-23 01:43:35 -07:00
|
|
|
|
|
|
|
START_TEST(eo_multiple_do)
|
|
|
|
{
|
|
|
|
eo_init();
|
|
|
|
|
|
|
|
/* Usually should be const, not const only for the test... */
|
|
|
|
static Eo_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-07-23 01:43:35 -07:00
|
|
|
"Inherit",
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_CLASS_DESCRIPTION_OPS(_multi_do_op_descs),
|
2012-07-23 01:43:35 -07:00
|
|
|
NULL,
|
|
|
|
0,
|
2013-11-08 04:25:39 -08:00
|
|
|
NULL,
|
2012-07-23 01:43:35 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2013-09-27 08:26:25 -07:00
|
|
|
const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL);
|
2012-07-23 01:43:35 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(klass, NULL);
|
2012-07-23 01:43:35 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
|
2013-11-08 04:25:39 -08:00
|
|
|
Eina_Bool ca, cb, cc;
|
|
|
|
|
|
|
|
ca = cb = cc = EINA_FALSE;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(obj, ca = simple_a_print(), cb = multi_a_print(), cc = multi_a_print());
|
2013-11-08 04:25:39 -08:00
|
|
|
fail_if(!(ca && cb && cc));
|
|
|
|
|
|
|
|
ca = cb = cc = EINA_FALSE;
|
2014-04-02 01:46:34 -07:00
|
|
|
eo_do(klass, ca = simple_class_hi_print(), cb = multi_class_hi_print(), cc = multi_class_hi_print());
|
2013-11-08 04:25:39 -08:00
|
|
|
fail_if(!(ca && cb && cc));
|
2012-07-23 01:43:35 -07:00
|
|
|
|
|
|
|
eo_unref(obj);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
START_TEST(eo_add_do_and_custom)
|
2012-08-23 03:35:14 -07:00
|
|
|
{
|
|
|
|
Simple_Public_Data *pd = NULL;
|
|
|
|
Eo *obj = NULL;
|
|
|
|
eo_init();
|
|
|
|
|
2014-09-25 02:24:27 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, eo_constructor());
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2014-04-02 01:46:34 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, simple_a_set(7));
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(!obj);
|
2013-03-19 23:56:15 -07:00
|
|
|
pd = eo_data_scope_get(obj, SIMPLE_CLASS);
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(pd->a != 7);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2014-09-25 02:24:27 -07:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, eo_constructor(), simple_a_set(7));
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(!obj);
|
2013-03-19 23:56:15 -07:00
|
|
|
pd = eo_data_scope_get(obj, SIMPLE_CLASS);
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(pd->a != 7);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2014-08-29 01:55:02 -07:00
|
|
|
Eina_Bool finalized;
|
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, finalized = eo_finalized_get());
|
|
|
|
fail_if(finalized);
|
|
|
|
|
Eo: Remove GCCism and make it more portable.
This affects eo_do() and eo_add() that used to use the ({}) GCCism.
Following a discussion with Peter de Ridder after my talk at FOSDEM,
we've decided to reopen the GCCism (works with other gcc compatible
compilers like clang and intelc) discussion, and after a bit of back and
forth it was decided to make things more portable, at the cost of ease
of use.
For example:
if (eo_do(obj, visible_get()))
is no longer allowed, the portable alternative
Eina_Bool tmp;
if (eo_do_ret(obj, tmp, visible_get()))
is to be used instead.
However:
eo_do(obj, a = a_get(), b = b_get(), bool_set(!bool_get))
are still allowed and OK.
eo_do(obj, if (a_get()) return;);
is no longer allowed, but:
eo_do(obj, if (a_get()) something());
is still allowed.
For clarity, this commit only incorporates the Eo changes, and not the
EFL changes to make the efl conform with this change.
Thanks again to Peter de Ridder for triggering this important discussion
which led to this change.
2015-02-23 08:06:40 -08:00
|
|
|
eo_do(obj, finalized = eo_finalized_get());
|
2014-08-29 01:55:02 -07:00
|
|
|
fail_if(!finalized);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2012-08-23 03:35:14 -07:00
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2013-04-18 03:55:55 -07:00
|
|
|
START_TEST(eo_pointers_indirection)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_EO_ID
|
|
|
|
eo_init();
|
|
|
|
|
|
|
|
static const Eo_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2013-04-18 03:55:55 -07:00
|
|
|
"Simple",
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_CLASS_DESCRIPTION_NOOPS(),
|
2013-04-18 03:55:55 -07:00
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2014-04-02 04:01:16 -07:00
|
|
|
const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
|
|
|
/* Check simple id validity */
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(klass, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
fail_if(!eo_isa(obj, klass));
|
|
|
|
obj = (Eo *)((char *)(obj) + 1);
|
|
|
|
fail_if(eo_isa(obj, klass));
|
|
|
|
obj = (Eo *)((char *)(obj) - 1);
|
|
|
|
fail_if(!eo_isa(obj, klass));
|
|
|
|
eo_unref(obj);
|
|
|
|
fail_if(eo_isa(obj, klass));
|
|
|
|
|
|
|
|
/* Check id invalidity after deletion */
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj1 = eo_add(klass, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!obj1);
|
|
|
|
eo_unref(obj1);
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj2 = eo_add(klass, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!obj2);
|
|
|
|
fail_if(!eo_isa(obj2, klass));
|
|
|
|
fail_if(eo_isa(obj1, klass));
|
|
|
|
eo_unref(obj2);
|
|
|
|
|
2014-10-22 03:43:45 -07:00
|
|
|
/* Check id sanity checks for "close enough" ids. */
|
|
|
|
obj1 = eo_add(klass, NULL);
|
|
|
|
fail_if(!obj1);
|
|
|
|
obj2 = (Eo *) (((Eo_Id) obj1) & ~MASK_OBJ_TAG);
|
|
|
|
fail_if(eo_class_get(obj2));
|
|
|
|
eo_unref(obj1);
|
|
|
|
|
2013-05-06 15:34:50 -07:00
|
|
|
#define NB_OBJS 10000
|
2013-04-18 03:55:55 -07:00
|
|
|
unsigned int obj_id;
|
|
|
|
Eo **objs = calloc(NB_OBJS, sizeof(Eo *));
|
|
|
|
fail_if(!objs);
|
|
|
|
/* Creation of the objects */
|
|
|
|
for ( obj_id = 0; obj_id < NB_OBJS; obj_id++)
|
|
|
|
{
|
2014-04-02 01:46:34 -07:00
|
|
|
objs[obj_id] = eo_add(klass, NULL);
|
2013-05-07 14:40:53 -07:00
|
|
|
if(!objs[obj_id])
|
|
|
|
fail_if(!objs[obj_id]);
|
|
|
|
if(!eo_isa(objs[obj_id], klass))
|
|
|
|
fail_if(!eo_isa(objs[obj_id], klass));
|
2013-04-18 03:55:55 -07:00
|
|
|
}
|
2013-09-28 23:34:03 -07:00
|
|
|
/* Deletion of a few objects */
|
|
|
|
for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000)
|
2013-04-18 03:55:55 -07:00
|
|
|
{
|
|
|
|
eo_unref(objs[obj_id]);
|
2013-05-07 14:40:53 -07:00
|
|
|
if(eo_isa(objs[obj_id], klass))
|
|
|
|
fail_if(eo_isa(objs[obj_id], klass));
|
2013-04-18 03:55:55 -07:00
|
|
|
}
|
2013-09-28 23:34:03 -07:00
|
|
|
/* Creation of the deleted objects */
|
|
|
|
for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000)
|
2013-04-18 03:55:55 -07:00
|
|
|
{
|
2014-04-02 01:46:34 -07:00
|
|
|
objs[obj_id] = eo_add(klass, NULL);
|
2013-05-07 14:40:53 -07:00
|
|
|
if(!objs[obj_id])
|
|
|
|
fail_if(!objs[obj_id]);
|
|
|
|
if(!eo_isa(objs[obj_id], klass))
|
|
|
|
fail_if(!eo_isa(objs[obj_id], klass));
|
2013-04-18 03:55:55 -07:00
|
|
|
}
|
|
|
|
/* Deletion of all the objects */
|
|
|
|
for ( obj_id = 0; obj_id < NB_OBJS; obj_id++)
|
|
|
|
eo_unref(objs[obj_id]);
|
2013-05-06 15:34:50 -07:00
|
|
|
/* Just be sure that we trigger an already freed error */
|
|
|
|
eo_unref(objs[0]);
|
2013-04-18 03:55:55 -07:00
|
|
|
free(objs);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2014-05-30 03:17:36 -07:00
|
|
|
|
|
|
|
static Eo *
|
|
|
|
_eo_add_failures_finalize(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eo_Op_Description _eo_add_failures_op_descs[] = {
|
|
|
|
EO_OP_FUNC_OVERRIDE(eo_finalize, _eo_add_failures_finalize),
|
|
|
|
};
|
|
|
|
|
|
|
|
START_TEST(eo_add_failures)
|
|
|
|
{
|
|
|
|
eo_init();
|
|
|
|
|
|
|
|
static const Eo_Class_Description class_desc = {
|
|
|
|
EO_VERSION,
|
|
|
|
"Simple2",
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
|
|
|
EO_CLASS_DESCRIPTION_OPS(_eo_add_failures_op_descs),
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
|
|
|
|
|
|
|
|
Eo *obj = eo_add(klass, NULL);
|
|
|
|
|
|
|
|
fail_if(obj);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2015-04-17 06:31:19 -07:00
|
|
|
START_TEST(eo_parts)
|
|
|
|
{
|
|
|
|
int a = 0;
|
|
|
|
|
|
|
|
eo_init();
|
|
|
|
|
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
|
|
|
|
|
|
|
eo_do(obj, simple_a_set(3), a = simple_a_get());
|
|
|
|
ck_assert_int_eq(a, 3);
|
|
|
|
|
|
|
|
eo_do_part(obj, simple_part_get("test"),
|
|
|
|
simple_a_set(7),
|
|
|
|
a = simple_a_get()
|
|
|
|
);
|
|
|
|
ck_assert_int_eq(a, 7);
|
|
|
|
|
|
|
|
eo_do(obj, simple_a_set(3), a = simple_a_get());
|
|
|
|
ck_assert_int_eq(a, 3);
|
|
|
|
|
|
|
|
/* Faking a call, just asserting NULL as the part to check default values. */
|
|
|
|
eo_do_part(obj, NULL,
|
|
|
|
simple_a_set(7),
|
|
|
|
a = simple_a_get()
|
|
|
|
);
|
|
|
|
ck_assert_int_eq(a, 0);
|
|
|
|
|
|
|
|
eo_del(obj);
|
|
|
|
|
|
|
|
eo_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
void eo_test_general(TCase *tc)
|
|
|
|
{
|
|
|
|
tcase_add_test(tc, eo_simple);
|
2013-12-30 06:24:44 -08:00
|
|
|
tcase_add_test(tc, eo_stack);
|
2013-11-08 04:25:39 -08:00
|
|
|
tcase_add_test(tc, eo_signals);
|
2012-05-02 06:59:18 -07:00
|
|
|
tcase_add_test(tc, eo_data_fetch);
|
2012-06-14 03:29:39 -07:00
|
|
|
tcase_add_test(tc, eo_isa_tests);
|
2013-11-08 04:25:39 -08:00
|
|
|
tcase_add_test(tc, eo_composite_tests);
|
|
|
|
tcase_add_test(tc, eo_man_free);
|
|
|
|
tcase_add_test(tc, eo_refs);
|
|
|
|
tcase_add_test(tc, eo_weak_reference);
|
|
|
|
tcase_add_test(tc, eo_generic_data);
|
|
|
|
tcase_add_test(tc, eo_magic_checks);
|
2012-07-23 01:43:35 -07:00
|
|
|
tcase_add_test(tc, eo_multiple_do);
|
2014-04-02 01:46:34 -07:00
|
|
|
tcase_add_test(tc, eo_add_do_and_custom);
|
2013-04-18 03:55:55 -07:00
|
|
|
tcase_add_test(tc, eo_pointers_indirection);
|
2014-05-30 03:17:36 -07:00
|
|
|
tcase_add_test(tc, eo_add_failures);
|
2015-04-17 06:31:19 -07:00
|
|
|
tcase_add_test(tc, eo_parts);
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|