2012-05-01 00:40:14 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
2016-10-05 23:42:03 -07:00
|
|
|
#ifndef _WIN32
|
|
|
|
# include <signal.h>
|
|
|
|
# include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
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"
|
2016-05-18 05:29:45 -07:00
|
|
|
#include "eo_test_class_singleton.h"
|
2016-09-08 02:39:38 -07:00
|
|
|
#include "eo_test_domain.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)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
|
|
|
Eo *obj = efl_add(EO_CLASS, NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
2012-06-10 07:04:58 -07:00
|
|
|
fail_if(!obj);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_constructor(obj);
|
|
|
|
efl_destructor(obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-06-10 07:04:58 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-05-18 05:29:45 -07:00
|
|
|
START_TEST(eo_singleton)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2016-05-18 05:29:45 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(SINGLETON_CLASS, NULL);
|
2016-05-18 05:29:45 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj2 = efl_add(SINGLETON_CLASS, NULL);
|
2016-05-18 05:29:45 -07:00
|
|
|
fail_if(!obj2);
|
|
|
|
|
|
|
|
ck_assert_ptr_eq(obj, obj2);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj2);
|
2016-05-18 05:29:45 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2016-05-18 05:29:45 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-05-19 03:33:17 -07:00
|
|
|
#define OVERRIDE_A_SIMPLE 100859
|
|
|
|
#define OVERRIDE_A 324000
|
|
|
|
static int
|
|
|
|
_simple_obj_override_a_get(Eo *obj, void *class_data EINA_UNUSED)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
return OVERRIDE_A + simple_a_get(efl_super(obj, EFL_OBJECT_OVERRIDE_CLASS));
|
2016-05-19 03:33:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_simple_obj_override_a_double_set(Eo *obj, void *class_data EINA_UNUSED, int a)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
simple_a_set(efl_super(obj, EFL_OBJECT_OVERRIDE_CLASS), 2 * a);
|
2016-05-19 03:33:17 -07:00
|
|
|
}
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
START_TEST(efl_object_override_tests)
|
2016-05-19 03:33:17 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2016-05-19 03:33:17 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
2016-05-19 03:33:17 -07:00
|
|
|
fail_if(!obj);
|
|
|
|
|
|
|
|
/* First get the value before the override to make sure it works and to
|
|
|
|
* make sure we don't cache. */
|
|
|
|
ck_assert_int_eq(simple_a_get(obj), 0);
|
|
|
|
|
2016-09-01 06:34:55 -07:00
|
|
|
EFL_OPS_DEFINE(
|
2016-07-19 01:21:36 -07:00
|
|
|
overrides,
|
2016-09-08 05:08:08 -07:00
|
|
|
EFL_OBJECT_OP_FUNC(simple_a_get, _simple_obj_override_a_get));
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_object_override(obj, &overrides));
|
2016-05-19 03:33:17 -07:00
|
|
|
|
|
|
|
ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A);
|
|
|
|
|
|
|
|
/* Check super works. */
|
|
|
|
simple_a_set(obj, OVERRIDE_A_SIMPLE);
|
|
|
|
ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A + OVERRIDE_A_SIMPLE);
|
|
|
|
|
|
|
|
/* Override again. */
|
2016-09-01 06:34:55 -07:00
|
|
|
EFL_OPS_DEFINE(
|
2016-07-19 01:21:36 -07:00
|
|
|
overrides2,
|
2016-09-08 05:08:08 -07:00
|
|
|
EFL_OBJECT_OP_FUNC(simple_a_set, _simple_obj_override_a_double_set));
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_object_override(obj, NULL));
|
|
|
|
fail_if(!efl_object_override(obj, &overrides2));
|
2016-05-19 03:33:17 -07:00
|
|
|
|
|
|
|
simple_a_set(obj, OVERRIDE_A_SIMPLE);
|
2016-07-20 21:52:16 -07:00
|
|
|
ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A_SIMPLE * 2);
|
|
|
|
|
|
|
|
/* Try overriding again - not allowed by policy */
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_object_override(obj, &overrides));
|
2016-07-20 21:52:16 -07:00
|
|
|
ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A_SIMPLE * 2);
|
2016-05-19 03:33:17 -07:00
|
|
|
|
|
|
|
/* Try introducing a new function */
|
2016-09-01 06:34:55 -07:00
|
|
|
EFL_OPS_DEFINE(
|
2016-07-19 01:21:36 -07:00
|
|
|
overrides3,
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_OBJECT_OP_FUNC(simple2_class_beef_get, _simple_obj_override_a_double_set));
|
|
|
|
fail_if(!efl_object_override(obj, NULL));
|
2016-09-09 02:53:45 -07:00
|
|
|
fail_if(efl_object_override(obj, &overrides3));
|
2016-05-19 03:33:17 -07:00
|
|
|
|
2016-07-20 21:52:16 -07:00
|
|
|
/* Test override reset */
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_object_override(obj, NULL));
|
2016-07-20 21:52:16 -07:00
|
|
|
simple_a_set(obj, 42 * OVERRIDE_A_SIMPLE);
|
|
|
|
ck_assert_int_eq(simple_a_get(obj), 42 * OVERRIDE_A_SIMPLE);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2016-05-19 03:33:17 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2016-05-19 03:33:17 -07:00
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
2016-06-20 07:31:31 -07:00
|
|
|
static void
|
2016-08-30 05:34:10 -07:00
|
|
|
_eo_signals_a_changed_cb(void *_data, const Efl_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++;
|
2016-08-31 17:15:35 -07:00
|
|
|
|
2014-05-20 07:31:53 -07:00
|
|
|
ck_assert_int_eq(data, _eo_signals_cb_current);
|
2013-04-12 03:06:30 -07:00
|
|
|
_eo_signals_cb_flag |= 0x1;
|
|
|
|
}
|
|
|
|
|
2016-06-20 07:31:31 -07:00
|
|
|
static void
|
2016-08-30 05:34:10 -07:00
|
|
|
_eo_signals_a_changed_cb2(void *_data EINA_UNUSED, const Efl_Event *event EINA_UNUSED)
|
2013-04-12 03:06:30 -07:00
|
|
|
{
|
|
|
|
_eo_signals_cb_flag |= 0x2;
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_stop(event->object);
|
2013-04-12 05:46:30 -07:00
|
|
|
}
|
|
|
|
|
2016-06-20 09:57:52 -07:00
|
|
|
static void
|
2016-08-30 05:34:10 -07:00
|
|
|
_eo_signals_a_changed_within_cb(void *_data EINA_UNUSED, const Efl_Event *event)
|
2016-06-20 09:57:52 -07:00
|
|
|
{
|
|
|
|
int a = 3;
|
2016-08-22 15:40:39 -07:00
|
|
|
efl_event_callback_legacy_call(event->object, EV_A_CHANGED, &a);
|
2016-06-20 09:57:52 -07:00
|
|
|
_eo_signals_cb_flag = 0x8;
|
|
|
|
}
|
|
|
|
|
2016-06-20 07:31:31 -07:00
|
|
|
static void
|
2016-08-30 05:34:10 -07:00
|
|
|
_eo_signals_a_changed_never(void *_data EINA_UNUSED, const Efl_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
|
|
|
}
|
|
|
|
|
2016-06-20 07:31:31 -07:00
|
|
|
static void
|
2016-08-30 05:34:10 -07:00
|
|
|
_eo_signals_efl_del_cb(void *_data EINA_UNUSED, const Efl_Event *event EINA_UNUSED)
|
2013-04-12 03:06:30 -07:00
|
|
|
{
|
|
|
|
_eo_signals_cb_flag |= 0x4;
|
|
|
|
}
|
|
|
|
|
2016-06-20 07:31:31 -07:00
|
|
|
void
|
2016-08-30 05:34:10 -07:00
|
|
|
_eo_signals_cb_added_deled(void *data, const Efl_Event *event)
|
2013-04-12 03:06:30 -07:00
|
|
|
{
|
2016-08-10 07:23:04 -07:00
|
|
|
const Efl_Callback_Array_Item *callback_array = event->info;
|
|
|
|
const Efl_Callback_Array_Item *(*callback_data)(void) = data;
|
2013-04-12 03:06:30 -07:00
|
|
|
|
2016-06-15 21:01:50 -07:00
|
|
|
fail_if((callback_data() != callback_array) &&
|
|
|
|
(callback_array->func != _eo_signals_cb_added_deled));
|
2013-04-12 03:06:30 -07:00
|
|
|
}
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(_eo_signals_callbacks,
|
2016-06-15 21:01:50 -07:00
|
|
|
{ EV_A_CHANGED, _eo_signals_a_changed_cb },
|
|
|
|
{ EV_A_CHANGED, _eo_signals_a_changed_cb2 },
|
|
|
|
{ EV_A_CHANGED, _eo_signals_a_changed_never },
|
2016-08-10 07:23:04 -07:00
|
|
|
{ EFL_EVENT_DEL, _eo_signals_efl_del_cb });
|
2016-06-15 21:01:50 -07:00
|
|
|
|
2013-04-12 03:06:30 -07:00
|
|
|
START_TEST(eo_signals)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2016-06-15 21:01:50 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
2016-02-04 21:21:56 -08:00
|
|
|
Eina_Bool r;
|
2014-04-02 01:46:34 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_add(obj, EFL_EVENT_CALLBACK_ADD, _eo_signals_cb_added_deled, &_eo_signals_callbacks);
|
|
|
|
r = efl_event_callback_add(obj, EFL_EVENT_CALLBACK_DEL, _eo_signals_cb_added_deled, &_eo_signals_callbacks);
|
2016-02-04 21:21:56 -08:00
|
|
|
fail_if(!r);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_priority_add(obj, _eo_signals_callbacks(), -100, (void *) 1);
|
|
|
|
efl_event_callback_array_add(obj, _eo_signals_callbacks(), (void *) 3);
|
|
|
|
r = efl_event_callback_array_priority_add(obj, _eo_signals_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-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 1);
|
|
|
|
efl_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 2);
|
|
|
|
r = efl_event_callback_array_del(obj, _eo_signals_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-08-10 07:23:04 -07:00
|
|
|
r = efl_event_callback_array_del(obj, _eo_signals_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);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
r = efl_event_callback_array_add(obj, NULL, NULL);
|
2016-03-04 06:29:20 -08:00
|
|
|
fail_if(r);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2013-04-12 03:06:30 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
2014-05-20 07:31:53 -07:00
|
|
|
/* Legacy support signals. */
|
|
|
|
{
|
2016-08-10 07:23:04 -07:00
|
|
|
const Efl_Event_Description *a_desc = efl_object_legacy_only_event_description_get("a,changed");
|
2014-05-20 07:31:53 -07:00
|
|
|
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);
|
|
|
|
|
2016-03-04 06:21:08 -08:00
|
|
|
/* Check that when calling again we still get the same event. */
|
2016-08-10 07:23:04 -07:00
|
|
|
const Efl_Event_Description *a_desc2 = efl_object_legacy_only_event_description_get("a,changed");
|
2016-03-04 06:21:08 -08:00
|
|
|
fail_if(!a_desc2);
|
|
|
|
fail_if(a_desc2 != a_desc);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
const Efl_Event_Description *bad_desc = efl_object_legacy_only_event_description_get("bad");
|
2014-05-20 07:31:53 -07:00
|
|
|
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-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_priority_add(obj, EV_A_CHANGED2, -1000, _eo_signals_a_changed_never, (void *) 1);
|
|
|
|
efl_event_callback_priority_add(obj, EV_A_CHANGED2, 0, _eo_signals_a_changed_within_cb, NULL);
|
|
|
|
efl_event_callback_priority_add(obj, EV_A_CHANGED, -100, _eo_signals_a_changed_cb, (void *) 1);
|
|
|
|
efl_event_callback_add(obj, a_desc, _eo_signals_a_changed_cb2, NULL);
|
2016-03-01 10:06:28 -08:00
|
|
|
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-08-10 07:23:04 -07:00
|
|
|
r = efl_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);
|
2016-08-10 07:23:04 -07:00
|
|
|
r = efl_event_callback_del(obj, a_desc, _eo_signals_a_changed_cb2, NULL);
|
2016-06-20 09:57:52 -07:00
|
|
|
fail_if(!r);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_add(obj, EV_A_CHANGED, _eo_signals_a_changed_cb2, NULL);
|
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-08-22 15:40:39 -07:00
|
|
|
efl_event_callback_legacy_call(obj, a_desc, &a);
|
2014-05-20 07:31:53 -07:00
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
|
2016-06-20 09:57:52 -07:00
|
|
|
|
|
|
|
/* Stop event within event. */
|
|
|
|
_eo_signals_cb_current = 0;
|
|
|
|
_eo_signals_cb_flag = 0;
|
2016-08-22 15:40:39 -07:00
|
|
|
fail_if(!efl_event_callback_legacy_call(obj, EV_A_CHANGED2, &a));
|
2016-06-20 09:57:52 -07:00
|
|
|
ck_assert_int_eq(_eo_signals_cb_flag, 0x8);
|
|
|
|
fail_if(!r);
|
2014-05-20 07:31:53 -07:00
|
|
|
}
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2014-05-20 07:31:53 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2013-04-12 03:06:30 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
START_TEST(efl_data_fetch)
|
2012-05-02 06:59:18 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2012-05-02 06:59:18 -07:00
|
|
|
|
2012-05-06 07:18:44 -07:00
|
|
|
/* Usually should be const, not const only for the test... */
|
2016-08-10 07:23:04 -07:00
|
|
|
static Efl_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-05-02 06:59:18 -07:00
|
|
|
"Simple2",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_REGULAR,
|
2012-05-02 06:59:18 -07:00
|
|
|
10,
|
|
|
|
NULL,
|
2016-09-05 04:31:55 -07:00
|
|
|
NULL,
|
2012-05-02 06:59:18 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
const Efl_Class *klass = efl_class_new(&class_desc, EO_CLASS, NULL);
|
2012-05-02 06:59:18 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_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
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_data_scope_get(obj, SIMPLE_CLASS));
|
2012-05-06 05:03:16 -07:00
|
|
|
#endif
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-05-02 06:59:18 -07:00
|
|
|
|
2012-05-06 07:18:44 -07:00
|
|
|
class_desc.data_size = 0;
|
2016-08-15 06:44:41 -07:00
|
|
|
klass = efl_class_new(&class_desc, EO_CLASS, NULL);
|
2012-05-06 07:18:44 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(klass, NULL);
|
2012-05-06 07:18:44 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_data_scope_get(obj, klass));
|
|
|
|
fail_if(!efl_data_scope_get(obj, EFL_OBJECT_CLASS));
|
|
|
|
efl_unref(obj);
|
2012-05-06 07:18:44 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-05-02 06:59:18 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
START_TEST(efl_isa_tests)
|
2012-06-14 03:29:39 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2012-06-14 03:29:39 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
const Efl_Class *klass, *iface, *mixin;
|
2012-06-14 03:29:39 -07:00
|
|
|
|
|
|
|
{
|
|
|
|
/* Usually should be const, not const only for the test... */
|
2016-08-10 07:23:04 -07:00
|
|
|
static Efl_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-06-14 03:29:39 -07:00
|
|
|
"Iface",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_INTERFACE,
|
2012-06-14 03:29:39 -07:00
|
|
|
0,
|
|
|
|
NULL,
|
2016-09-05 04:31:55 -07:00
|
|
|
NULL,
|
2012-06-14 03:29:39 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
iface = efl_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... */
|
2016-08-10 07:23:04 -07:00
|
|
|
static Efl_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-06-14 03:29:39 -07:00
|
|
|
"Mixin",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_MIXIN,
|
2012-06-14 03:29:39 -07:00
|
|
|
0,
|
|
|
|
NULL,
|
2016-09-05 04:31:55 -07:00
|
|
|
NULL,
|
2012-06-14 03:29:39 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
mixin = efl_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... */
|
2016-08-10 07:23:04 -07:00
|
|
|
static Efl_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-06-14 03:29:39 -07:00
|
|
|
"Simple2",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_REGULAR,
|
2012-06-14 03:29:39 -07:00
|
|
|
10,
|
|
|
|
NULL,
|
2016-09-05 04:31:55 -07:00
|
|
|
NULL,
|
2012-06-14 03:29:39 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
klass = efl_class_new(&class_desc, EO_CLASS, iface, mixin, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
}
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(klass, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_isa(obj, SIMPLE_CLASS));
|
|
|
|
fail_if(!efl_isa(obj, iface));
|
|
|
|
fail_if(!efl_isa(obj, mixin));
|
|
|
|
fail_if(!efl_isa(obj, klass));
|
|
|
|
fail_if(!efl_isa(obj, EO_CLASS));
|
|
|
|
efl_unref(obj);
|
|
|
|
|
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
2012-06-14 03:29:39 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_isa(obj, klass));
|
|
|
|
fail_if(efl_isa(obj, iface));
|
|
|
|
fail_if(efl_isa(obj, mixin));
|
|
|
|
fail_if(!efl_isa(obj, SIMPLE_CLASS));
|
|
|
|
fail_if(!efl_isa(obj, EO_CLASS));
|
|
|
|
efl_unref(obj);
|
|
|
|
|
|
|
|
efl_object_shutdown();
|
2012-06-14 03:29:39 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
START_TEST(efl_composite_tests)
|
2012-06-07 03:54:15 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2012-06-07 03:54:15 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
2012-06-07 03:54:15 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
|
2012-06-07 03:54:15 -07:00
|
|
|
fail_if(!obj2);
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
|
2016-05-05 08:08:08 -07:00
|
|
|
fail_if(!obj3);
|
2012-06-07 03:54:15 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_composite_attach(obj, obj2);
|
|
|
|
fail_if(!efl_composite_part_is(obj2));
|
2016-05-05 08:08:08 -07:00
|
|
|
|
|
|
|
/* Check swapping attachments works. */
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_composite_attach(obj3, obj2);
|
|
|
|
fail_if(!efl_composite_part_is(obj2));
|
2016-05-05 08:08:08 -07:00
|
|
|
|
|
|
|
/* Check that a deletion of a child detaches from the parent. */
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del(obj2);
|
|
|
|
fail_if(!efl_composite_attach(obj3, obj));
|
2016-05-05 08:08:08 -07:00
|
|
|
|
|
|
|
/* Check that a deletion of the parent detaches the child. */
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del(obj3);
|
|
|
|
fail_if(efl_composite_part_is(obj));
|
2012-06-07 03:54:15 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-06-07 03:54:15 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-06-07 03:54:15 -07:00
|
|
|
}
|
|
|
|
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;
|
2016-08-10 07:23:04 -07:00
|
|
|
static const Efl_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)
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_manual_free_set(obj, EINA_TRUE);
|
|
|
|
return efl_constructor(efl_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-08-15 06:44:41 -07:00
|
|
|
efl_destructor(efl_super(obj, cur_klass));
|
2012-06-10 07:04:53 -07:00
|
|
|
if (_man_should_des)
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_manual_free_set(obj, EINA_FALSE);
|
2012-05-21 04:45:32 -07:00
|
|
|
}
|
|
|
|
|
2016-09-05 04:31:55 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_class_initializer(Efl_Class *klass)
|
|
|
|
{
|
|
|
|
EFL_OPS_DEFINE(ops,
|
2016-09-08 05:08:08 -07:00
|
|
|
EFL_OBJECT_OP_FUNC(efl_constructor, _man_con),
|
|
|
|
EFL_OBJECT_OP_FUNC(efl_destructor, _man_des),
|
2016-09-05 04:31:55 -07:00
|
|
|
);
|
|
|
|
|
2016-09-09 02:53:58 -07:00
|
|
|
return efl_class_functions_set(klass, &ops, NULL);
|
2016-09-05 04:31:55 -07:00
|
|
|
}
|
2012-05-21 04:45:32 -07:00
|
|
|
|
|
|
|
START_TEST(eo_man_free)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2012-05-21 04:45:32 -07:00
|
|
|
|
|
|
|
/* Usually should be const, not const only for the test... */
|
2016-08-10 07:23:04 -07:00
|
|
|
static Efl_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2012-05-21 04:45:32 -07:00
|
|
|
"Simple2",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_REGULAR,
|
2012-05-21 04:45:32 -07:00
|
|
|
10,
|
2016-09-05 04:31:55 -07:00
|
|
|
_class_initializer,
|
2013-11-08 04:25:39 -08:00
|
|
|
NULL,
|
2012-05-21 04:45:32 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
const Efl_Class *klass = efl_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
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_manual_free(obj));
|
|
|
|
efl_unref(obj);
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2012-06-10 07:04:53 -07:00
|
|
|
_man_should_des = EINA_FALSE;
|
2016-08-15 06:44:41 -07:00
|
|
|
klass = efl_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);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_manual_free(obj));
|
|
|
|
fail_if(efl_destructed_is(obj));
|
|
|
|
efl_unref(obj);
|
|
|
|
fail_if(!efl_destructed_is(obj));
|
|
|
|
fail_if(!efl_manual_free(obj));
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
|
|
|
fail_if(!efl_destructed_is(obj));
|
|
|
|
fail_if(!efl_manual_free(obj));
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2012-06-10 07:04:53 -07:00
|
|
|
_man_should_con = EINA_FALSE;
|
2016-08-15 06:44:41 -07:00
|
|
|
klass = efl_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);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(klass, NULL);
|
2012-05-21 04:45:32 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_manual_free(obj));
|
|
|
|
efl_unref(obj);
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(klass, NULL);
|
2012-06-10 00:53:43 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_manual_free_set(obj, EINA_TRUE);
|
|
|
|
efl_unref(obj);
|
|
|
|
efl_ref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
fail_if(!efl_manual_free(obj));
|
|
|
|
|
|
|
|
obj = efl_add(klass, NULL);
|
2012-08-23 03:37:46 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_manual_free_set(obj, EINA_TRUE);
|
|
|
|
efl_unref(obj);
|
|
|
|
efl_ref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
fail_if(!efl_manual_free(obj));
|
|
|
|
|
|
|
|
efl_object_shutdown();
|
2012-05-21 04:45:32 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
START_TEST(efl_refs)
|
2012-05-01 00:40:14 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xref(obj, obj2);
|
|
|
|
fail_if(efl_ref_get(obj) != 2);
|
|
|
|
efl_xref(obj, obj3);
|
|
|
|
fail_if(efl_ref_get(obj) != 3);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xunref(obj, obj2);
|
|
|
|
fail_if(efl_ref_get(obj) != 2);
|
|
|
|
efl_xunref(obj, obj3);
|
|
|
|
fail_if(efl_ref_get(obj) != 1);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2013-01-18 08:57:57 -08:00
|
|
|
#ifdef EO_DEBUG
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xunref(obj, obj3);
|
|
|
|
fail_if(efl_ref_get(obj) != 1);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xref(obj, obj2);
|
|
|
|
fail_if(efl_ref_get(obj) != 2);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xunref(obj, obj3);
|
|
|
|
fail_if(efl_ref_get(obj) != 2);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xunref(obj, obj2);
|
|
|
|
fail_if(efl_ref_get(obj) != 1);
|
2012-05-01 00:40:14 -07:00
|
|
|
#endif
|
|
|
|
|
2012-06-07 03:54:17 -07:00
|
|
|
/* Check we don't seg if there's an extra xref. */
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xref(obj, obj2);
|
|
|
|
efl_unref(obj);
|
2012-06-07 03:54:17 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj2);
|
|
|
|
efl_unref(obj3);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2012-06-07 03:54:17 -07:00
|
|
|
/* Check hierarchy */
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj2 = efl_ref(efl_add(SIMPLE_CLASS, obj));
|
2012-06-07 03:54:17 -07:00
|
|
|
|
2013-12-30 13:16:55 -08:00
|
|
|
Eo *wref = NULL;
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add(obj2, &wref);
|
2012-06-07 03:54:17 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj2);
|
2012-06-07 03:54:17 -07:00
|
|
|
|
|
|
|
fail_if(!wref); /* Parent is still holding a reference. */
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-06-07 03:54:17 -07:00
|
|
|
|
|
|
|
fail_if(wref);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
/* efl_add_ref and normal efl_add */
|
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj2 = efl_add(SIMPLE_CLASS, obj);
|
|
|
|
obj3 = efl_add_ref(SIMPLE_CLASS, obj);
|
2014-09-25 07:51:17 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
ck_assert_int_eq(efl_ref_get(obj), 1);
|
|
|
|
ck_assert_int_eq(efl_ref_get(obj2), 1);
|
|
|
|
ck_assert_int_eq(efl_ref_get(obj3), 2);
|
2014-09-25 07:51:17 -07:00
|
|
|
|
2016-10-21 07:18:46 -07:00
|
|
|
efl_del(obj);
|
|
|
|
efl_del(obj2);
|
|
|
|
efl_unref(obj3);
|
|
|
|
efl_del(obj3);
|
|
|
|
|
2015-08-26 02:47:06 -07:00
|
|
|
/* Setting and removing parents. */
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj2 = efl_ref(efl_add(SIMPLE_CLASS, obj));
|
|
|
|
obj3 = efl_ref(efl_add(SIMPLE_CLASS, NULL));
|
2015-08-26 02:47:06 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_parent_set(obj2, obj3);
|
|
|
|
efl_parent_set(obj3, obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
ck_assert_int_eq(efl_ref_get(obj2), 2);
|
|
|
|
ck_assert_int_eq(efl_ref_get(obj3), 2);
|
2015-08-26 02:47:06 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_parent_set(obj2, NULL);
|
|
|
|
efl_parent_set(obj3, NULL);
|
2016-08-15 06:44:41 -07:00
|
|
|
ck_assert_int_eq(efl_ref_get(obj2), 1);
|
|
|
|
ck_assert_int_eq(efl_ref_get(obj3), 1);
|
2015-08-26 02:47:06 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_parent_set(obj2, obj);
|
|
|
|
efl_parent_set(obj3, obj);
|
2016-10-21 07:02:27 -07:00
|
|
|
ck_assert_int_eq(efl_ref_get(obj2), 2);
|
|
|
|
ck_assert_int_eq(efl_ref_get(obj3), 2);
|
2015-08-26 02:47:06 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del(obj);
|
|
|
|
efl_del(obj2);
|
|
|
|
efl_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. */
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
efl_ref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj);
|
|
|
|
|
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj2 = efl_add(SIMPLE_CLASS, obj);
|
|
|
|
efl_unref(obj2);
|
|
|
|
efl_ref(obj2);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del(obj2);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-06-07 00:17:45 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
START_TEST(efl_weak_reference)
|
2012-05-01 00:40:14 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
|
2013-12-30 13:16:55 -08:00
|
|
|
Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL;
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add(obj, &wref);
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add(obj, &wref);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_ref(obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-06-03 01:42:08 -07:00
|
|
|
fail_if(!wref);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add(obj, &wref);
|
|
|
|
efl_wref_del(obj, &wref);
|
2012-05-01 04:25:00 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add(obj, &wref);
|
|
|
|
efl_wref_del(obj2, &wref);
|
2012-05-01 04:25:00 -07:00
|
|
|
fail_if(!wref);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_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-08-10 07:23:04 -07:00
|
|
|
efl_wref_del(obj, &wref);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
|
|
|
|
wref = wref2 = wref3 = NULL;
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add(obj, &wref);
|
|
|
|
efl_wref_add(obj, &wref2);
|
|
|
|
efl_wref_add(obj, &wref3);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(!wref);
|
|
|
|
fail_if(!wref2);
|
|
|
|
fail_if(!wref3);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_del(obj, &wref);
|
|
|
|
efl_wref_del(obj, &wref2);
|
|
|
|
efl_wref_del(obj, &wref3);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
|
|
|
fail_if(wref2);
|
|
|
|
fail_if(wref3);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add(obj, &wref2);
|
|
|
|
efl_wref_add(obj, &wref3);
|
2012-05-01 07:00:14 -07:00
|
|
|
wref = obj;
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_del(obj, &wref);
|
2012-05-01 07:00:14 -07:00
|
|
|
fail_if(wref);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_del(obj, &wref2);
|
|
|
|
efl_wref_del(obj, &wref3);
|
2012-05-01 05:38:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj2);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
|
|
|
START_TEST(eo_generic_data)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
|
2016-04-12 09:04:11 -07:00
|
|
|
Eo *objtmp;
|
2013-12-30 13:16:55 -08:00
|
|
|
void *data = NULL;
|
2016-04-19 02:25:15 -07:00
|
|
|
Eina_Value *value;
|
|
|
|
Eina_Value *value2;
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-07-07 02:41:23 -07:00
|
|
|
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_data_set(obj, "test1", (void *) 1);
|
|
|
|
data = efl_key_data_get(obj, "test1");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_data_set(obj, "test1", NULL);
|
|
|
|
data = efl_key_data_get(obj, "test1");
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_data_set(obj, "test1", (void *) 1);
|
|
|
|
efl_key_data_set(obj, "test2", (void *) 2);
|
|
|
|
data = efl_key_data_get(obj, "test1");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
data = efl_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-08-10 07:23:04 -07:00
|
|
|
data = efl_key_data_get(obj, "test2");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(2 != (intptr_t) data);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_data_set(obj, "test2", NULL);
|
|
|
|
data = efl_key_data_get(obj, "test2");
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
data = efl_key_data_get(obj, "test1");
|
2013-01-15 09:17:39 -08:00
|
|
|
fail_if(1 != (intptr_t) data);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_data_set(obj, "test1", NULL);
|
|
|
|
data = efl_key_data_get(obj, "test1");
|
2012-05-01 00:40:14 -07:00
|
|
|
fail_if(data);
|
|
|
|
|
2016-04-12 09:04:11 -07:00
|
|
|
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_ref_set(obj, "test1", obj2);
|
|
|
|
objtmp = efl_key_ref_get(obj, "test1");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(obj2 != objtmp);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_ref_set(obj, "test1", NULL);
|
|
|
|
objtmp = efl_key_ref_get(obj, "test1");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_ref_set(obj, "test1", obj2);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj2) != 2);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_ref_set(obj, "test2", obj3);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj3) != 2);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_ref_get(obj, "test1");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(obj2 != objtmp);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_ref_get(obj, "test2");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(obj3 != objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
data = efl_key_ref_get(obj, "test2");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(obj3 != objtmp);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_ref_set(obj, "test2", NULL);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj3) != 1);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_ref_get(obj, "test2");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_ref_get(obj, "test1");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(obj2 != objtmp);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_ref_set(obj, "test1", NULL);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj2) != 1);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_ref_get(obj, "test1");
|
2016-04-12 09:04:11 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_ref_set(obj, "test1", obj2);
|
|
|
|
efl_key_ref_set(obj, "test2", obj3);
|
|
|
|
efl_del(obj2);
|
|
|
|
efl_del(obj2);
|
|
|
|
efl_del(obj3);
|
|
|
|
efl_del(obj3);
|
|
|
|
objtmp = efl_key_ref_get(obj, "test1");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_ref_get(obj, "test2");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj2 = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
obj3 = efl_add(SIMPLE_CLASS, NULL);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_wref_set(obj, "test1", obj2);
|
|
|
|
objtmp = efl_key_wref_get(obj, "test1");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(obj2 != objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_wref_set(obj, "test1", NULL);
|
|
|
|
objtmp = efl_key_wref_get(obj, "test1");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_wref_set(obj, "test1", obj2);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj2) != 1);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_wref_set(obj, "test2", obj3);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj3) != 1);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_wref_get(obj, "test1");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(obj2 != objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_wref_get(obj, "test2");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(obj3 != objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
data = efl_key_wref_get(obj, "test2");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(obj3 != objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_wref_set(obj, "test2", NULL);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj3) != 1);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_wref_get(obj, "test2");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_wref_get(obj, "test1");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(obj2 != objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_wref_set(obj, "test1", NULL);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_ref_get(obj2) != 1);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_wref_get(obj, "test1");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_wref_set(obj, "test1", obj2);
|
|
|
|
efl_key_wref_set(obj, "test2", obj3);
|
|
|
|
efl_del(obj2);
|
|
|
|
efl_del(obj3);
|
|
|
|
objtmp = efl_key_wref_get(obj, "test1");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_key_wref_get(obj, "test2");
|
2016-07-07 02:41:23 -07:00
|
|
|
fail_if(objtmp);
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-04-19 02:25:15 -07:00
|
|
|
value = eina_value_new(EINA_VALUE_TYPE_INT);
|
|
|
|
eina_value_set(value, 1234);
|
2016-08-10 07:23:04 -07:00
|
|
|
value2 = efl_key_value_get(obj, "value1");
|
2016-04-19 02:25:15 -07:00
|
|
|
fail_if(value2 != NULL);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_value_set(obj, "value1", value);
|
|
|
|
value2 = efl_key_value_get(obj, "value1");
|
2016-04-19 02:25:15 -07:00
|
|
|
fail_if(value != value2);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_value_set(obj, "value1", NULL);
|
|
|
|
value2 = efl_key_value_get(obj, "value1");
|
2016-04-19 02:25:15 -07:00
|
|
|
fail_if(value2 != NULL);
|
2016-07-07 02:41:23 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_key_value_set(obj, "value1", NULL);
|
2016-04-19 02:25:15 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
|
|
|
efl_unref(obj2);
|
|
|
|
efl_unref(obj3);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|
|
|
|
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;
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2012-05-21 04:45:37 -07:00
|
|
|
memset(_buf, 1, sizeof(_buf));
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_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
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add((Efl_Class *) buf, NULL);
|
2012-05-21 04:45:37 -07:00
|
|
|
fail_if(obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_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-08-15 06:44:41 -07:00
|
|
|
simple_a_set(efl_super((Eo *) buf, SIMPLE_CLASS), ++i);
|
|
|
|
a = simple_a_get(efl_super((Eo *) buf, SIMPLE_CLASS));
|
2013-11-08 04:25:39 -08:00
|
|
|
ck_assert_int_ne(i, a);
|
2016-08-15 06:44:41 -07:00
|
|
|
simple_a_set(efl_super(obj, (const Efl_Class *) buf), ++i);
|
|
|
|
a = simple_a_get(efl_super(obj, (const Efl_Class *) buf));
|
2013-11-11 02:47:13 -08:00
|
|
|
ck_assert_int_ne(i, a);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_class_get((Eo *) buf));
|
|
|
|
fail_if(efl_class_name_get((Efl_Class*) buf));
|
|
|
|
fail_if(efl_class_get(obj) != SIMPLE_CLASS);
|
|
|
|
fail_if(efl_class_get(SIMPLE_CLASS) != EFL_CLASS_CLASS);
|
2016-08-10 07:23:04 -07:00
|
|
|
simple_a_set((Efl_Class *) buf, 1);
|
2016-08-15 06:44:41 -07:00
|
|
|
simple_a_set(efl_super((Efl_Class *) buf, SIMPLE_CLASS), ++i);
|
|
|
|
simple_a_set(efl_super(SIMPLE_CLASS, (Efl_Class *) buf), ++i);
|
|
|
|
fail_if(efl_class_new(NULL, (Efl_Class *) buf), NULL);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_xref(obj, (Eo *) buf);
|
|
|
|
efl_xunref(obj, (Eo *) buf);
|
|
|
|
efl_xref((Eo *) buf, obj);
|
|
|
|
efl_xunref((Eo *) buf, obj);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_ref((Eo *) buf);
|
|
|
|
efl_unref((Eo *) buf);
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del((Eo *) buf);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_isa((Eo *) buf, SIMPLE_CLASS);
|
|
|
|
efl_isa(obj, (Efl_Class *) buf);
|
2012-06-14 03:29:39 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(0 != efl_ref_get((Eo *) buf));
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_wref_add((Eo *) buf, &wref);
|
|
|
|
parent = efl_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
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_data_scope_get((Eo *) buf, SIMPLE_CLASS));
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_composite_attach(obj, (Eo *) buf);
|
|
|
|
efl_composite_detach(obj, (Eo *) buf);
|
|
|
|
efl_composite_part_is((Eo *) buf);
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_event_callback_forwarder_add(obj, NULL, (Eo *) buf);
|
|
|
|
efl_event_callback_forwarder_del(obj, NULL, (Eo *) buf);
|
2012-05-21 04:45:32 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_manual_free_set((Eo *) buf, EINA_TRUE);
|
|
|
|
efl_manual_free((Eo *) buf);
|
|
|
|
efl_destructed_is((Eo *) buf);
|
2012-05-21 04:45:37 -07:00
|
|
|
|
2013-11-20 04:16:47 -08:00
|
|
|
obj2 = NULL;
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_parent_set(obj, (Eo *) buf);
|
|
|
|
obj2 = efl_parent_get(obj);
|
2013-11-20 04:16:47 -08:00
|
|
|
fail_if(obj2 && (obj2 == (Eo *) buf));
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-05-21 04:45:37 -07:00
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
buf = NULL;
|
|
|
|
}
|
2012-05-01 00:40:14 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-10-19 08:20:19 -07:00
|
|
|
/* resolve issues */
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
|
|
|
|
{
|
|
|
|
printf("Hey\n");
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EFL_FUNC_BODY(resolve_a_print, Eina_Bool, EINA_FALSE);
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_multi_class_initializer(Efl_Class *klass)
|
|
|
|
{
|
|
|
|
EFL_OPS_DEFINE(ops,
|
|
|
|
EFL_OBJECT_OP_FUNC(resolve_a_print, _a_print),
|
|
|
|
);
|
|
|
|
|
|
|
|
return efl_class_functions_set(klass, &ops, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
START_TEST(efl_func_resolve)
|
|
|
|
{
|
|
|
|
efl_object_init();
|
|
|
|
|
|
|
|
/* Usually should be const, not const only for the test... */
|
|
|
|
static Efl_Class_Description class_desc = {
|
|
|
|
EO_VERSION,
|
|
|
|
"Inherit",
|
|
|
|
EFL_CLASS_TYPE_REGULAR,
|
|
|
|
0,
|
|
|
|
_multi_class_initializer,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
const Efl_Class *klass = efl_class_new(&class_desc, SIMPLE_CLASS, NULL);
|
|
|
|
fail_if(!klass);
|
|
|
|
|
|
|
|
Eo *obj = efl_add(klass, NULL);
|
|
|
|
fail_if(!resolve_a_print(obj));
|
|
|
|
efl_unref(obj);
|
|
|
|
|
|
|
|
|
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
fail_if(!obj);
|
|
|
|
efl_manual_free_set(obj, EINA_TRUE);
|
|
|
|
|
|
|
|
fail_if(resolve_a_print(obj));
|
|
|
|
|
|
|
|
efl_unref(obj);
|
|
|
|
|
|
|
|
fail_if(!efl_destructed_is(obj));
|
|
|
|
efl_manual_free(obj);
|
|
|
|
|
|
|
|
efl_object_shutdown();
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
START_TEST(efl_add_do_and_custom)
|
2012-08-23 03:35:14 -07:00
|
|
|
{
|
|
|
|
Simple_Public_Data *pd = NULL;
|
|
|
|
Eo *obj = NULL;
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2012-08-23 03:35:14 -07:00
|
|
|
|
2016-09-05 08:57:35 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL, efl_constructor(efl_added));
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-08-23 03:35:14 -07:00
|
|
|
|
2016-09-05 08:57:35 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL, simple_a_set(efl_added, 7));
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
pd = efl_data_scope_get(obj, SIMPLE_CLASS);
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(pd->a != 7);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-08-23 03:35:14 -07:00
|
|
|
|
2016-09-05 08:57:35 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL, efl_constructor(efl_added), simple_a_set(efl_added, 7));
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
pd = efl_data_scope_get(obj, SIMPLE_CLASS);
|
2012-08-23 03:35:14 -07:00
|
|
|
fail_if(pd->a != 7);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2012-08-23 03:35:14 -07:00
|
|
|
|
2014-08-29 01:55:02 -07:00
|
|
|
Eina_Bool finalized;
|
2016-09-05 08:57:35 -07:00
|
|
|
obj = efl_add(SIMPLE_CLASS, NULL, finalized = efl_finalized_get(efl_added));
|
2014-08-29 01:55:02 -07:00
|
|
|
fail_if(finalized);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
finalized = efl_finalized_get(obj);
|
2014-08-29 01:55:02 -07:00
|
|
|
fail_if(!finalized);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2014-08-29 01:55:02 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2012-08-23 03:35:14 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2013-04-18 03:55:55 -07:00
|
|
|
START_TEST(eo_pointers_indirection)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_EO_ID
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2013-04-18 03:55:55 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
static const Efl_Class_Description class_desc = {
|
2014-04-02 01:46:34 -07:00
|
|
|
EO_VERSION,
|
2013-04-18 03:55:55 -07:00
|
|
|
"Simple",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_REGULAR,
|
2013-04-18 03:55:55 -07:00
|
|
|
0,
|
|
|
|
NULL,
|
2016-09-05 04:31:55 -07:00
|
|
|
NULL,
|
2013-04-18 03:55:55 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
const Efl_Class *klass = efl_class_new(&class_desc, EO_CLASS, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!klass);
|
|
|
|
|
|
|
|
/* Check simple id validity */
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(klass, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_isa(obj, klass));
|
2013-04-18 03:55:55 -07:00
|
|
|
obj = (Eo *)((char *)(obj) + 1);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_isa(obj, klass));
|
2013-04-18 03:55:55 -07:00
|
|
|
obj = (Eo *)((char *)(obj) - 1);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_isa(obj, klass));
|
|
|
|
efl_unref(obj);
|
|
|
|
fail_if(efl_isa(obj, klass));
|
2013-04-18 03:55:55 -07:00
|
|
|
|
|
|
|
/* Check id invalidity after deletion */
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj1 = efl_add(klass, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!obj1);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj1);
|
|
|
|
Eo *obj2 = efl_add(klass, NULL);
|
2013-04-18 03:55:55 -07:00
|
|
|
fail_if(!obj2);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_isa(obj2, klass));
|
|
|
|
fail_if(efl_isa(obj1, klass));
|
|
|
|
efl_unref(obj2);
|
2013-04-18 03:55:55 -07:00
|
|
|
|
2014-10-22 03:43:45 -07:00
|
|
|
/* Check id sanity checks for "close enough" ids. */
|
2016-08-15 06:44:41 -07:00
|
|
|
obj1 = efl_add(klass, NULL);
|
2014-10-22 03:43:45 -07:00
|
|
|
fail_if(!obj1);
|
|
|
|
obj2 = (Eo *) (((Eo_Id) obj1) & ~MASK_OBJ_TAG);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_class_get(obj2));
|
|
|
|
efl_unref(obj1);
|
2014-10-22 03:43:45 -07:00
|
|
|
|
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++)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
objs[obj_id] = efl_add(klass, NULL);
|
2013-05-07 14:40:53 -07:00
|
|
|
if(!objs[obj_id])
|
|
|
|
fail_if(!objs[obj_id]);
|
2016-08-15 06:44:41 -07:00
|
|
|
if(!efl_isa(objs[obj_id], klass))
|
|
|
|
fail_if(!efl_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
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(objs[obj_id]);
|
|
|
|
if(efl_isa(objs[obj_id], klass))
|
|
|
|
fail_if(efl_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
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
objs[obj_id] = efl_add(klass, NULL);
|
2013-05-07 14:40:53 -07:00
|
|
|
if(!objs[obj_id])
|
|
|
|
fail_if(!objs[obj_id]);
|
2016-08-15 06:44:41 -07:00
|
|
|
if(!efl_isa(objs[obj_id], klass))
|
|
|
|
fail_if(!efl_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++)
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(objs[obj_id]);
|
2013-05-06 15:34:50 -07:00
|
|
|
/* Just be sure that we trigger an already freed error */
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(objs[0]);
|
2013-04-18 03:55:55 -07:00
|
|
|
free(objs);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2013-04-18 03:55:55 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2014-05-30 03:17:36 -07:00
|
|
|
|
|
|
|
static Eo *
|
2016-08-15 06:44:41 -07:00
|
|
|
_efl_add_failures_finalize(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
|
2014-05-30 03:17:36 -07:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-09-05 04:31:55 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_add_failures_class_initializer(Efl_Class *klass)
|
|
|
|
{
|
|
|
|
EFL_OPS_DEFINE(ops,
|
2016-09-08 05:08:08 -07:00
|
|
|
EFL_OBJECT_OP_FUNC(efl_finalize, _efl_add_failures_finalize),
|
2016-09-05 04:31:55 -07:00
|
|
|
);
|
|
|
|
|
2016-09-09 02:53:58 -07:00
|
|
|
return efl_class_functions_set(klass, &ops, NULL);
|
2016-09-05 04:31:55 -07:00
|
|
|
}
|
2014-05-30 03:17:36 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
START_TEST(efl_add_failures)
|
2014-05-30 03:17:36 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2014-05-30 03:17:36 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
static const Efl_Class_Description class_desc = {
|
2014-05-30 03:17:36 -07:00
|
|
|
EO_VERSION,
|
|
|
|
"Simple2",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_REGULAR,
|
2014-05-30 03:17:36 -07:00
|
|
|
0,
|
2016-09-05 04:31:55 -07:00
|
|
|
_add_failures_class_initializer,
|
2014-05-30 03:17:36 -07:00
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
const Efl_Class *klass = efl_class_new(&class_desc, EO_CLASS, NULL);
|
2014-05-30 03:17:36 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(klass, NULL);
|
2014-05-30 03:17:36 -07:00
|
|
|
|
|
|
|
fail_if(obj);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2014-05-30 03:17:36 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-05-20 03:39:36 -07:00
|
|
|
#ifdef HAVE_EO_ID
|
2016-03-07 23:57:22 -08:00
|
|
|
static Eina_Bool intercepted = EINA_FALSE;
|
|
|
|
|
|
|
|
static void
|
|
|
|
_del_intercept(Eo *obj)
|
|
|
|
{
|
|
|
|
intercepted = EINA_TRUE;
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del_intercept_set(obj, NULL);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2016-03-07 23:57:22 -08:00
|
|
|
}
|
2016-05-20 03:39:36 -07:00
|
|
|
#endif
|
2016-03-07 23:57:22 -08:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
START_TEST(efl_del_intercept)
|
2016-03-07 23:57:22 -08:00
|
|
|
{
|
|
|
|
#ifdef HAVE_EO_ID
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
2016-03-07 23:57:22 -08:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
static const Efl_Class_Description class_desc = {
|
2016-03-07 23:57:22 -08:00
|
|
|
EO_VERSION,
|
|
|
|
"Simple",
|
2016-08-15 06:44:41 -07:00
|
|
|
EFL_CLASS_TYPE_REGULAR,
|
2016-03-07 23:57:22 -08:00
|
|
|
0,
|
|
|
|
NULL,
|
2016-09-05 04:31:55 -07:00
|
|
|
NULL,
|
2016-03-07 23:57:22 -08:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
const Efl_Class *klass = efl_class_new(&class_desc, EO_CLASS, NULL);
|
2016-03-07 23:57:22 -08:00
|
|
|
fail_if(!klass);
|
|
|
|
|
|
|
|
/* Check unref interception */
|
|
|
|
intercepted = EINA_FALSE;
|
2016-08-15 06:44:41 -07:00
|
|
|
Eo *obj = efl_add(klass, NULL);
|
2016-03-07 23:57:22 -08:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_isa(obj, klass));
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del_intercept_set(obj, _del_intercept);
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_unref(obj);
|
2016-03-07 23:57:22 -08:00
|
|
|
fail_if(!intercepted);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_isa(obj, klass));
|
2016-03-07 23:57:22 -08:00
|
|
|
|
|
|
|
/* Check del interception */
|
|
|
|
intercepted = EINA_FALSE;
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_add(klass, NULL);
|
2016-03-07 23:57:22 -08:00
|
|
|
fail_if(!obj);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(!efl_isa(obj, klass));
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del_intercept_set(obj, _del_intercept);
|
|
|
|
efl_del(obj);
|
2016-03-07 23:57:22 -08:00
|
|
|
fail_if(!intercepted);
|
2016-08-15 06:44:41 -07:00
|
|
|
fail_if(efl_isa(obj, klass));
|
2016-03-07 23:57:22 -08:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2016-03-07 23:57:22 -08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
START_TEST(efl_name)
|
2016-04-19 00:34:53 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
|
|
|
|
Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
|
2016-04-20 02:26:35 -07:00
|
|
|
Eo *objtmp;
|
2016-04-19 00:34:53 -07:00
|
|
|
const char *id;
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
id = efl_name_get(obj);
|
2016-04-19 00:34:53 -07:00
|
|
|
fail_if(NULL != id);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_name_set(obj, "Hello");
|
|
|
|
id = efl_name_get(obj);
|
2016-04-19 00:34:53 -07:00
|
|
|
fail_if(NULL == id);
|
|
|
|
fail_if(!!strcmp(id, "Hello"));
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_name_set(obj, "Hello");
|
|
|
|
efl_name_set(obj, "");
|
|
|
|
id = efl_name_get(obj);
|
2016-04-19 00:34:53 -07:00
|
|
|
fail_if(NULL != id);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_name_set(obj, "Hello");
|
|
|
|
efl_name_set(obj, NULL);
|
|
|
|
id = efl_name_get(obj);
|
2016-04-19 00:34:53 -07:00
|
|
|
fail_if(NULL != id);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_name_set(obj2, "joe");
|
|
|
|
efl_name_set(obj3, "bob");
|
2016-04-20 02:26:35 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_parent_set(obj2, obj);
|
|
|
|
efl_parent_set(obj3, obj2);
|
2016-04-20 02:26:35 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_name_find(obj, "bob");
|
2016-04-20 02:26:35 -07:00
|
|
|
fail_if(objtmp != obj3);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_name_find(obj, "joe");
|
2016-04-20 02:26:35 -07:00
|
|
|
fail_if(objtmp != obj2);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_name_find(obj, "bo*");
|
2016-04-20 02:26:35 -07:00
|
|
|
fail_if(objtmp != obj3);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_name_find(obj, "*oe");
|
2016-04-20 02:26:35 -07:00
|
|
|
fail_if(objtmp != obj2);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_name_find(obj, "Simple:*oe");
|
2016-04-20 02:26:35 -07:00
|
|
|
fail_if(objtmp != obj2);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_name_find(obj, "*mple:joe");
|
2016-04-20 02:26:35 -07:00
|
|
|
fail_if(objtmp != obj2);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del(obj);
|
2016-04-19 00:34:53 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2016-04-19 00:34:53 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-04-19 01:21:21 -07:00
|
|
|
START_TEST(eo_comment)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
|
2016-04-19 01:21:21 -07:00
|
|
|
const char *comment;
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
comment = efl_comment_get(obj);
|
2016-04-19 01:21:21 -07:00
|
|
|
fail_if(NULL != comment);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_comment_set(obj, "Hello");
|
|
|
|
comment = efl_comment_get(obj);
|
2016-04-19 01:21:21 -07:00
|
|
|
fail_if(NULL == comment);
|
|
|
|
fail_if(!!strcmp(comment, "Hello"));
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_comment_set(obj, "Hello");
|
|
|
|
efl_comment_set(obj, "");
|
|
|
|
comment = efl_comment_get(obj);
|
2016-04-19 01:21:21 -07:00
|
|
|
fail_if(NULL != comment);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_comment_set(obj, "Hello");
|
|
|
|
efl_comment_set(obj, NULL);
|
|
|
|
comment = efl_comment_get(obj);
|
2016-04-19 01:21:21 -07:00
|
|
|
fail_if(NULL != comment);
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del(obj);
|
2016-04-19 01:21:21 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2016-04-19 01:21:21 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-05-04 01:08:00 -07:00
|
|
|
START_TEST(eo_rec_interface)
|
2016-04-20 23:15:13 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_init();
|
|
|
|
Eo *s = efl_add(SEARCHABLE_CLASS, NULL);
|
|
|
|
Eo *obj = efl_add(SIMPLE_CLASS, s);
|
|
|
|
Eo *obj2 = efl_add(SIMPLE_CLASS, obj);
|
2016-04-20 23:15:13 -07:00
|
|
|
Eo *objtmp;
|
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
objtmp = efl_provider_find(obj2, SEARCHABLE_CLASS);
|
2016-05-04 01:08:00 -07:00
|
|
|
fail_if(objtmp != s);
|
2016-04-20 23:15:13 -07:00
|
|
|
|
2016-08-10 07:23:04 -07:00
|
|
|
efl_del(obj);
|
2016-04-20 23:15:13 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_object_shutdown();
|
2016-04-20 23:15:13 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2016-09-09 02:42:21 -07:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
Eo *obj, *objs;
|
|
|
|
Efl_Domain_Data *dat;
|
|
|
|
} Data;
|
|
|
|
|
|
|
|
static void *
|
|
|
|
thr1(void *data, Eina_Thread t EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Data *d = data;
|
|
|
|
Efl_Id_Domain dom;
|
2016-10-06 00:27:28 -07:00
|
|
|
Eo *s1, *s2;
|
2016-09-09 02:42:21 -07:00
|
|
|
|
|
|
|
fail_if(efl_domain_switch(EFL_ID_DOMAIN_THREAD) != EINA_TRUE);
|
|
|
|
fail_if(efl_domain_get() != EFL_ID_DOMAIN_THREAD);
|
|
|
|
printf("ADD2\n");
|
|
|
|
Eo *obj = efl_add(DOMAIN_CLASS, NULL);
|
|
|
|
printf("ADD2 DONE = %p\n", obj);
|
|
|
|
|
2016-10-05 23:42:03 -07:00
|
|
|
printf("VERIFY finalized_get()\n");
|
|
|
|
fail_if(!efl_finalized_get(d->objs));
|
|
|
|
|
2016-10-06 00:27:28 -07:00
|
|
|
printf("VERIFY parent_set(invalid) -- WILL SHOW ERRORS\n");
|
2016-10-06 00:19:12 -07:00
|
|
|
efl_domain_current_push(EFL_ID_DOMAIN_SHARED);
|
2016-10-06 00:27:28 -07:00
|
|
|
s1 = efl_add(DOMAIN_CLASS, NULL);
|
2016-10-06 00:19:12 -07:00
|
|
|
efl_domain_current_pop();
|
2016-10-06 00:27:28 -07:00
|
|
|
efl_del(s1);
|
|
|
|
efl_parent_set(d->objs, s1);
|
|
|
|
printf("END OF ERRORS\n");
|
|
|
|
|
|
|
|
printf("VERIFY composite\n");
|
|
|
|
efl_domain_current_push(EFL_ID_DOMAIN_SHARED);
|
|
|
|
s1 = efl_add(SIMPLE_CLASS, NULL, simple_a_set(efl_added, 7));
|
|
|
|
s2 = efl_add(SIMPLE_CLASS, NULL, simple_a_set(efl_added, 42));
|
|
|
|
efl_domain_current_pop();
|
|
|
|
|
|
|
|
efl_composite_attach(d->objs, s1);
|
|
|
|
int i1 = simple_a_get(d->objs);
|
|
|
|
int i2 = simple_a_get(s1);
|
|
|
|
fail_if(i1 != i2);
|
|
|
|
fail_if(efl_composite_attach(d->objs, s2));
|
|
|
|
efl_del(s1);
|
|
|
|
fail_if(!efl_composite_attach(d->objs, s2));
|
|
|
|
efl_del(s2);
|
2016-10-06 00:19:12 -07:00
|
|
|
|
2016-09-09 02:42:21 -07:00
|
|
|
printf("SET ON LOCAL\n");
|
|
|
|
domain_a_set(obj, 1234);
|
|
|
|
fail_if(domain_a_get(obj) != 1234);
|
|
|
|
printf("SET ON LOCAL DONE\n");
|
|
|
|
|
|
|
|
printf("SET ON SHARED\n");
|
|
|
|
domain_a_set(d->objs, 1234);
|
|
|
|
fail_if(domain_a_get(d->objs) != 1234);
|
|
|
|
printf("SET ON SHARED DONE\n");
|
|
|
|
|
|
|
|
printf("FAAAAIL check %p\n", d->obj);
|
|
|
|
domain_a_set(d->obj, 1234);
|
|
|
|
int v = domain_a_get(d->obj);
|
|
|
|
printf("........ v = %i\n", v);
|
|
|
|
fail_if(v == 1234);
|
|
|
|
sleep(1);
|
|
|
|
printf("FAAAAIL DONE\n");
|
|
|
|
|
|
|
|
printf("ADOPT...\n");
|
|
|
|
dom = efl_domain_data_adopt(d->dat);
|
|
|
|
fail_if(dom != EFL_ID_DOMAIN_MAIN);
|
|
|
|
printf("SUCCEED check %p\n", d->obj);
|
|
|
|
domain_a_set(d->obj, 8910);
|
|
|
|
v = domain_a_get(d->obj);
|
|
|
|
printf("........ v = %i\n", v);
|
|
|
|
fail_if(v != 8910);
|
|
|
|
sleep(1);
|
|
|
|
printf("SUCCEED DONE\n");
|
|
|
|
|
|
|
|
printf("RETURN DOMAIN DATA\n");
|
|
|
|
fail_if(efl_domain_data_return(dom) != EINA_TRUE);
|
|
|
|
printf("RETURN DOMAIN DATA DONE\n");
|
|
|
|
|
|
|
|
efl_del(obj);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-10-05 23:42:03 -07:00
|
|
|
#ifndef _WIN32
|
|
|
|
static void
|
|
|
|
_timeout(int val EINA_UNUSED)
|
|
|
|
{
|
2016-10-06 00:27:28 -07:00
|
|
|
EINA_LOG_CRIT("TIMED OUT!");
|
2016-10-05 23:42:03 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-09-08 02:39:38 -07:00
|
|
|
START_TEST(eo_domain)
|
|
|
|
{
|
|
|
|
Eo *obj, *objs;
|
|
|
|
|
|
|
|
printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
|
|
|
|
efl_object_init();
|
|
|
|
|
2016-10-05 23:42:03 -07:00
|
|
|
#ifndef _WIN32
|
|
|
|
signal(SIGALRM, _timeout);
|
|
|
|
alarm(10);
|
|
|
|
#endif
|
|
|
|
|
2016-09-08 02:39:38 -07:00
|
|
|
fail_if(efl_domain_get() != EFL_ID_DOMAIN_MAIN);
|
|
|
|
|
|
|
|
fail_if(efl_domain_switch(EFL_ID_DOMAIN_THREAD) != EINA_TRUE);
|
|
|
|
|
|
|
|
fail_if(efl_domain_get() != EFL_ID_DOMAIN_THREAD);
|
|
|
|
|
|
|
|
fail_if(efl_domain_switch(EFL_ID_DOMAIN_MAIN) != EINA_TRUE);
|
|
|
|
|
|
|
|
fail_if(efl_domain_get() != EFL_ID_DOMAIN_MAIN);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_get() != EFL_ID_DOMAIN_MAIN);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_set(EFL_ID_DOMAIN_SHARED) != EINA_TRUE);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_get() != EFL_ID_DOMAIN_SHARED);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_set(EFL_ID_DOMAIN_MAIN) != EINA_TRUE);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_get() != EFL_ID_DOMAIN_MAIN);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_push(EFL_ID_DOMAIN_SHARED) != EINA_TRUE);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_get() != EFL_ID_DOMAIN_SHARED);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_push(EFL_ID_DOMAIN_THREAD) != EINA_TRUE);
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_get() != EFL_ID_DOMAIN_THREAD);
|
|
|
|
|
|
|
|
efl_domain_current_pop();
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_get() != EFL_ID_DOMAIN_SHARED);
|
|
|
|
|
|
|
|
efl_domain_current_pop();
|
|
|
|
|
|
|
|
fail_if(efl_domain_current_get() != EFL_ID_DOMAIN_MAIN);
|
|
|
|
|
2016-09-09 02:42:21 -07:00
|
|
|
printf("ADD1\n");
|
|
|
|
obj = efl_add(DOMAIN_CLASS, NULL);
|
|
|
|
printf("ADD1 DONE = %p\n", obj);
|
2016-09-08 02:39:38 -07:00
|
|
|
|
|
|
|
efl_domain_current_push(EFL_ID_DOMAIN_SHARED);
|
2016-09-09 02:42:21 -07:00
|
|
|
printf("ADDS\n");
|
2016-10-05 23:42:03 -07:00
|
|
|
objs = efl_add(DOMAIN_CLASS, NULL, domain_a_set(efl_added, 42));
|
2016-09-09 02:42:21 -07:00
|
|
|
printf("ADDS DONE = %p\n", objs);
|
2016-09-08 02:39:38 -07:00
|
|
|
efl_domain_current_pop();
|
|
|
|
|
|
|
|
fail_if(efl_compatible(objs, obj) == EINA_TRUE);
|
|
|
|
|
|
|
|
domain_a_set(obj, 1234);
|
|
|
|
fail_if(domain_a_get(obj) != 1234);
|
|
|
|
|
|
|
|
domain_a_set(objs, 1234);
|
|
|
|
fail_if(domain_a_get(objs) != 1234);
|
|
|
|
|
2016-09-09 02:42:21 -07:00
|
|
|
Eina_Thread t;
|
|
|
|
Data data;
|
|
|
|
data.obj = obj;
|
|
|
|
data.objs = objs;
|
|
|
|
printf("GET DOMAIN DATA\n");
|
|
|
|
data.dat = efl_domain_data_get();
|
|
|
|
fail_if(data.dat == NULL);
|
|
|
|
printf("THR CREATE\n");
|
|
|
|
fail_if(!eina_thread_create(&t, EINA_THREAD_NORMAL, -1, thr1, &data));
|
|
|
|
printf("JOIN\n");
|
|
|
|
eina_thread_join(t);
|
|
|
|
printf("JOIN DONE\n");
|
|
|
|
|
2016-10-05 23:42:03 -07:00
|
|
|
printf("DELETING OBJECTS\n");
|
2016-09-08 02:39:38 -07:00
|
|
|
efl_del(obj);
|
|
|
|
efl_del(objs);
|
|
|
|
|
|
|
|
efl_object_shutdown();
|
|
|
|
printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
|
2016-10-05 23:42:03 -07:00
|
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
alarm(0);
|
|
|
|
signal(SIGALRM, NULL);
|
|
|
|
#endif
|
2016-09-08 02:39:38 -07:00
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2012-05-01 00:40:14 -07:00
|
|
|
void eo_test_general(TCase *tc)
|
|
|
|
{
|
|
|
|
tcase_add_test(tc, eo_simple);
|
2016-05-18 05:29:45 -07:00
|
|
|
tcase_add_test(tc, eo_singleton);
|
2016-08-15 06:44:41 -07:00
|
|
|
tcase_add_test(tc, efl_object_override_tests);
|
2013-11-08 04:25:39 -08:00
|
|
|
tcase_add_test(tc, eo_signals);
|
2016-08-15 06:44:41 -07:00
|
|
|
tcase_add_test(tc, efl_data_fetch);
|
|
|
|
tcase_add_test(tc, efl_isa_tests);
|
2016-08-10 07:23:04 -07:00
|
|
|
tcase_add_test(tc, efl_composite_tests);
|
2013-11-08 04:25:39 -08:00
|
|
|
tcase_add_test(tc, eo_man_free);
|
2016-08-15 06:44:41 -07:00
|
|
|
tcase_add_test(tc, efl_refs);
|
|
|
|
tcase_add_test(tc, efl_weak_reference);
|
2013-11-08 04:25:39 -08:00
|
|
|
tcase_add_test(tc, eo_generic_data);
|
|
|
|
tcase_add_test(tc, eo_magic_checks);
|
2016-10-19 08:20:19 -07:00
|
|
|
tcase_add_test(tc, efl_func_resolve);
|
2016-08-15 06:44:41 -07:00
|
|
|
tcase_add_test(tc, efl_add_do_and_custom);
|
2013-04-18 03:55:55 -07:00
|
|
|
tcase_add_test(tc, eo_pointers_indirection);
|
2016-08-15 06:44:41 -07:00
|
|
|
tcase_add_test(tc, efl_add_failures);
|
2016-08-10 07:23:04 -07:00
|
|
|
tcase_add_test(tc, efl_del_intercept);
|
|
|
|
tcase_add_test(tc, efl_name);
|
2016-04-19 01:21:21 -07:00
|
|
|
tcase_add_test(tc, eo_comment);
|
2016-05-04 01:08:00 -07:00
|
|
|
tcase_add_test(tc, eo_rec_interface);
|
2016-09-08 02:39:38 -07:00
|
|
|
tcase_add_test(tc, eo_domain);
|
2012-05-01 00:40:14 -07:00
|
|
|
}
|