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
|
|
|
|
2016-02-04 06:02:57 -08: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);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_constructor(obj);
|
|
|
|
eo_destructor(obj);
|
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);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
simple_recursive(obj, 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
|
2016-02-29 02:18:40 -08:00
|
|
|
_eo_signals_a_changed_cb(void *_data, const Eo_Event *event EINA_UNUSED)
|
2013-04-12 03:06:30 -07:00
|
|
|
{
|
|
|
|
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
|
2016-02-29 02:18:40 -08:00
|
|
|
_eo_signals_a_changed_cb2(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED)
|
2013-04-12 03:06:30 -07:00
|
|
|
{
|
|
|
|
_eo_signals_cb_flag |= 0x2;
|
2013-04-12 05:46:30 -07:00
|
|
|
return EO_CALLBACK_STOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2016-02-29 02:18:40 -08:00
|
|
|
_eo_signals_a_changed_never(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED)
|
2013-04-12 05:46:30 -07:00
|
|
|
{
|
|
|
|
/* This one should never be called. */
|
|
|
|
fail_if(1);
|
2013-04-12 03:06:30 -07:00
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2016-02-29 02:18:40 -08:00
|
|
|
_eo_signals_eo_del_cb(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED)
|
2013-04-12 03:06:30 -07:00
|
|
|
{
|
|
|
|
_eo_signals_cb_flag |= 0x4;
|
|
|
|
return EO_CALLBACK_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
2016-02-29 02:18:40 -08:00
|
|
|
_eo_signals_cb_added_deled(void *data, const Eo_Event *event)
|
2013-04-12 03:06:30 -07:00
|
|
|
{
|
2016-02-29 02:18:40 -08:00
|
|
|
const Eo_Callback_Array_Item *callback_array = event->event_info;
|
2013-04-12 03:06:30 -07:00
|
|
|
|
|
|
|
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 },
|
2016-01-20 20:10:05 -08:00
|
|
|
{ EO_BASE_EVENT_DEL, _eo_signals_eo_del_cb },
|
2013-04-12 03:06:30 -07:00
|
|
|
{ NULL, NULL }
|
|
|
|
};
|
2014-04-02 01:46:34 -07:00
|
|
|
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
|
2016-02-04 21:21:56 -08:00
|
|
|
Eina_Bool r;
|
2014-04-02 01:46:34 -07:00
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_event_callback_add(obj, EO_BASE_EVENT_CALLBACK_ADD, _eo_signals_cb_added_deled, callbacks);
|
|
|
|
r = eo_event_callback_add(obj, EO_BASE_EVENT_CALLBACK_DEL, _eo_signals_cb_added_deled, callbacks);
|
2016-02-04 21:21:56 -08:00
|
|
|
fail_if(!r);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_event_callback_array_priority_add(obj, callbacks, -100, (void *) 1);
|
|
|
|
eo_event_callback_array_add(obj, callbacks, (void *) 3);
|
|
|
|
r = eo_event_callback_array_priority_add(obj, callbacks, -50, (void *) 2);
|
2016-02-04 21:21:56 -08:00
|
|
|
fail_if(!r);
|
2016-03-01 10:06:28 -08:00
|
|
|
simple_a_set(obj, 1);
|
2013-04-12 03:06:30 -07:00
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_event_callback_array_del(obj, callbacks, (void *) 1);
|
|
|
|
eo_event_callback_array_del(obj, callbacks, (void *) 2);
|
|
|
|
r = eo_event_callback_array_del(obj, callbacks, (void *) 3);
|
2016-02-04 21:21:56 -08:00
|
|
|
fail_if(!r);
|
2013-04-12 05:46:30 -07:00
|
|
|
/* Try to delete something that doesn't exist. */
|
2016-03-01 10:06:28 -08:00
|
|
|
r = eo_event_callback_array_del(obj, callbacks, (void *) 4);
|
2016-02-04 21:21:56 -08:00
|
|
|
fail_if(r);
|
2013-04-12 03:06:30 -07:00
|
|
|
_eo_signals_cb_flag = 0;
|
2016-03-01 10:06:28 -08:00
|
|
|
simple_a_set(obj, 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-10-16 03:42:37 -07:00
|
|
|
ck_assert_str_eq(a_desc->name, "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-10-16 03:42:37 -07:00
|
|
|
ck_assert_str_eq(bad_desc->name, "bad");
|
2014-05-20 07:31:53 -07:00
|
|
|
|
|
|
|
/* Call Eo event with legacy and non-legacy callbacks. */
|
|
|
|
_eo_signals_cb_current = 0;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_event_callback_priority_add(obj, EV_A_CHANGED2, -1000, _eo_signals_a_changed_never, (void *) 1);
|
|
|
|
eo_event_callback_priority_add(obj, EV_A_CHANGED, -100, _eo_signals_a_changed_cb, (void *) 1);
|
|
|
|
eo_event_callback_add(obj, a_desc, _eo_signals_a_changed_cb2, NULL);
|
|
|
|
simple_a_set(obj, 1);
|
2014-05-20 07:31:53 -07:00
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
|
|
|
|
|
2015-09-29 01:14:32 -07:00
|
|
|
/* We don't need this one anymore. */
|
2016-03-01 10:06:28 -08:00
|
|
|
r = eo_event_callback_del(obj, EV_A_CHANGED2, _eo_signals_a_changed_never, (void *) 1);
|
2016-02-04 21:21:56 -08:00
|
|
|
fail_if(!r);
|
2015-09-29 01:14:32 -07:00
|
|
|
|
2014-05-20 07:31:53 -07:00
|
|
|
/* Call legacy event with legacy and non-legacy callbacks. */
|
|
|
|
int a = 3;
|
|
|
|
_eo_signals_cb_current = 0;
|
|
|
|
_eo_signals_cb_flag = 0;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_event_callback_call(obj, a_desc, &a);
|
2014-05-20 07:31:53 -07:00
|
|
|
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);
|
2016-03-04 06:03:41 -08:00
|
|
|
fail_if(eo_data_get(obj, klass));
|
2013-03-19 23:56:15 -07:00
|
|
|
fail_if(eo_data_scope_get(obj, klass));
|
2016-03-04 06:03:41 -08:00
|
|
|
fail_if(!eo_data_scope_get(obj, EO_BASE_CLASS));
|
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_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);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_composite_attach(obj, obj2);
|
|
|
|
eo_parent_set(obj2, NULL);
|
|
|
|
fail_if(eo_composite_part_is(obj2));
|
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);
|
2016-03-01 10:06:28 -08:00
|
|
|
return eo_constructor(eo_super(obj, cur_klass));
|
2012-06-10 07:04:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
|
|
|
|
{
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_destructor(eo_super(obj, cur_klass));
|
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;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add(obj2, &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));
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_parent_set(obj2, obj3);
|
|
|
|
eo_parent_set(obj3, obj);
|
2015-08-26 02:47:06 -07:00
|
|
|
ck_assert_int_eq(eo_ref_get(obj2), 2);
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj3), 2);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_parent_set(obj2, NULL);
|
|
|
|
eo_parent_set(obj3, NULL);
|
2015-08-26 02:47:06 -07:00
|
|
|
ck_assert_int_eq(eo_ref_get(obj2), 1);
|
|
|
|
ck_assert_int_eq(eo_ref_get(obj3), 1);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_parent_set(obj2, obj);
|
|
|
|
eo_parent_set(obj3, obj);
|
2015-08-26 02:47:06 -07:00
|
|
|
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;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add(obj, &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);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add(obj, &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
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add(obj, &wref);
|
|
|
|
eo_wref_del(obj, &wref);
|
2012-05-01 04:25:00 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add(obj, &wref);
|
|
|
|
eo_wref_del(obj2, &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;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_del(obj, &wref);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
|
|
|
wref = wref2 = wref3 = NULL;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add(obj, &wref);
|
|
|
|
eo_wref_add(obj, &wref2);
|
|
|
|
eo_wref_add(obj, &wref3);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
fail_if(!wref2);
|
|
|
|
fail_if(!wref3);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_del(obj, &wref);
|
|
|
|
eo_wref_del(obj, &wref2);
|
|
|
|
eo_wref_del(obj, &wref3);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
fail_if(wref2);
|
|
|
|
fail_if(wref3);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add(obj, &wref2);
|
|
|
|
eo_wref_add(obj, &wref3);
|
2012-05-01 07:00:14 -07:00
|
|
|
wref = obj;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_del(obj, &wref);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_del(obj, &wref2);
|
|
|
|
eo_wref_del(obj, &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
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_key_data_set(obj, "test1", (void *) 1);
|
|
|
|
data = eo_key_data_get(obj, "test1");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_key_data_del(obj, "test1");
|
|
|
|
data = eo_key_data_get(obj, "test1");
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_key_data_set(obj, "test1", (void *) 1);
|
|
|
|
eo_key_data_set(obj, "test2", (void *) 2);
|
|
|
|
data = eo_key_data_get(obj, "test1");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2016-03-01 10:06:28 -08:00
|
|
|
data = eo_key_data_get(obj, "test2");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(2 != (intptr_t) data);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
data = eo_key_data_get(obj, "test2");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(2 != (intptr_t) data);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_key_data_del(obj, "test2");
|
|
|
|
data = eo_key_data_get(obj, "test2");
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
data = eo_key_data_get(obj, "test1");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_key_data_del(obj, "test1");
|
|
|
|
data = eo_key_data_get(obj, "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
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
simple_a_set((Eo *) buf, ++i);
|
|
|
|
a = simple_a_get((Eo *) buf);
|
2013-11-08 04:25:39 -08:00
|
|
|
ck_assert_int_ne(i, a);
|
2016-03-01 10:06:28 -08:00
|
|
|
simple_a_set(eo_super((Eo *) buf, SIMPLE_CLASS), ++i);
|
|
|
|
a = simple_a_get(eo_super((Eo *) buf, SIMPLE_CLASS));
|
2013-11-08 04:25:39 -08:00
|
|
|
ck_assert_int_ne(i, a);
|
2016-03-01 10:06:28 -08:00
|
|
|
simple_a_set(eo_super(obj, (const Eo_Class *) buf), ++i);
|
|
|
|
a = simple_a_get(eo_super(obj, (const Eo_Class *) buf));
|
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);
|
2016-03-01 10:06:28 -08:00
|
|
|
simple_a_set((Eo_Class *) buf, 1);
|
|
|
|
simple_a_set(eo_super((Eo_Class *) buf, SIMPLE_CLASS), ++i);
|
|
|
|
simple_a_set(eo_super(SIMPLE_CLASS, (Eo_Class *) buf), ++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
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_wref_add((Eo *) buf, &wref);
|
|
|
|
parent = eo_parent_get((Eo *) buf);
|
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
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_composite_attach(obj, (Eo *) buf);
|
|
|
|
eo_composite_detach(obj, (Eo *) buf);
|
|
|
|
eo_composite_part_is((Eo *) buf);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_event_callback_forwarder_add(obj, NULL, (Eo *) buf);
|
|
|
|
eo_event_callback_forwarder_del(obj, 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;
|
2016-03-01 10:06:28 -08:00
|
|
|
eo_parent_set(obj, (Eo *) buf);
|
|
|
|
obj2 = eo_parent_get(obj);
|
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);
|
2016-03-02 06:42:46 -08:00
|
|
|
EO_FUNC_BODY_CONST(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;
|
2016-03-01 10:06:28 -08:00
|
|
|
ca = simple_a_print(obj);
|
|
|
|
cb = multi_a_print(obj);
|
|
|
|
cc = multi_a_print(obj);
|
2013-11-08 04:25:39 -08:00
|
|
|
fail_if(!(ca && cb && cc));
|
|
|
|
|
|
|
|
ca = cb = cc = EINA_FALSE;
|
2016-03-01 10:06:28 -08:00
|
|
|
ca = simple_class_hi_print(klass);
|
|
|
|
cb = multi_class_hi_print(klass);
|
|
|
|
cc = multi_class_hi_print(klass);
|
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();
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, eo_constructor(eoid));
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
eo_unref(obj);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, simple_a_set(eoid, 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);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, eo_constructor(eoid), simple_a_set(eoid, 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;
|
2016-03-01 10:06:28 -08:00
|
|
|
obj = eo_add(SIMPLE_CLASS, NULL, finalized = eo_finalized_get(eoid));
|
2014-08-29 01:55:02 -07:00
|
|
|
fail_if(finalized);
|
|
|
|
|
2016-03-01 10:06:28 -08:00
|
|
|
finalized = eo_finalized_get(obj);
|
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
|
|
|
|
|
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);
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|