summaryrefslogtreecommitdiff
path: root/src/tests/eo/suite
diff options
context:
space:
mode:
authorTom Hacohen <tom@stosb.com>2016-08-10 15:23:04 +0100
committerTom Hacohen <tom@stosb.com>2016-08-11 17:04:43 +0100
commitc662934be8bcbaba60d1688e77533acbea5d09b9 (patch)
tree8e12b5ffd083024f09b7ec7fa9f979113056fb9d /src/tests/eo/suite
parente64e120a51972c44fb8cae88a78bb4aa34f502c7 (diff)
Change the EFL to follow the new Eo rename.
Diffstat (limited to 'src/tests/eo/suite')
-rw-r--r--src/tests/eo/suite/eo_test_class_behaviour_errors.c24
-rw-r--r--src/tests/eo/suite/eo_test_class_errors.c58
-rw-r--r--src/tests/eo/suite/eo_test_class_simple.c40
-rw-r--r--src/tests/eo/suite/eo_test_class_simple.h12
-rw-r--r--src/tests/eo/suite/eo_test_class_singleton.c8
-rw-r--r--src/tests/eo/suite/eo_test_class_singleton.h2
-rw-r--r--src/tests/eo/suite/eo_test_general.c450
-rw-r--r--src/tests/eo/suite/eo_test_init.c4
-rw-r--r--src/tests/eo/suite/eo_test_threaded_calls.c6
-rw-r--r--src/tests/eo/suite/eo_test_value.c4
10 files changed, 304 insertions, 304 deletions
diff --git a/src/tests/eo/suite/eo_test_class_behaviour_errors.c b/src/tests/eo/suite/eo_test_class_behaviour_errors.c
index 3b25b389c0..5689f91a65 100644
--- a/src/tests/eo/suite/eo_test_class_behaviour_errors.c
+++ b/src/tests/eo/suite/eo_test_class_behaviour_errors.c
@@ -12,26 +12,26 @@
12 12
13static struct log_ctx ctx; 13static struct log_ctx ctx;
14 14
15const Eo_Class *klass; 15const Efl_Class *klass;
16 16
17static void _destructor_unref(Eo *obj, void *class_data EINA_UNUSED) 17static void _destructor_unref(Eo *obj, void *class_data EINA_UNUSED)
18{ 18{
19 eo_destructor(eo_super(obj, klass)); 19 efl_destructor(eo_super(obj, klass));
20 20
21 /* this triggers an eo stack overflow if not correctly protected */ 21 /* this triggers an eo stack overflow if not correctly protected */
22 eo_unref(obj); 22 eo_unref(obj);
23} 23}
24 24
25START_TEST(eo_destructor_unref) 25START_TEST(efl_destructor_unref)
26{ 26{
27 eo_init(); 27 eo_init();
28 eina_log_print_cb_set(eo_test_print_cb, &ctx); 28 eina_log_print_cb_set(eo_test_print_cb, &ctx);
29 29
30 static Eo_Op_Description op_descs [] = { 30 static Efl_Op_Description op_descs [] = {
31 EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor_unref), 31 EO_OP_FUNC_OVERRIDE(efl_destructor, _destructor_unref),
32 }; 32 };
33 33
34 static Eo_Class_Description class_desc = { 34 static Efl_Class_Description class_desc = {
35 EO_VERSION, 35 EO_VERSION,
36 "Simple", 36 "Simple",
37 EO_CLASS_TYPE_REGULAR, 37 EO_CLASS_TYPE_REGULAR,
@@ -57,12 +57,12 @@ START_TEST(eo_destructor_unref)
57} 57}
58END_TEST 58END_TEST
59 59
60START_TEST(eo_destructor_double_del) 60START_TEST(efl_destructor_double_del)
61{ 61{
62 eo_init(); 62 eo_init();
63 eina_log_print_cb_set(eo_test_print_cb, &ctx); 63 eina_log_print_cb_set(eo_test_print_cb, &ctx);
64 64
65 static Eo_Class_Description class_desc = { 65 static Efl_Class_Description class_desc = {
66 EO_VERSION, 66 EO_VERSION,
67 "Simple", 67 "Simple",
68 EO_CLASS_TYPE_REGULAR, 68 EO_CLASS_TYPE_REGULAR,
@@ -81,8 +81,8 @@ START_TEST(eo_destructor_double_del)
81 fail_if(!obj); 81 fail_if(!obj);
82 82
83 TEST_EO_ERROR("eo_unref", "Obj:%p. User refcount (%d) < 0. Too many unrefs."); 83 TEST_EO_ERROR("eo_unref", "Obj:%p. User refcount (%d) < 0. Too many unrefs.");
84 eo_del(obj); 84 efl_del(obj);
85 eo_del(obj); 85 efl_del(obj);
86 86
87 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 87 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
88 88
@@ -92,6 +92,6 @@ END_TEST
92 92
93void eo_test_class_behaviour_errors(TCase *tc) 93void eo_test_class_behaviour_errors(TCase *tc)
94{ 94{
95 tcase_add_test(tc, eo_destructor_unref); 95 tcase_add_test(tc, efl_destructor_unref);
96 tcase_add_test(tc, eo_destructor_double_del); 96 tcase_add_test(tc, efl_destructor_double_del);
97} 97}
diff --git a/src/tests/eo/suite/eo_test_class_errors.c b/src/tests/eo/suite/eo_test_class_errors.c
index 276c6d7785..d2bac92adf 100644
--- a/src/tests/eo/suite/eo_test_class_errors.c
+++ b/src/tests/eo/suite/eo_test_class_errors.c
@@ -17,11 +17,11 @@ START_TEST(eo_inherit_errors)
17 eo_init(); 17 eo_init();
18 eina_log_print_cb_set(eo_test_print_cb, &ctx); 18 eina_log_print_cb_set(eo_test_print_cb, &ctx);
19 19
20 const Eo_Class *klass; 20 const Efl_Class *klass;
21 const Eo_Class *klass_mixin; 21 const Efl_Class *klass_mixin;
22 const Eo_Class *klass_simple; 22 const Efl_Class *klass_simple;
23 23
24 static const Eo_Class_Description class_desc_simple = { 24 static const Efl_Class_Description class_desc_simple = {
25 EO_VERSION, 25 EO_VERSION,
26 "Simple", 26 "Simple",
27 EO_CLASS_TYPE_REGULAR, 27 EO_CLASS_TYPE_REGULAR,
@@ -32,7 +32,7 @@ START_TEST(eo_inherit_errors)
32 NULL 32 NULL
33 }; 33 };
34 34
35 static const Eo_Class_Description class_desc_mixin = { 35 static const Efl_Class_Description class_desc_mixin = {
36 EO_VERSION, 36 EO_VERSION,
37 "Mixin", 37 "Mixin",
38 EO_CLASS_TYPE_MIXIN, 38 EO_CLASS_TYPE_MIXIN,
@@ -43,7 +43,7 @@ START_TEST(eo_inherit_errors)
43 NULL 43 NULL
44 }; 44 };
45 45
46 static Eo_Class_Description class_desc = { 46 static Efl_Class_Description class_desc = {
47 EO_VERSION, 47 EO_VERSION,
48 "General", 48 "General",
49 EO_CLASS_TYPE_MIXIN, 49 EO_CLASS_TYPE_MIXIN,
@@ -84,12 +84,12 @@ START_TEST(eo_inconsistent_mro)
84 eo_init(); 84 eo_init();
85 eina_log_print_cb_set(eo_test_print_cb, &ctx); 85 eina_log_print_cb_set(eo_test_print_cb, &ctx);
86 86
87 const Eo_Class *klass; 87 const Efl_Class *klass;
88 const Eo_Class *klass_mixin; 88 const Efl_Class *klass_mixin;
89 const Eo_Class *klass_mixin2; 89 const Efl_Class *klass_mixin2;
90 const Eo_Class *klass_mixin3; 90 const Efl_Class *klass_mixin3;
91 91
92 static const Eo_Class_Description class_desc_simple = { 92 static const Efl_Class_Description class_desc_simple = {
93 EO_VERSION, 93 EO_VERSION,
94 "Simple", 94 "Simple",
95 EO_CLASS_TYPE_REGULAR, 95 EO_CLASS_TYPE_REGULAR,
@@ -100,7 +100,7 @@ START_TEST(eo_inconsistent_mro)
100 NULL 100 NULL
101 }; 101 };
102 102
103 static const Eo_Class_Description class_desc_mixin = { 103 static const Efl_Class_Description class_desc_mixin = {
104 EO_VERSION, 104 EO_VERSION,
105 "Mixin", 105 "Mixin",
106 EO_CLASS_TYPE_MIXIN, 106 EO_CLASS_TYPE_MIXIN,
@@ -111,7 +111,7 @@ START_TEST(eo_inconsistent_mro)
111 NULL 111 NULL
112 }; 112 };
113 113
114 static const Eo_Class_Description class_desc_mixin2 = { 114 static const Efl_Class_Description class_desc_mixin2 = {
115 EO_VERSION, 115 EO_VERSION,
116 "Mixin2", 116 "Mixin2",
117 EO_CLASS_TYPE_MIXIN, 117 EO_CLASS_TYPE_MIXIN,
@@ -122,7 +122,7 @@ START_TEST(eo_inconsistent_mro)
122 NULL 122 NULL
123 }; 123 };
124 124
125 static const Eo_Class_Description class_desc_mixin3 = { 125 static const Efl_Class_Description class_desc_mixin3 = {
126 EO_VERSION, 126 EO_VERSION,
127 "Mixin3", 127 "Mixin3",
128 EO_CLASS_TYPE_MIXIN, 128 EO_CLASS_TYPE_MIXIN,
@@ -159,16 +159,16 @@ START_TEST(eo_inconsistent_mro)
159} 159}
160END_TEST 160END_TEST
161 161
162static void _stub_class_constructor(Eo_Class *klass EINA_UNUSED) {} 162static void _stub_class_constructor(Efl_Class *klass EINA_UNUSED) {}
163 163
164START_TEST(eo_bad_interface) 164START_TEST(eo_bad_interface)
165{ 165{
166 eo_init(); 166 eo_init();
167 eina_log_print_cb_set(eo_test_safety_print_cb, &ctx); 167 eina_log_print_cb_set(eo_test_safety_print_cb, &ctx);
168 168
169 const Eo_Class *klass; 169 const Efl_Class *klass;
170 170
171 static Eo_Class_Description class_desc = { 171 static Efl_Class_Description class_desc = {
172 EO_VERSION, 172 EO_VERSION,
173 "Interface", 173 "Interface",
174 EO_CLASS_TYPE_INTERFACE, 174 EO_CLASS_TYPE_INTERFACE,
@@ -215,12 +215,12 @@ START_TEST(eo_null_api)
215 eo_init(); 215 eo_init();
216 eina_log_print_cb_set(eo_test_print_cb, &ctx); 216 eina_log_print_cb_set(eo_test_print_cb, &ctx);
217 217
218 const Eo_Class *klass; 218 const Efl_Class *klass;
219 219
220 static Eo_Op_Description op_descs[] = { 220 static Efl_Op_Description op_descs[] = {
221 EO_OP_FUNC(NULL, _null_fct), 221 EO_OP_FUNC(NULL, _null_fct),
222 }; 222 };
223 static Eo_Class_Description class_desc = { 223 static Efl_Class_Description class_desc = {
224 EO_VERSION, 224 EO_VERSION,
225 "Simple", 225 "Simple",
226 EO_CLASS_TYPE_REGULAR, 226 EO_CLASS_TYPE_REGULAR,
@@ -247,12 +247,12 @@ START_TEST(eo_wrong_override)
247 eo_init(); 247 eo_init();
248 eina_log_print_cb_set(eo_test_print_cb, &ctx); 248 eina_log_print_cb_set(eo_test_print_cb, &ctx);
249 249
250 const Eo_Class *klass; 250 const Efl_Class *klass;
251 251
252 static Eo_Op_Description op_descs[] = { 252 static Efl_Op_Description op_descs[] = {
253 EO_OP_FUNC_OVERRIDE(null_fct, _null_fct), 253 EO_OP_FUNC_OVERRIDE(null_fct, _null_fct),
254 }; 254 };
255 static Eo_Class_Description class_desc = { 255 static Efl_Class_Description class_desc = {
256 EO_VERSION, 256 EO_VERSION,
257 "Simple", 257 "Simple",
258 EO_CLASS_TYPE_REGULAR, 258 EO_CLASS_TYPE_REGULAR,
@@ -279,13 +279,13 @@ START_TEST(eo_api_redefined)
279 eo_init(); 279 eo_init();
280 eina_log_print_cb_set(eo_test_print_cb, &ctx); 280 eina_log_print_cb_set(eo_test_print_cb, &ctx);
281 281
282 const Eo_Class *klass; 282 const Efl_Class *klass;
283 283
284 static Eo_Op_Description op_descs[] = { 284 static Efl_Op_Description op_descs[] = {
285 EO_OP_FUNC(null_fct, _null_fct), 285 EO_OP_FUNC(null_fct, _null_fct),
286 EO_OP_FUNC(null_fct, NULL), 286 EO_OP_FUNC(null_fct, NULL),
287 }; 287 };
288 static Eo_Class_Description class_desc = { 288 static Efl_Class_Description class_desc = {
289 EO_VERSION, 289 EO_VERSION,
290 "Simple", 290 "Simple",
291 EO_CLASS_TYPE_REGULAR, 291 EO_CLASS_TYPE_REGULAR,
@@ -312,13 +312,13 @@ START_TEST(eo_dich_func_override)
312 eo_init(); 312 eo_init();
313 eina_log_print_cb_set(eo_test_print_cb, &ctx); 313 eina_log_print_cb_set(eo_test_print_cb, &ctx);
314 314
315 const Eo_Class *klass; 315 const Efl_Class *klass;
316 316
317 static Eo_Op_Description op_descs[] = { 317 static Efl_Op_Description op_descs[] = {
318 EO_OP_FUNC_OVERRIDE(simple_a_set, _null_fct), 318 EO_OP_FUNC_OVERRIDE(simple_a_set, _null_fct),
319 EO_OP_FUNC_OVERRIDE(simple_a_set, NULL), 319 EO_OP_FUNC_OVERRIDE(simple_a_set, NULL),
320 }; 320 };
321 static Eo_Class_Description class_desc = { 321 static Efl_Class_Description class_desc = {
322 EO_VERSION, 322 EO_VERSION,
323 "Simple", 323 "Simple",
324 EO_CLASS_TYPE_REGULAR, 324 EO_CLASS_TYPE_REGULAR,
diff --git a/src/tests/eo/suite/eo_test_class_simple.c b/src/tests/eo/suite/eo_test_class_simple.c
index dcc3991553..b4f715d752 100644
--- a/src/tests/eo/suite/eo_test_class_simple.c
+++ b/src/tests/eo/suite/eo_test_class_simple.c
@@ -7,11 +7,11 @@
7 7
8#define MY_CLASS SIMPLE_CLASS 8#define MY_CLASS SIMPLE_CLASS
9 9
10EAPI const Eo_Event_Description _EV_A_CHANGED = 10EAPI const Efl_Event_Description _EV_A_CHANGED =
11 EO_EVENT_DESCRIPTION("a,changed"); 11 EFL_EVENT_DESCRIPTION("a,changed");
12 12
13EAPI const Eo_Event_Description _EV_A_CHANGED2 = 13EAPI const Efl_Event_Description _EV_A_CHANGED2 =
14 EO_EVENT_DESCRIPTION("a,changed"); 14 EFL_EVENT_DESCRIPTION("a,changed");
15 15
16static void 16static void
17_a_set(Eo *obj EINA_UNUSED, void *class_data, int a) 17_a_set(Eo *obj EINA_UNUSED, void *class_data, int a)
@@ -20,7 +20,7 @@ _a_set(Eo *obj EINA_UNUSED, void *class_data, int a)
20 printf("%s %d\n", eo_class_name_get(MY_CLASS), a); 20 printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
21 pd->a = a; 21 pd->a = a;
22 22
23 eo_event_callback_call(obj, EV_A_CHANGED, &pd->a); 23 efl_event_callback_call(obj, EV_A_CHANGED, &pd->a);
24} 24}
25 25
26static int 26static int
@@ -41,7 +41,7 @@ _a_print(Eo *obj EINA_UNUSED, void *class_data)
41} 41}
42 42
43static Eina_Bool 43static Eina_Bool
44_class_hi_print(Eo_Class *klass, void *data EINA_UNUSED) 44_class_hi_print(Efl_Class *klass, void *data EINA_UNUSED)
45{ 45{
46 printf("Hi Print %s\n", eo_class_name_get(klass)); 46 printf("Hi Print %s\n", eo_class_name_get(klass));
47 47
@@ -74,10 +74,10 @@ _recursive(Eo *obj, void *class_data EINA_UNUSED, int n)
74} 74}
75 75
76static void 76static void
77_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, Eo_Dbg_Info *root) 77_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, Efl_Dbg_Info *root)
78{ 78{
79 eo_dbg_info_get(eo_super(eo_obj, MY_CLASS), root); 79 efl_dbg_info_get(eo_super(eo_obj, MY_CLASS), root);
80 Eo_Dbg_Info *group = EO_DBG_INFO_LIST_APPEND(root, "Test list"); 80 Efl_Dbg_Info *group = EO_DBG_INFO_LIST_APPEND(root, "Test list");
81 EO_DBG_INFO_APPEND(group, "Test", EINA_VALUE_TYPE_INT, 8); 81 EO_DBG_INFO_APPEND(group, "Test", EINA_VALUE_TYPE_INT, 8);
82} 82}
83 83
@@ -88,7 +88,7 @@ EO_FUNC_BODY_CONST(simple_class_hi_print, Eina_Bool, EINA_FALSE);
88EO_VOID_FUNC_BODY(simple_pure_virtual); 88EO_VOID_FUNC_BODY(simple_pure_virtual);
89EO_VOID_FUNC_BODY(simple_no_implementation); 89EO_VOID_FUNC_BODY(simple_no_implementation);
90 90
91static Eo_Op_Description op_descs[] = { 91static Efl_Op_Description op_descs[] = {
92 EO_OP_FUNC(simple_a_set, _a_set), 92 EO_OP_FUNC(simple_a_set, _a_set),
93 EO_OP_FUNC(simple_a_get, _a_get), 93 EO_OP_FUNC(simple_a_get, _a_get),
94 EO_OP_FUNC(simple_a_print, _a_print), 94 EO_OP_FUNC(simple_a_print, _a_print),
@@ -96,10 +96,10 @@ static Eo_Op_Description op_descs[] = {
96 EO_OP_FUNC(simple_recursive, _recursive), 96 EO_OP_FUNC(simple_recursive, _recursive),
97 EO_OP_FUNC(simple_part_get, _part_get), 97 EO_OP_FUNC(simple_part_get, _part_get),
98 EO_OP_FUNC(simple_pure_virtual, NULL), 98 EO_OP_FUNC(simple_pure_virtual, NULL),
99 EO_OP_FUNC_OVERRIDE(eo_dbg_info_get, _dbg_info_get), 99 EO_OP_FUNC_OVERRIDE(efl_dbg_info_get, _dbg_info_get),
100}; 100};
101 101
102static const Eo_Class_Description class_desc = { 102static const Efl_Class_Description class_desc = {
103 EO_VERSION, 103 EO_VERSION,
104 "Simple", 104 "Simple",
105 EO_CLASS_TYPE_REGULAR, 105 EO_CLASS_TYPE_REGULAR,
@@ -121,11 +121,11 @@ _beef_get(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
121 121
122EO_FUNC_BODY_CONST(simple2_class_beef_get, int, 0); 122EO_FUNC_BODY_CONST(simple2_class_beef_get, int, 0);
123 123
124static Eo_Op_Description op_descs2[] = { 124static Efl_Op_Description op_descs2[] = {
125 EO_OP_CLASS_FUNC(simple2_class_beef_get, _beef_get), 125 EO_OP_CLASS_FUNC(simple2_class_beef_get, _beef_get),
126}; 126};
127 127
128static const Eo_Class_Description class_desc2 = { 128static const Efl_Class_Description class_desc2 = {
129 EO_VERSION, 129 EO_VERSION,
130 "Simple2", 130 "Simple2",
131 EO_CLASS_TYPE_REGULAR, 131 EO_CLASS_TYPE_REGULAR,
@@ -138,19 +138,19 @@ static const Eo_Class_Description class_desc2 = {
138 138
139EO_DEFINE_CLASS(simple2_class_get, &class_desc2, EO_CLASS, NULL) 139EO_DEFINE_CLASS(simple2_class_get, &class_desc2, EO_CLASS, NULL)
140 140
141static Eo_Base* 141static Efl_Object*
142_interface_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, const Eo_Base *klass) 142_interface_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, const Efl_Object *klass)
143{ 143{
144 if (klass == SEARCHABLE_CLASS) return obj; 144 if (klass == SEARCHABLE_CLASS) return obj;
145 145
146 return eo_provider_find(eo_super(obj, SEARCHABLE_CLASS), klass); 146 return efl_provider_find(eo_super(obj, SEARCHABLE_CLASS), klass);
147} 147}
148 148
149static Eo_Op_Description op_descs_searchable[] = { 149static Efl_Op_Description op_descs_searchable[] = {
150 EO_OP_FUNC_OVERRIDE(eo_provider_find, _interface_get) 150 EO_OP_FUNC_OVERRIDE(efl_provider_find, _interface_get)
151}; 151};
152 152
153static const Eo_Class_Description class_desc_searchable = { 153static const Efl_Class_Description class_desc_searchable = {
154 EO_VERSION, 154 EO_VERSION,
155 "Searchable", 155 "Searchable",
156 EO_CLASS_TYPE_REGULAR, 156 EO_CLASS_TYPE_REGULAR,
diff --git a/src/tests/eo/suite/eo_test_class_simple.h b/src/tests/eo/suite/eo_test_class_simple.h
index 8d92d96bfc..7d7432b5a0 100644
--- a/src/tests/eo/suite/eo_test_class_simple.h
+++ b/src/tests/eo/suite/eo_test_class_simple.h
@@ -15,21 +15,21 @@ EAPI void simple_pure_virtual(Eo *obj);
15EAPI void simple_no_implementation(Eo *obj); 15EAPI void simple_no_implementation(Eo *obj);
16EAPI Eo *simple_part_get(Eo *obj, const char *name); 16EAPI Eo *simple_part_get(Eo *obj, const char *name);
17 17
18extern const Eo_Event_Description _EV_A_CHANGED; 18extern const Efl_Event_Description _EV_A_CHANGED;
19#define EV_A_CHANGED (&(_EV_A_CHANGED)) 19#define EV_A_CHANGED (&(_EV_A_CHANGED))
20 20
21extern const Eo_Event_Description _EV_A_CHANGED2; 21extern const Efl_Event_Description _EV_A_CHANGED2;
22#define EV_A_CHANGED2 (&(_EV_A_CHANGED2)) 22#define EV_A_CHANGED2 (&(_EV_A_CHANGED2))
23 23
24#define SIMPLE_CLASS simple_class_get() 24#define SIMPLE_CLASS simple_class_get()
25const Eo_Class *simple_class_get(void); 25const Efl_Class *simple_class_get(void);
26 26
27EAPI int simple2_class_beef_get(const Eo_Class *obj); 27EAPI int simple2_class_beef_get(const Efl_Class *obj);
28 28
29#define SIMPLE2_CLASS simple2_class_get() 29#define SIMPLE2_CLASS simple2_class_get()
30const Eo_Class *simple2_class_get(void); 30const Efl_Class *simple2_class_get(void);
31 31
32#define SEARCHABLE_CLASS searchable_class_get() 32#define SEARCHABLE_CLASS searchable_class_get()
33const Eo_Class *searchable_class_get(void); 33const Efl_Class *searchable_class_get(void);
34 34
35#endif 35#endif
diff --git a/src/tests/eo/suite/eo_test_class_singleton.c b/src/tests/eo/suite/eo_test_class_singleton.c
index 4898abc55f..692e382075 100644
--- a/src/tests/eo/suite/eo_test_class_singleton.c
+++ b/src/tests/eo/suite/eo_test_class_singleton.c
@@ -11,7 +11,7 @@
11static Eo *singleton_obj = NULL; 11static Eo *singleton_obj = NULL;
12 12
13static Eo * 13static Eo *
14_singleton_eo_constructor(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED) 14_singleton_efl_constructor(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED)
15{ 15{
16 if (!singleton_obj) 16 if (!singleton_obj)
17 { 17 {
@@ -25,11 +25,11 @@ _singleton_eo_constructor(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED)
25 return singleton_obj; 25 return singleton_obj;
26} 26}
27 27
28static Eo_Op_Description op_descs[] = { 28static Efl_Op_Description op_descs[] = {
29 EO_OP_FUNC_OVERRIDE(eo_constructor, _singleton_eo_constructor), 29 EO_OP_FUNC_OVERRIDE(efl_constructor, _singleton_efl_constructor),
30}; 30};
31 31
32static const Eo_Class_Description class_desc = { 32static const Efl_Class_Description class_desc = {
33 EO_VERSION, 33 EO_VERSION,
34 "Singleton", 34 "Singleton",
35 EO_CLASS_TYPE_REGULAR, 35 EO_CLASS_TYPE_REGULAR,
diff --git a/src/tests/eo/suite/eo_test_class_singleton.h b/src/tests/eo/suite/eo_test_class_singleton.h
index 7aafb35cc5..3008b8fdc4 100644
--- a/src/tests/eo/suite/eo_test_class_singleton.h
+++ b/src/tests/eo/suite/eo_test_class_singleton.h
@@ -2,6 +2,6 @@
2#define SINGLETON_H 2#define SINGLETON_H
3 3
4#define SINGLETON_CLASS singleton_class_get() 4#define SINGLETON_CLASS singleton_class_get()
5const Eo_Class *singleton_class_get(void); 5const Efl_Class *singleton_class_get(void);
6 6
7#endif 7#endif
diff --git a/src/tests/eo/suite/eo_test_general.c b/src/tests/eo/suite/eo_test_general.c
index de7c25883d..24705019fc 100644
--- a/src/tests/eo/suite/eo_test_general.c
+++ b/src/tests/eo/suite/eo_test_general.c
@@ -21,8 +21,8 @@ START_TEST(eo_simple)
21 21
22 obj = eo_add(SIMPLE_CLASS, NULL); 22 obj = eo_add(SIMPLE_CLASS, NULL);
23 fail_if(!obj); 23 fail_if(!obj);
24 eo_constructor(obj); 24 efl_constructor(obj);
25 eo_destructor(obj); 25 efl_destructor(obj);
26 eo_unref(obj); 26 eo_unref(obj);
27 27
28 eo_shutdown(); 28 eo_shutdown();
@@ -53,13 +53,13 @@ END_TEST
53static int 53static int
54_simple_obj_override_a_get(Eo *obj, void *class_data EINA_UNUSED) 54_simple_obj_override_a_get(Eo *obj, void *class_data EINA_UNUSED)
55{ 55{
56 return OVERRIDE_A + simple_a_get(eo_super(obj, EO_OVERRIDE_CLASS)); 56 return OVERRIDE_A + simple_a_get(eo_super(obj, EFL_OBJECT_OVERRIDE_CLASS));
57} 57}
58 58
59static void 59static void
60_simple_obj_override_a_double_set(Eo *obj, void *class_data EINA_UNUSED, int a) 60_simple_obj_override_a_double_set(Eo *obj, void *class_data EINA_UNUSED, int a)
61{ 61{
62 simple_a_set(eo_super(obj, EO_OVERRIDE_CLASS), 2 * a); 62 simple_a_set(eo_super(obj, EFL_OBJECT_OVERRIDE_CLASS), 2 * a);
63} 63}
64 64
65START_TEST(eo_override_tests) 65START_TEST(eo_override_tests)
@@ -132,14 +132,14 @@ static void
132_eo_signals_a_changed_cb2(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED) 132_eo_signals_a_changed_cb2(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED)
133{ 133{
134 _eo_signals_cb_flag |= 0x2; 134 _eo_signals_cb_flag |= 0x2;
135 eo_event_callback_stop(event->object); 135 efl_event_callback_stop(event->object);
136} 136}
137 137
138static void 138static void
139_eo_signals_a_changed_within_cb(void *_data EINA_UNUSED, const Eo_Event *event) 139_eo_signals_a_changed_within_cb(void *_data EINA_UNUSED, const Eo_Event *event)
140{ 140{
141 int a = 3; 141 int a = 3;
142 eo_event_callback_call(event->object, EV_A_CHANGED, &a); 142 efl_event_callback_call(event->object, EV_A_CHANGED, &a);
143 _eo_signals_cb_flag = 0x8; 143 _eo_signals_cb_flag = 0x8;
144} 144}
145 145
@@ -151,7 +151,7 @@ _eo_signals_a_changed_never(void *_data EINA_UNUSED, const Eo_Event *event EINA_
151} 151}
152 152
153static void 153static void
154_eo_signals_eo_del_cb(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED) 154_eo_signals_efl_del_cb(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED)
155{ 155{
156 _eo_signals_cb_flag |= 0x4; 156 _eo_signals_cb_flag |= 0x4;
157} 157}
@@ -159,8 +159,8 @@ _eo_signals_eo_del_cb(void *_data EINA_UNUSED, const Eo_Event *event EINA_UNUSED
159void 159void
160_eo_signals_cb_added_deled(void *data, const Eo_Event *event) 160_eo_signals_cb_added_deled(void *data, const Eo_Event *event)
161{ 161{
162 const Eo_Callback_Array_Item *callback_array = event->info; 162 const Efl_Callback_Array_Item *callback_array = event->info;
163 const Eo_Callback_Array_Item *(*callback_data)(void) = data; 163 const Efl_Callback_Array_Item *(*callback_data)(void) = data;
164 164
165 fail_if((callback_data() != callback_array) && 165 fail_if((callback_data() != callback_array) &&
166 (callback_array->func != _eo_signals_cb_added_deled)); 166 (callback_array->func != _eo_signals_cb_added_deled));
@@ -170,7 +170,7 @@ EO_CALLBACKS_ARRAY_DEFINE(_eo_signals_callbacks,
170{ EV_A_CHANGED, _eo_signals_a_changed_cb }, 170{ EV_A_CHANGED, _eo_signals_a_changed_cb },
171{ EV_A_CHANGED, _eo_signals_a_changed_cb2 }, 171{ EV_A_CHANGED, _eo_signals_a_changed_cb2 },
172{ EV_A_CHANGED, _eo_signals_a_changed_never }, 172{ EV_A_CHANGED, _eo_signals_a_changed_never },
173{ EO_EVENT_DEL, _eo_signals_eo_del_cb }); 173{ EFL_EVENT_DEL, _eo_signals_efl_del_cb });
174 174
175START_TEST(eo_signals) 175START_TEST(eo_signals)
176{ 176{
@@ -179,28 +179,28 @@ START_TEST(eo_signals)
179 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 179 Eo *obj = eo_add(SIMPLE_CLASS, NULL);
180 Eina_Bool r; 180 Eina_Bool r;
181 181
182 eo_event_callback_add(obj, EO_EVENT_CALLBACK_ADD, _eo_signals_cb_added_deled, &_eo_signals_callbacks); 182 efl_event_callback_add(obj, EFL_EVENT_CALLBACK_ADD, _eo_signals_cb_added_deled, &_eo_signals_callbacks);
183 r = eo_event_callback_add(obj, EO_EVENT_CALLBACK_DEL, _eo_signals_cb_added_deled, &_eo_signals_callbacks); 183 r = efl_event_callback_add(obj, EFL_EVENT_CALLBACK_DEL, _eo_signals_cb_added_deled, &_eo_signals_callbacks);
184 fail_if(!r); 184 fail_if(!r);
185 eo_event_callback_array_priority_add(obj, _eo_signals_callbacks(), -100, (void *) 1); 185 efl_event_callback_array_priority_add(obj, _eo_signals_callbacks(), -100, (void *) 1);
186 eo_event_callback_array_add(obj, _eo_signals_callbacks(), (void *) 3); 186 efl_event_callback_array_add(obj, _eo_signals_callbacks(), (void *) 3);
187 r = eo_event_callback_array_priority_add(obj, _eo_signals_callbacks(), -50, (void *) 2); 187 r = efl_event_callback_array_priority_add(obj, _eo_signals_callbacks(), -50, (void *) 2);
188 fail_if(!r); 188 fail_if(!r);
189 simple_a_set(obj, 1); 189 simple_a_set(obj, 1);
190 ck_assert_int_eq(_eo_signals_cb_flag, 0x3); 190 ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
191 191
192 eo_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 1); 192 efl_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 1);
193 eo_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 2); 193 efl_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 2);
194 r = eo_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 3); 194 r = efl_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 3);
195 fail_if(!r); 195 fail_if(!r);
196 /* Try to delete something that doesn't exist. */ 196 /* Try to delete something that doesn't exist. */
197 r = eo_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 4); 197 r = efl_event_callback_array_del(obj, _eo_signals_callbacks(), (void *) 4);
198 fail_if(r); 198 fail_if(r);
199 _eo_signals_cb_flag = 0; 199 _eo_signals_cb_flag = 0;
200 simple_a_set(obj, 1); 200 simple_a_set(obj, 1);
201 ck_assert_int_eq(_eo_signals_cb_flag, 0x0); 201 ck_assert_int_eq(_eo_signals_cb_flag, 0x0);
202 202
203 r = eo_event_callback_array_add(obj, NULL, NULL); 203 r = efl_event_callback_array_add(obj, NULL, NULL);
204 fail_if(r); 204 fail_if(r);
205 205
206 eo_unref(obj); 206 eo_unref(obj);
@@ -208,47 +208,47 @@ START_TEST(eo_signals)
208 obj = eo_add(SIMPLE_CLASS, NULL); 208 obj = eo_add(SIMPLE_CLASS, NULL);
209 /* Legacy support signals. */ 209 /* Legacy support signals. */
210 { 210 {
211 const Eo_Event_Description *a_desc = eo_base_legacy_only_event_description_get("a,changed"); 211 const Efl_Event_Description *a_desc = efl_object_legacy_only_event_description_get("a,changed");
212 fail_if(!a_desc); 212 fail_if(!a_desc);
213 ck_assert_str_eq(a_desc->name, "a,changed"); 213 ck_assert_str_eq(a_desc->name, "a,changed");
214 fail_if(a_desc == EV_A_CHANGED); 214 fail_if(a_desc == EV_A_CHANGED);
215 215
216 /* Check that when calling again we still get the same event. */ 216 /* Check that when calling again we still get the same event. */
217 const Eo_Event_Description *a_desc2 = eo_base_legacy_only_event_description_get("a,changed"); 217 const Efl_Event_Description *a_desc2 = efl_object_legacy_only_event_description_get("a,changed");
218 fail_if(!a_desc2); 218 fail_if(!a_desc2);
219 fail_if(a_desc2 != a_desc); 219 fail_if(a_desc2 != a_desc);
220 220
221 const Eo_Event_Description *bad_desc = eo_base_legacy_only_event_description_get("bad"); 221 const Efl_Event_Description *bad_desc = efl_object_legacy_only_event_description_get("bad");
222 fail_if(!bad_desc); 222 fail_if(!bad_desc);
223 ck_assert_str_eq(bad_desc->name, "bad"); 223 ck_assert_str_eq(bad_desc->name, "bad");
224 224
225 /* Call Eo event with legacy and non-legacy callbacks. */ 225 /* Call Eo event with legacy and non-legacy callbacks. */
226 _eo_signals_cb_current = 0; 226 _eo_signals_cb_current = 0;
227 eo_event_callback_priority_add(obj, EV_A_CHANGED2, -1000, _eo_signals_a_changed_never, (void *) 1); 227 efl_event_callback_priority_add(obj, EV_A_CHANGED2, -1000, _eo_signals_a_changed_never, (void *) 1);
228 eo_event_callback_priority_add(obj, EV_A_CHANGED2, 0, _eo_signals_a_changed_within_cb, NULL); 228 efl_event_callback_priority_add(obj, EV_A_CHANGED2, 0, _eo_signals_a_changed_within_cb, NULL);
229 eo_event_callback_priority_add(obj, EV_A_CHANGED, -100, _eo_signals_a_changed_cb, (void *) 1); 229 efl_event_callback_priority_add(obj, EV_A_CHANGED, -100, _eo_signals_a_changed_cb, (void *) 1);
230 eo_event_callback_add(obj, a_desc, _eo_signals_a_changed_cb2, NULL); 230 efl_event_callback_add(obj, a_desc, _eo_signals_a_changed_cb2, NULL);
231 simple_a_set(obj, 1); 231 simple_a_set(obj, 1);
232 ck_assert_int_eq(_eo_signals_cb_flag, 0x3); 232 ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
233 233
234 /* We don't need this one anymore. */ 234 /* We don't need this one anymore. */
235 r = eo_event_callback_del(obj, EV_A_CHANGED2, _eo_signals_a_changed_never, (void *) 1); 235 r = efl_event_callback_del(obj, EV_A_CHANGED2, _eo_signals_a_changed_never, (void *) 1);
236 fail_if(!r); 236 fail_if(!r);
237 r = eo_event_callback_del(obj, a_desc, _eo_signals_a_changed_cb2, NULL); 237 r = efl_event_callback_del(obj, a_desc, _eo_signals_a_changed_cb2, NULL);
238 fail_if(!r); 238 fail_if(!r);
239 eo_event_callback_add(obj, EV_A_CHANGED, _eo_signals_a_changed_cb2, NULL); 239 efl_event_callback_add(obj, EV_A_CHANGED, _eo_signals_a_changed_cb2, NULL);
240 240
241 /* Call legacy event with legacy and non-legacy callbacks. */ 241 /* Call legacy event with legacy and non-legacy callbacks. */
242 int a = 3; 242 int a = 3;
243 _eo_signals_cb_current = 0; 243 _eo_signals_cb_current = 0;
244 _eo_signals_cb_flag = 0; 244 _eo_signals_cb_flag = 0;
245 eo_event_callback_call(obj, a_desc, &a); 245 efl_event_callback_call(obj, a_desc, &a);
246 ck_assert_int_eq(_eo_signals_cb_flag, 0x3); 246 ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
247 247
248 /* Stop event within event. */ 248 /* Stop event within event. */
249 _eo_signals_cb_current = 0; 249 _eo_signals_cb_current = 0;
250 _eo_signals_cb_flag = 0; 250 _eo_signals_cb_flag = 0;
251 fail_if(!eo_event_callback_call(obj, EV_A_CHANGED2, &a)); 251 fail_if(!efl_event_callback_call(obj, EV_A_CHANGED2, &a));
252 ck_assert_int_eq(_eo_signals_cb_flag, 0x8); 252 ck_assert_int_eq(_eo_signals_cb_flag, 0x8);
253 fail_if(!r); 253 fail_if(!r);
254 } 254 }
@@ -263,7 +263,7 @@ START_TEST(eo_data_fetch)
263 eo_init(); 263 eo_init();
264 264
265 /* Usually should be const, not const only for the test... */ 265 /* Usually should be const, not const only for the test... */
266 static Eo_Class_Description class_desc = { 266 static Efl_Class_Description class_desc = {
267 EO_VERSION, 267 EO_VERSION,
268 "Simple2", 268 "Simple2",
269 EO_CLASS_TYPE_REGULAR, 269 EO_CLASS_TYPE_REGULAR,
@@ -274,7 +274,7 @@ START_TEST(eo_data_fetch)
274 NULL 274 NULL
275 }; 275 };
276 276
277 const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 277 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
278 fail_if(!klass); 278 fail_if(!klass);
279 279
280 Eo *obj = eo_add(klass, NULL); 280 Eo *obj = eo_add(klass, NULL);
@@ -291,7 +291,7 @@ START_TEST(eo_data_fetch)
291 obj = eo_add(klass, NULL); 291 obj = eo_add(klass, NULL);
292 fail_if(!obj); 292 fail_if(!obj);
293 fail_if(eo_data_scope_get(obj, klass)); 293 fail_if(eo_data_scope_get(obj, klass));
294 fail_if(!eo_data_scope_get(obj, EO_BASE_CLASS)); 294 fail_if(!eo_data_scope_get(obj, EFL_OBJECT_CLASS));
295 eo_unref(obj); 295 eo_unref(obj);
296 296
297 eo_shutdown(); 297 eo_shutdown();
@@ -302,11 +302,11 @@ START_TEST(eo_isa_tests)
302{ 302{
303 eo_init(); 303 eo_init();
304 304
305 const Eo_Class *klass, *iface, *mixin; 305 const Efl_Class *klass, *iface, *mixin;
306 306
307 { 307 {
308 /* Usually should be const, not const only for the test... */ 308 /* Usually should be const, not const only for the test... */
309 static Eo_Class_Description class_desc = { 309 static Efl_Class_Description class_desc = {
310 EO_VERSION, 310 EO_VERSION,
311 "Iface", 311 "Iface",
312 EO_CLASS_TYPE_INTERFACE, 312 EO_CLASS_TYPE_INTERFACE,
@@ -323,7 +323,7 @@ START_TEST(eo_isa_tests)
323 323
324 { 324 {
325 /* Usually should be const, not const only for the test... */ 325 /* Usually should be const, not const only for the test... */
326 static Eo_Class_Description class_desc = { 326 static Efl_Class_Description class_desc = {
327 EO_VERSION, 327 EO_VERSION,
328 "Mixin", 328 "Mixin",
329 EO_CLASS_TYPE_MIXIN, 329 EO_CLASS_TYPE_MIXIN,
@@ -340,7 +340,7 @@ START_TEST(eo_isa_tests)
340 340
341 { 341 {
342 /* Usually should be const, not const only for the test... */ 342 /* Usually should be const, not const only for the test... */
343 static Eo_Class_Description class_desc = { 343 static Efl_Class_Description class_desc = {
344 EO_VERSION, 344 EO_VERSION,
345 "Simple2", 345 "Simple2",
346 EO_CLASS_TYPE_REGULAR, 346 EO_CLASS_TYPE_REGULAR,
@@ -378,7 +378,7 @@ START_TEST(eo_isa_tests)
378END_TEST 378END_TEST
379 379
380 380
381START_TEST(eo_composite_tests) 381START_TEST(efl_composite_tests)
382{ 382{
383 eo_init(); 383 eo_init();
384 384
@@ -389,20 +389,20 @@ START_TEST(eo_composite_tests)
389 Eo *obj3 = eo_add(SIMPLE_CLASS, NULL); 389 Eo *obj3 = eo_add(SIMPLE_CLASS, NULL);
390 fail_if(!obj3); 390 fail_if(!obj3);
391 391
392 eo_composite_attach(obj, obj2); 392 efl_composite_attach(obj, obj2);
393 fail_if(!eo_composite_part_is(obj2)); 393 fail_if(!efl_composite_part_is(obj2));
394 394
395 /* Check swapping attachments works. */ 395 /* Check swapping attachments works. */
396 eo_composite_attach(obj3, obj2); 396 efl_composite_attach(obj3, obj2);
397 fail_if(!eo_composite_part_is(obj2)); 397 fail_if(!efl_composite_part_is(obj2));
398 398
399 /* Check that a deletion of a child detaches from the parent. */ 399 /* Check that a deletion of a child detaches from the parent. */
400 eo_del(obj2); 400 efl_del(obj2);
401 fail_if(!eo_composite_attach(obj3, obj)); 401 fail_if(!efl_composite_attach(obj3, obj));
402 402
403 /* Check that a deletion of the parent detaches the child. */ 403 /* Check that a deletion of the parent detaches the child. */
404 eo_del(obj3); 404 efl_del(obj3);
405 fail_if(eo_composite_part_is(obj)); 405 fail_if(efl_composite_part_is(obj));
406 406
407 eo_unref(obj); 407 eo_unref(obj);
408 408
@@ -412,27 +412,27 @@ END_TEST
412 412
413static Eina_Bool _man_should_con = EINA_TRUE; 413static Eina_Bool _man_should_con = EINA_TRUE;
414static Eina_Bool _man_should_des = EINA_TRUE; 414static Eina_Bool _man_should_des = EINA_TRUE;
415static const Eo_Class *cur_klass = NULL; 415static const Efl_Class *cur_klass = NULL;
416 416
417static Eo * 417static Eo *
418_man_con(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED) 418_man_con(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
419{ 419{
420 if (_man_should_con) 420 if (_man_should_con)
421 eo_manual_free_set(obj, EINA_TRUE); 421 eo_manual_free_set(obj, EINA_TRUE);
422 return eo_constructor(eo_super(obj, cur_klass)); 422 return efl_constructor(eo_super(obj, cur_klass));
423} 423}
424 424
425static void 425static void
426_man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED) 426_man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
427{ 427{
428 eo_destructor(eo_super(obj, cur_klass)); 428 efl_destructor(eo_super(obj, cur_klass));
429 if (_man_should_des) 429 if (_man_should_des)
430 eo_manual_free_set(obj, EINA_FALSE); 430 eo_manual_free_set(obj, EINA_FALSE);
431} 431}
432 432
433static Eo_Op_Description op_descs[] = { 433static Efl_Op_Description op_descs[] = {
434 EO_OP_FUNC_OVERRIDE(eo_constructor, _man_con), 434 EO_OP_FUNC_OVERRIDE(efl_constructor, _man_con),
435 EO_OP_FUNC_OVERRIDE(eo_destructor, _man_des), 435 EO_OP_FUNC_OVERRIDE(efl_destructor, _man_des),
436}; 436};
437 437
438START_TEST(eo_man_free) 438START_TEST(eo_man_free)
@@ -440,7 +440,7 @@ START_TEST(eo_man_free)
440 eo_init(); 440 eo_init();
441 441
442 /* Usually should be const, not const only for the test... */ 442 /* Usually should be const, not const only for the test... */
443 static Eo_Class_Description class_desc = { 443 static Efl_Class_Description class_desc = {
444 EO_VERSION, 444 EO_VERSION,
445 "Simple2", 445 "Simple2",
446 EO_CLASS_TYPE_REGULAR, 446 EO_CLASS_TYPE_REGULAR,
@@ -451,7 +451,7 @@ START_TEST(eo_man_free)
451 NULL 451 NULL
452 }; 452 };
453 453
454 const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 454 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
455 fail_if(!klass); 455 fail_if(!klass);
456 cur_klass = klass; 456 cur_klass = klass;
457 457
@@ -561,7 +561,7 @@ START_TEST(eo_refs)
561 obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj)); 561 obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj));
562 562
563 Eo *wref = NULL; 563 Eo *wref = NULL;
564 eo_wref_add(obj2, &wref); 564 efl_wref_add(obj2, &wref);
565 fail_if(!wref); 565 fail_if(!wref);
566 566
567 eo_unref(obj2); 567 eo_unref(obj2);
@@ -586,24 +586,24 @@ START_TEST(eo_refs)
586 obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj)); 586 obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj));
587 obj3 = eo_ref(eo_add(SIMPLE_CLASS, NULL)); 587 obj3 = eo_ref(eo_add(SIMPLE_CLASS, NULL));
588 588
589 eo_parent_set(obj2, obj3); 589 efl_parent_set(obj2, obj3);
590 eo_parent_set(obj3, obj); 590 efl_parent_set(obj3, obj);
591 ck_assert_int_eq(eo_ref_get(obj2), 2); 591 ck_assert_int_eq(eo_ref_get(obj2), 2);
592 ck_assert_int_eq(eo_ref_get(obj3), 2); 592 ck_assert_int_eq(eo_ref_get(obj3), 2);
593 593
594 eo_parent_set(obj2, NULL); 594 efl_parent_set(obj2, NULL);
595 eo_parent_set(obj3, NULL); 595 efl_parent_set(obj3, NULL);
596 ck_assert_int_eq(eo_ref_get(obj2), 1); 596 ck_assert_int_eq(eo_ref_get(obj2), 1);
597 ck_assert_int_eq(eo_ref_get(obj3), 1); 597 ck_assert_int_eq(eo_ref_get(obj3), 1);
598 598
599 eo_parent_set(obj2, obj); 599 efl_parent_set(obj2, obj);
600 eo_parent_set(obj3, obj); 600 efl_parent_set(obj3, obj);
601 ck_assert_int_eq(eo_ref_get(obj2), 1); 601 ck_assert_int_eq(eo_ref_get(obj2), 1);
602 ck_assert_int_eq(eo_ref_get(obj3), 1); 602 ck_assert_int_eq(eo_ref_get(obj3), 1);
603 603
604 eo_del(obj); 604 efl_del(obj);
605 eo_del(obj2); 605 efl_del(obj2);
606 eo_del(obj3); 606 efl_del(obj3);
607 607
608 /* Just check it doesn't seg atm. */ 608 /* Just check it doesn't seg atm. */
609 obj = eo_add(SIMPLE_CLASS, NULL); 609 obj = eo_add(SIMPLE_CLASS, NULL);
@@ -615,7 +615,7 @@ START_TEST(eo_refs)
615 obj2 = eo_add(SIMPLE_CLASS, obj); 615 obj2 = eo_add(SIMPLE_CLASS, obj);
616 eo_unref(obj2); 616 eo_unref(obj2);
617 eo_ref(obj2); 617 eo_ref(obj2);
618 eo_del(obj2); 618 efl_del(obj2);
619 eo_unref(obj); 619 eo_unref(obj);
620 620
621 eo_shutdown(); 621 eo_shutdown();
@@ -629,14 +629,14 @@ START_TEST(eo_weak_reference)
629 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 629 Eo *obj = eo_add(SIMPLE_CLASS, NULL);
630 Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); 630 Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
631 Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL; 631 Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL;
632 eo_wref_add(obj, &wref); 632 efl_wref_add(obj, &wref);
633 fail_if(!wref); 633 fail_if(!wref);
634 634
635 eo_unref(obj); 635 eo_unref(obj);
636 fail_if(wref); 636 fail_if(wref);
637 637
638 obj = eo_add(SIMPLE_CLASS, NULL); 638 obj = eo_add(SIMPLE_CLASS, NULL);
639 eo_wref_add(obj, &wref); 639 efl_wref_add(obj, &wref);
640 640
641 eo_ref(obj); 641 eo_ref(obj);
642 fail_if(!wref); 642 fail_if(!wref);
@@ -649,41 +649,41 @@ START_TEST(eo_weak_reference)
649 649
650 obj = eo_add(SIMPLE_CLASS, NULL); 650 obj = eo_add(SIMPLE_CLASS, NULL);
651 651
652 eo_wref_add(obj, &wref); 652 efl_wref_add(obj, &wref);
653 eo_wref_del(obj, &wref); 653 efl_wref_del(obj, &wref);
654 fail_if(wref); 654 fail_if(wref);
655 655
656 eo_wref_add(obj, &wref); 656 efl_wref_add(obj, &wref);
657 eo_wref_del(obj2, &wref); 657 efl_wref_del(obj2, &wref);
658 fail_if(!wref); 658 fail_if(!wref);
659 eo_wref_del_safe(&wref); 659 efl_wref_del_safe(&wref);
660 fail_if(wref); 660 fail_if(wref);
661 661
662 wref = obj; 662 wref = obj;
663 eo_wref_del(obj, &wref); 663 efl_wref_del(obj, &wref);
664 fail_if(wref); 664 fail_if(wref);
665 665
666 wref = wref2 = wref3 = NULL; 666 wref = wref2 = wref3 = NULL;
667 eo_wref_add(obj, &wref); 667 efl_wref_add(obj, &wref);
668 eo_wref_add(obj, &wref2); 668 efl_wref_add(obj, &wref2);
669 eo_wref_add(obj, &wref3); 669 efl_wref_add(obj, &wref3);
670 fail_if(!wref); 670 fail_if(!wref);
671 fail_if(!wref2); 671 fail_if(!wref2);
672 fail_if(!wref3); 672 fail_if(!wref3);
673 eo_wref_del(obj, &wref); 673 efl_wref_del(obj, &wref);
674 eo_wref_del(obj, &wref2); 674 efl_wref_del(obj, &wref2);
675 eo_wref_del(obj, &wref3); 675 efl_wref_del(obj, &wref3);
676 fail_if(wref); 676 fail_if(wref);
677 fail_if(wref2); 677 fail_if(wref2);
678 fail_if(wref3); 678 fail_if(wref3);
679 679
680 eo_wref_add(obj, &wref2); 680 efl_wref_add(obj, &wref2);
681 eo_wref_add(obj, &wref3); 681 efl_wref_add(obj, &wref3);
682 wref = obj; 682 wref = obj;
683 eo_wref_del(obj, &wref); 683 efl_wref_del(obj, &wref);
684 fail_if(wref); 684 fail_if(wref);
685 eo_wref_del(obj, &wref2); 685 efl_wref_del(obj, &wref2);
686 eo_wref_del(obj, &wref3); 686 efl_wref_del(obj, &wref3);
687 687
688 eo_unref(obj); 688 eo_unref(obj);
689 eo_unref(obj2); 689 eo_unref(obj2);
@@ -706,86 +706,86 @@ START_TEST(eo_generic_data)
706 706
707 707
708 708
709 eo_key_data_set(obj, "test1", (void *) 1); 709 efl_key_data_set(obj, "test1", (void *) 1);
710 data = eo_key_data_get(obj, "test1"); 710 data = efl_key_data_get(obj, "test1");
711 fail_if(1 != (intptr_t) data); 711 fail_if(1 != (intptr_t) data);
712 712
713 eo_key_data_set(obj, "test1", NULL); 713 efl_key_data_set(obj, "test1", NULL);
714 data = eo_key_data_get(obj, "test1"); 714 data = efl_key_data_get(obj, "test1");
715 fail_if(data); 715 fail_if(data);
716 716
717 eo_key_data_set(obj, "test1", (void *) 1); 717 efl_key_data_set(obj, "test1", (void *) 1);
718 eo_key_data_set(obj, "test2", (void *) 2); 718 efl_key_data_set(obj, "test2", (void *) 2);
719 data = eo_key_data_get(obj, "test1"); 719 data = efl_key_data_get(obj, "test1");
720 fail_if(1 != (intptr_t) data); 720 fail_if(1 != (intptr_t) data);
721 721
722 data = eo_key_data_get(obj, "test2"); 722 data = efl_key_data_get(obj, "test2");
723 fail_if(2 != (intptr_t) data); 723 fail_if(2 != (intptr_t) data);
724 724
725 data = eo_key_data_get(obj, "test2"); 725 data = efl_key_data_get(obj, "test2");
726 fail_if(2 != (intptr_t) data); 726 fail_if(2 != (intptr_t) data);
727 727
728 eo_key_data_set(obj, "test2", NULL); 728 efl_key_data_set(obj, "test2", NULL);
729 data = eo_key_data_get(obj, "test2"); 729 data = efl_key_data_get(obj, "test2");
730 fail_if(data); 730 fail_if(data);
731 731
732 data = eo_key_data_get(obj, "test1"); 732 data = efl_key_data_get(obj, "test1");
733 fail_if(1 != (intptr_t) data); 733 fail_if(1 != (intptr_t) data);
734 734
735 eo_key_data_set(obj, "test1", NULL); 735 efl_key_data_set(obj, "test1", NULL);
736 data = eo_key_data_get(obj, "test1"); 736 data = efl_key_data_get(obj, "test1");
737 fail_if(data); 737 fail_if(data);
738 738
739 739
740 740
741 eo_key_ref_set(obj, "test1", obj2); 741 efl_key_ref_set(obj, "test1", obj2);
742 objtmp = eo_key_ref_get(obj, "test1"); 742 objtmp = efl_key_ref_get(obj, "test1");
743 fail_if(obj2 != objtmp); 743 fail_if(obj2 != objtmp);
744 744
745 eo_key_ref_set(obj, "test1", NULL); 745 efl_key_ref_set(obj, "test1", NULL);
746 objtmp = eo_key_ref_get(obj, "test1"); 746 objtmp = efl_key_ref_get(obj, "test1");
747 fail_if(objtmp); 747 fail_if(objtmp);
748 748
749 eo_key_ref_set(obj, "test1", obj2); 749 efl_key_ref_set(obj, "test1", obj2);
750 fail_if(eo_ref_get(obj2) != 2); 750 fail_if(eo_ref_get(obj2) != 2);
751 751
752 eo_key_ref_set(obj, "test2", obj3); 752 efl_key_ref_set(obj, "test2", obj3);
753 fail_if(eo_ref_get(obj3) != 2); 753 fail_if(eo_ref_get(obj3) != 2);
754 754
755 objtmp = eo_key_ref_get(obj, "test1"); 755 objtmp = efl_key_ref_get(obj, "test1");
756 fail_if(obj2 != objtmp); 756 fail_if(obj2 != objtmp);
757 757
758 objtmp = eo_key_ref_get(obj, "test2"); 758 objtmp = efl_key_ref_get(obj, "test2");
759 fail_if(obj3 != objtmp); 759 fail_if(obj3 != objtmp);
760 760
761 data = eo_key_ref_get(obj, "test2"); 761 data = efl_key_ref_get(obj, "test2");
762 fail_if(obj3 != objtmp); 762 fail_if(obj3 != objtmp);
763 763
764 eo_key_ref_set(obj, "test2", NULL); 764 efl_key_ref_set(obj, "test2", NULL);
765 fail_if(eo_ref_get(obj3) != 1); 765 fail_if(eo_ref_get(obj3) != 1);
766 766
767 objtmp = eo_key_ref_get(obj, "test2"); 767 objtmp = efl_key_ref_get(obj, "test2");
768 fail_if(objtmp); 768 fail_if(objtmp);
769 769
770 objtmp = eo_key_ref_get(obj, "test1"); 770 objtmp = efl_key_ref_get(obj, "test1");
771 fail_if(obj2 != objtmp); 771 fail_if(obj2 != objtmp);
772 772
773 eo_key_ref_set(obj, "test1", NULL); 773 efl_key_ref_set(obj, "test1", NULL);
774 fail_if(eo_ref_get(obj2) != 1); 774 fail_if(eo_ref_get(obj2) != 1);
775 775
776 objtmp = eo_key_ref_get(obj, "test1"); 776 objtmp = efl_key_ref_get(obj, "test1");
777 fail_if(objtmp); 777 fail_if(objtmp);
778 778
779 eo_key_ref_set(obj, "test1", obj2); 779 efl_key_ref_set(obj, "test1", obj2);
780 eo_key_ref_set(obj, "test2", obj3); 780 efl_key_ref_set(obj, "test2", obj3);
781 eo_del(obj2); 781 efl_del(obj2);
782 eo_del(obj2); 782 efl_del(obj2);
783 eo_del(obj3); 783 efl_del(obj3);
784 eo_del(obj3); 784 efl_del(obj3);
785 objtmp = eo_key_ref_get(obj, "test1"); 785 objtmp = efl_key_ref_get(obj, "test1");
786 fail_if(objtmp); 786 fail_if(objtmp);
787 787
788 objtmp = eo_key_ref_get(obj, "test2"); 788 objtmp = efl_key_ref_get(obj, "test2");
789 fail_if(objtmp); 789 fail_if(objtmp);
790 790
791 791
@@ -793,70 +793,70 @@ START_TEST(eo_generic_data)
793 obj2 = eo_add(SIMPLE_CLASS, NULL); 793 obj2 = eo_add(SIMPLE_CLASS, NULL);
794 obj3 = eo_add(SIMPLE_CLASS, NULL); 794 obj3 = eo_add(SIMPLE_CLASS, NULL);
795 795
796 eo_key_wref_set(obj, "test1", obj2); 796 efl_key_wref_set(obj, "test1", obj2);
797 objtmp = eo_key_wref_get(obj, "test1"); 797 objtmp = efl_key_wref_get(obj, "test1");
798 fail_if(obj2 != objtmp); 798 fail_if(obj2 != objtmp);
799 799
800 eo_key_wref_set(obj, "test1", NULL); 800 efl_key_wref_set(obj, "test1", NULL);
801 objtmp = eo_key_wref_get(obj, "test1"); 801 objtmp = efl_key_wref_get(obj, "test1");
802 fail_if(objtmp); 802 fail_if(objtmp);
803 803
804 eo_key_wref_set(obj, "test1", obj2); 804 efl_key_wref_set(obj, "test1", obj2);
805 fail_if(eo_ref_get(obj2) != 1); 805 fail_if(eo_ref_get(obj2) != 1);
806 806
807 eo_key_wref_set(obj, "test2", obj3); 807 efl_key_wref_set(obj, "test2", obj3);
808 fail_if(eo_ref_get(obj3) != 1); 808 fail_if(eo_ref_get(obj3) != 1);
809 809
810 objtmp = eo_key_wref_get(obj, "test1"); 810 objtmp = efl_key_wref_get(obj, "test1");
811 fail_if(obj2 != objtmp); 811 fail_if(obj2 != objtmp);
812 812
813 objtmp = eo_key_wref_get(obj, "test2"); 813 objtmp = efl_key_wref_get(obj, "test2");
814 fail_if(obj3 != objtmp); 814 fail_if(obj3 != objtmp);
815 815
816 data = eo_key_wref_get(obj, "test2"); 816 data = efl_key_wref_get(obj, "test2");
817 fail_if(obj3 != objtmp); 817 fail_if(obj3 != objtmp);
818 818
819 eo_key_wref_set(obj, "test2", NULL); 819 efl_key_wref_set(obj, "test2", NULL);
820 fail_if(eo_ref_get(obj3) != 1); 820 fail_if(eo_ref_get(obj3) != 1);
821 821
822 objtmp = eo_key_wref_get(obj, "test2"); 822 objtmp = efl_key_wref_get(obj, "test2");
823 fail_if(objtmp); 823 fail_if(objtmp);
824 824
825 objtmp = eo_key_wref_get(obj, "test1"); 825 objtmp = efl_key_wref_get(obj, "test1");
826 fail_if(obj2 != objtmp); 826 fail_if(obj2 != objtmp);
827 827
828 eo_key_wref_set(obj, "test1", NULL); 828 efl_key_wref_set(obj, "test1", NULL);
829 fail_if(eo_ref_get(obj2) != 1); 829 fail_if(eo_ref_get(obj2) != 1);
830 830
831 objtmp = eo_key_wref_get(obj, "test1"); 831 objtmp = efl_key_wref_get(obj, "test1");
832 fail_if(objtmp); 832 fail_if(objtmp);
833 833
834 eo_key_wref_set(obj, "test1", obj2); 834 efl_key_wref_set(obj, "test1", obj2);
835 eo_key_wref_set(obj, "test2", obj3); 835 efl_key_wref_set(obj, "test2", obj3);
836 eo_del(obj2); 836 efl_del(obj2);
837 eo_del(obj3); 837 efl_del(obj3);
838 objtmp = eo_key_wref_get(obj, "test1"); 838 objtmp = efl_key_wref_get(obj, "test1");
839 fail_if(objtmp); 839 fail_if(objtmp);
840 840
841 objtmp = eo_key_wref_get(obj, "test2"); 841 objtmp = efl_key_wref_get(obj, "test2");
842 fail_if(objtmp); 842 fail_if(objtmp);
843 843
844 844
845 845
846 value = eina_value_new(EINA_VALUE_TYPE_INT); 846 value = eina_value_new(EINA_VALUE_TYPE_INT);
847 eina_value_set(value, 1234); 847 eina_value_set(value, 1234);
848 value2 = eo_key_value_get(obj, "value1"); 848 value2 = efl_key_value_get(obj, "value1");
849 fail_if(value2 != NULL); 849 fail_if(value2 != NULL);
850 850
851 eo_key_value_set(obj, "value1", value); 851 efl_key_value_set(obj, "value1", value);
852 value2 = eo_key_value_get(obj, "value1"); 852 value2 = efl_key_value_get(obj, "value1");
853 fail_if(value != value2); 853 fail_if(value != value2);
854 854
855 eo_key_value_set(obj, "value1", NULL); 855 efl_key_value_set(obj, "value1", NULL);
856 value2 = eo_key_value_get(obj, "value1"); 856 value2 = efl_key_value_get(obj, "value1");
857 fail_if(value2 != NULL); 857 fail_if(value2 != NULL);
858 858
859 eo_key_value_set(obj, "value1", NULL); 859 efl_key_value_set(obj, "value1", NULL);
860 860
861 eo_unref(obj); 861 eo_unref(obj);
862 eo_unref(obj2); 862 eo_unref(obj2);
@@ -885,7 +885,7 @@ START_TEST(eo_magic_checks)
885 Eo *wref = NULL; 885 Eo *wref = NULL;
886 Eo *obj2 = NULL; 886 Eo *obj2 = NULL;
887 887
888 obj = eo_add((Eo_Class *) buf, NULL); 888 obj = eo_add((Efl_Class *) buf, NULL);
889 fail_if(obj); 889 fail_if(obj);
890 890
891 obj = eo_add(SIMPLE_CLASS, NULL); 891 obj = eo_add(SIMPLE_CLASS, NULL);
@@ -897,17 +897,17 @@ START_TEST(eo_magic_checks)
897 simple_a_set(eo_super((Eo *) buf, SIMPLE_CLASS), ++i); 897 simple_a_set(eo_super((Eo *) buf, SIMPLE_CLASS), ++i);
898 a = simple_a_get(eo_super((Eo *) buf, SIMPLE_CLASS)); 898 a = simple_a_get(eo_super((Eo *) buf, SIMPLE_CLASS));
899 ck_assert_int_ne(i, a); 899 ck_assert_int_ne(i, a);
900 simple_a_set(eo_super(obj, (const Eo_Class *) buf), ++i); 900 simple_a_set(eo_super(obj, (const Efl_Class *) buf), ++i);
901 a = simple_a_get(eo_super(obj, (const Eo_Class *) buf)); 901 a = simple_a_get(eo_super(obj, (const Efl_Class *) buf));
902 ck_assert_int_ne(i, a); 902 ck_assert_int_ne(i, a);
903 fail_if(eo_class_get((Eo *) buf)); 903 fail_if(eo_class_get((Eo *) buf));
904 fail_if(eo_class_name_get((Eo_Class*) buf)); 904 fail_if(eo_class_name_get((Efl_Class*) buf));
905 fail_if(eo_class_get(obj) != SIMPLE_CLASS); 905 fail_if(eo_class_get(obj) != SIMPLE_CLASS);
906 fail_if(eo_class_get(SIMPLE_CLASS) != EO_CLASS_CLASS); 906 fail_if(eo_class_get(SIMPLE_CLASS) != EFL_CLASS_CLASS);
907 simple_a_set((Eo_Class *) buf, 1); 907 simple_a_set((Efl_Class *) buf, 1);
908 simple_a_set(eo_super((Eo_Class *) buf, SIMPLE_CLASS), ++i); 908 simple_a_set(eo_super((Efl_Class *) buf, SIMPLE_CLASS), ++i);
909 simple_a_set(eo_super(SIMPLE_CLASS, (Eo_Class *) buf), ++i); 909 simple_a_set(eo_super(SIMPLE_CLASS, (Efl_Class *) buf), ++i);
910 fail_if(eo_class_new(NULL, (Eo_Class *) buf), NULL); 910 fail_if(eo_class_new(NULL, (Efl_Class *) buf), NULL);
911 911
912 eo_xref(obj, (Eo *) buf); 912 eo_xref(obj, (Eo *) buf);
913 eo_xunref(obj, (Eo *) buf); 913 eo_xunref(obj, (Eo *) buf);
@@ -916,34 +916,34 @@ START_TEST(eo_magic_checks)
916 916
917 eo_ref((Eo *) buf); 917 eo_ref((Eo *) buf);
918 eo_unref((Eo *) buf); 918 eo_unref((Eo *) buf);
919 eo_del((Eo *) buf); 919 efl_del((Eo *) buf);
920 920
921 eo_isa((Eo *) buf, SIMPLE_CLASS); 921 eo_isa((Eo *) buf, SIMPLE_CLASS);
922 eo_isa(obj, (Eo_Class *) buf); 922 eo_isa(obj, (Efl_Class *) buf);
923 923
924 fail_if(0 != eo_ref_get((Eo *) buf)); 924 fail_if(0 != eo_ref_get((Eo *) buf));
925 925
926 eo_wref_add((Eo *) buf, &wref); 926 efl_wref_add((Eo *) buf, &wref);
927 parent = eo_parent_get((Eo *) buf); 927 parent = efl_parent_get((Eo *) buf);
928 fail_if(wref); 928 fail_if(wref);
929 fail_if(parent); 929 fail_if(parent);
930 930
931 fail_if(eo_data_scope_get((Eo *) buf, SIMPLE_CLASS)); 931 fail_if(eo_data_scope_get((Eo *) buf, SIMPLE_CLASS));
932 932
933 eo_composite_attach(obj, (Eo *) buf); 933 efl_composite_attach(obj, (Eo *) buf);
934 eo_composite_detach(obj, (Eo *) buf); 934 efl_composite_detach(obj, (Eo *) buf);
935 eo_composite_part_is((Eo *) buf); 935 efl_composite_part_is((Eo *) buf);
936 936
937 eo_event_callback_forwarder_add(obj, NULL, (Eo *) buf); 937 efl_event_callback_forwarder_add(obj, NULL, (Eo *) buf);
938 eo_event_callback_forwarder_del(obj, NULL, (Eo *) buf); 938 efl_event_callback_forwarder_del(obj, NULL, (Eo *) buf);
939 939
940 eo_manual_free_set((Eo *) buf, EINA_TRUE); 940 eo_manual_free_set((Eo *) buf, EINA_TRUE);
941 eo_manual_free((Eo *) buf); 941 eo_manual_free((Eo *) buf);
942 eo_destructed_is((Eo *) buf); 942 eo_destructed_is((Eo *) buf);
943 943
944 obj2 = NULL; 944 obj2 = NULL;
945 eo_parent_set(obj, (Eo *) buf); 945 efl_parent_set(obj, (Eo *) buf);
946 obj2 = eo_parent_get(obj); 946 obj2 = efl_parent_get(obj);
947 fail_if(obj2 && (obj2 == (Eo *) buf)); 947 fail_if(obj2 && (obj2 == (Eo *) buf));
948 948
949 eo_unref(obj); 949 eo_unref(obj);
@@ -969,7 +969,7 @@ _a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
969} 969}
970 970
971static Eina_Bool 971static Eina_Bool
972_class_hi_print(Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) 972_class_hi_print(Efl_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
973{ 973{
974 printf("Hi\n"); 974 printf("Hi\n");
975 975
@@ -979,7 +979,7 @@ _class_hi_print(Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
979EO_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE); 979EO_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE);
980EO_FUNC_BODY_CONST(multi_class_hi_print, Eina_Bool, EINA_FALSE); 980EO_FUNC_BODY_CONST(multi_class_hi_print, Eina_Bool, EINA_FALSE);
981 981
982static Eo_Op_Description _multi_do_op_descs[] = { 982static Efl_Op_Description _multi_do_op_descs[] = {
983 EO_OP_FUNC(multi_a_print, _a_print), 983 EO_OP_FUNC(multi_a_print, _a_print),
984 EO_OP_FUNC(multi_class_hi_print, _class_hi_print), 984 EO_OP_FUNC(multi_class_hi_print, _class_hi_print),
985}; 985};
@@ -989,7 +989,7 @@ START_TEST(eo_multiple_do)
989 eo_init(); 989 eo_init();
990 990
991 /* Usually should be const, not const only for the test... */ 991 /* Usually should be const, not const only for the test... */
992 static Eo_Class_Description class_desc = { 992 static Efl_Class_Description class_desc = {
993 EO_VERSION, 993 EO_VERSION,
994 "Inherit", 994 "Inherit",
995 EO_CLASS_TYPE_REGULAR, 995 EO_CLASS_TYPE_REGULAR,
@@ -1000,7 +1000,7 @@ START_TEST(eo_multiple_do)
1000 NULL 1000 NULL
1001 }; 1001 };
1002 1002
1003 const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); 1003 const Efl_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL);
1004 fail_if(!klass); 1004 fail_if(!klass);
1005 1005
1006 Eo *obj = eo_add(klass, NULL); 1006 Eo *obj = eo_add(klass, NULL);
@@ -1032,7 +1032,7 @@ START_TEST(eo_add_do_and_custom)
1032 Eo *obj = NULL; 1032 Eo *obj = NULL;
1033 eo_init(); 1033 eo_init();
1034 1034
1035 obj = eo_add(SIMPLE_CLASS, NULL, eo_constructor(eo_self)); 1035 obj = eo_add(SIMPLE_CLASS, NULL, efl_constructor(eo_self));
1036 fail_if(!obj); 1036 fail_if(!obj);
1037 eo_unref(obj); 1037 eo_unref(obj);
1038 1038
@@ -1042,17 +1042,17 @@ START_TEST(eo_add_do_and_custom)
1042 fail_if(pd->a != 7); 1042 fail_if(pd->a != 7);
1043 eo_unref(obj); 1043 eo_unref(obj);
1044 1044
1045 obj = eo_add(SIMPLE_CLASS, NULL, eo_constructor(eo_self), simple_a_set(eo_self, 7)); 1045 obj = eo_add(SIMPLE_CLASS, NULL, efl_constructor(eo_self), simple_a_set(eo_self, 7));
1046 fail_if(!obj); 1046 fail_if(!obj);
1047 pd = eo_data_scope_get(obj, SIMPLE_CLASS); 1047 pd = eo_data_scope_get(obj, SIMPLE_CLASS);
1048 fail_if(pd->a != 7); 1048 fail_if(pd->a != 7);
1049 eo_unref(obj); 1049 eo_unref(obj);
1050 1050
1051 Eina_Bool finalized; 1051 Eina_Bool finalized;
1052 obj = eo_add(SIMPLE_CLASS, NULL, finalized = eo_finalized_get(eo_self)); 1052 obj = eo_add(SIMPLE_CLASS, NULL, finalized = efl_finalized_get(eo_self));
1053 fail_if(finalized); 1053 fail_if(finalized);
1054 1054
1055 finalized = eo_finalized_get(obj); 1055 finalized = efl_finalized_get(obj);
1056 fail_if(!finalized); 1056 fail_if(!finalized);
1057 eo_unref(obj); 1057 eo_unref(obj);
1058 1058
@@ -1065,7 +1065,7 @@ START_TEST(eo_pointers_indirection)
1065#ifdef HAVE_EO_ID 1065#ifdef HAVE_EO_ID
1066 eo_init(); 1066 eo_init();
1067 1067
1068 static const Eo_Class_Description class_desc = { 1068 static const Efl_Class_Description class_desc = {
1069 EO_VERSION, 1069 EO_VERSION,
1070 "Simple", 1070 "Simple",
1071 EO_CLASS_TYPE_REGULAR, 1071 EO_CLASS_TYPE_REGULAR,
@@ -1076,7 +1076,7 @@ START_TEST(eo_pointers_indirection)
1076 NULL 1076 NULL
1077 }; 1077 };
1078 1078
1079 const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 1079 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
1080 fail_if(!klass); 1080 fail_if(!klass);
1081 1081
1082 /* Check simple id validity */ 1082 /* Check simple id validity */
@@ -1155,15 +1155,15 @@ _eo_add_failures_finalize(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
1155 return NULL; 1155 return NULL;
1156} 1156}
1157 1157
1158static Eo_Op_Description _eo_add_failures_op_descs[] = { 1158static Efl_Op_Description _eo_add_failures_op_descs[] = {
1159 EO_OP_FUNC_OVERRIDE(eo_finalize, _eo_add_failures_finalize), 1159 EO_OP_FUNC_OVERRIDE(efl_finalize, _eo_add_failures_finalize),
1160}; 1160};
1161 1161
1162START_TEST(eo_add_failures) 1162START_TEST(eo_add_failures)
1163{ 1163{
1164 eo_init(); 1164 eo_init();
1165 1165
1166 static const Eo_Class_Description class_desc = { 1166 static const Efl_Class_Description class_desc = {
1167 EO_VERSION, 1167 EO_VERSION,
1168 "Simple2", 1168 "Simple2",
1169 EO_CLASS_TYPE_REGULAR, 1169 EO_CLASS_TYPE_REGULAR,
@@ -1174,7 +1174,7 @@ START_TEST(eo_add_failures)
1174 NULL 1174 NULL
1175 }; 1175 };
1176 1176
1177 const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 1177 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
1178 1178
1179 Eo *obj = eo_add(klass, NULL); 1179 Eo *obj = eo_add(klass, NULL);
1180 1180
@@ -1191,17 +1191,17 @@ static void
1191_del_intercept(Eo *obj) 1191_del_intercept(Eo *obj)
1192{ 1192{
1193 intercepted = EINA_TRUE; 1193 intercepted = EINA_TRUE;
1194 eo_del_intercept_set(obj, NULL); 1194 efl_del_intercept_set(obj, NULL);
1195 eo_unref(obj); 1195 eo_unref(obj);
1196} 1196}
1197#endif 1197#endif
1198 1198
1199START_TEST(eo_del_intercept) 1199START_TEST(efl_del_intercept)
1200{ 1200{
1201#ifdef HAVE_EO_ID 1201#ifdef HAVE_EO_ID
1202 eo_init(); 1202 eo_init();
1203 1203
1204 static const Eo_Class_Description class_desc = { 1204 static const Efl_Class_Description class_desc = {
1205 EO_VERSION, 1205 EO_VERSION,
1206 "Simple", 1206 "Simple",
1207 EO_CLASS_TYPE_REGULAR, 1207 EO_CLASS_TYPE_REGULAR,
@@ -1212,7 +1212,7 @@ START_TEST(eo_del_intercept)
1212 NULL 1212 NULL
1213 }; 1213 };
1214 1214
1215 const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 1215 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL);
1216 fail_if(!klass); 1216 fail_if(!klass);
1217 1217
1218 /* Check unref interception */ 1218 /* Check unref interception */
@@ -1220,7 +1220,7 @@ START_TEST(eo_del_intercept)
1220 Eo *obj = eo_add(klass, NULL); 1220 Eo *obj = eo_add(klass, NULL);
1221 fail_if(!obj); 1221 fail_if(!obj);
1222 fail_if(!eo_isa(obj, klass)); 1222 fail_if(!eo_isa(obj, klass));
1223 eo_del_intercept_set(obj, _del_intercept); 1223 efl_del_intercept_set(obj, _del_intercept);
1224 eo_unref(obj); 1224 eo_unref(obj);
1225 fail_if(!intercepted); 1225 fail_if(!intercepted);
1226 fail_if(eo_isa(obj, klass)); 1226 fail_if(eo_isa(obj, klass));
@@ -1230,8 +1230,8 @@ START_TEST(eo_del_intercept)
1230 obj = eo_add(klass, NULL); 1230 obj = eo_add(klass, NULL);
1231 fail_if(!obj); 1231 fail_if(!obj);
1232 fail_if(!eo_isa(obj, klass)); 1232 fail_if(!eo_isa(obj, klass));
1233 eo_del_intercept_set(obj, _del_intercept); 1233 efl_del_intercept_set(obj, _del_intercept);
1234 eo_del(obj); 1234 efl_del(obj);
1235 fail_if(!intercepted); 1235 fail_if(!intercepted);
1236 fail_if(eo_isa(obj, klass)); 1236 fail_if(eo_isa(obj, klass));
1237 1237
@@ -1240,7 +1240,7 @@ START_TEST(eo_del_intercept)
1240} 1240}
1241END_TEST 1241END_TEST
1242 1242
1243START_TEST(eo_name) 1243START_TEST(efl_name)
1244{ 1244{
1245 eo_init(); 1245 eo_init();
1246 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 1246 Eo *obj = eo_add(SIMPLE_CLASS, NULL);
@@ -1249,49 +1249,49 @@ START_TEST(eo_name)
1249 Eo *objtmp; 1249 Eo *objtmp;
1250 const char *id; 1250 const char *id;
1251 1251
1252 id = eo_name_get(obj); 1252 id = efl_name_get(obj);
1253 fail_if(NULL != id); 1253 fail_if(NULL != id);
1254 1254
1255 eo_name_set(obj, "Hello"); 1255 efl_name_set(obj, "Hello");
1256 id = eo_name_get(obj); 1256 id = efl_name_get(obj);
1257 fail_if(NULL == id); 1257 fail_if(NULL == id);
1258 fail_if(!!strcmp(id, "Hello")); 1258 fail_if(!!strcmp(id, "Hello"));
1259 1259
1260 eo_name_set(obj, "Hello"); 1260 efl_name_set(obj, "Hello");
1261 eo_name_set(obj, ""); 1261 efl_name_set(obj, "");
1262 id = eo_name_get(obj); 1262 id = efl_name_get(obj);
1263 fail_if(NULL != id); 1263 fail_if(NULL != id);
1264 1264
1265 eo_name_set(obj, "Hello"); 1265 efl_name_set(obj, "Hello");
1266 eo_name_set(obj, NULL); 1266 efl_name_set(obj, NULL);
1267 id = eo_name_get(obj); 1267 id = efl_name_get(obj);
1268 fail_if(NULL != id); 1268 fail_if(NULL != id);
1269 1269
1270 eo_name_set(obj2, "joe"); 1270 efl_name_set(obj2, "joe");
1271 eo_name_set(obj3, "bob"); 1271 efl_name_set(obj3, "bob");
1272 1272
1273 eo_parent_set(obj2, obj); 1273 efl_parent_set(obj2, obj);
1274 eo_parent_set(obj3, obj2); 1274 efl_parent_set(obj3, obj2);
1275 1275
1276 objtmp = eo_name_find(obj, "bob"); 1276 objtmp = efl_name_find(obj, "bob");
1277 fail_if(objtmp != obj3); 1277 fail_if(objtmp != obj3);
1278 1278
1279 objtmp = eo_name_find(obj, "joe"); 1279 objtmp = efl_name_find(obj, "joe");
1280 fail_if(objtmp != obj2); 1280 fail_if(objtmp != obj2);
1281 1281
1282 objtmp = eo_name_find(obj, "bo*"); 1282 objtmp = efl_name_find(obj, "bo*");
1283 fail_if(objtmp != obj3); 1283 fail_if(objtmp != obj3);
1284 1284
1285 objtmp = eo_name_find(obj, "*oe"); 1285 objtmp = efl_name_find(obj, "*oe");
1286 fail_if(objtmp != obj2); 1286 fail_if(objtmp != obj2);
1287 1287
1288 objtmp = eo_name_find(obj, "Simple:*oe"); 1288 objtmp = efl_name_find(obj, "Simple:*oe");
1289 fail_if(objtmp != obj2); 1289 fail_if(objtmp != obj2);
1290 1290
1291 objtmp = eo_name_find(obj, "*mple:joe"); 1291 objtmp = efl_name_find(obj, "*mple:joe");
1292 fail_if(objtmp != obj2); 1292 fail_if(objtmp != obj2);
1293 1293
1294 eo_del(obj); 1294 efl_del(obj);
1295 1295
1296 eo_shutdown(); 1296 eo_shutdown();
1297} 1297}
@@ -1303,25 +1303,25 @@ START_TEST(eo_comment)
1303 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 1303 Eo *obj = eo_add(SIMPLE_CLASS, NULL);
1304 const char *comment; 1304 const char *comment;
1305 1305
1306 comment = eo_comment_get(obj); 1306 comment = efl_comment_get(obj);
1307 fail_if(NULL != comment); 1307 fail_if(NULL != comment);
1308 1308
1309 eo_comment_set(obj, "Hello"); 1309 efl_comment_set(obj, "Hello");
1310 comment = eo_comment_get(obj); 1310 comment = efl_comment_get(obj);
1311 fail_if(NULL == comment); 1311 fail_if(NULL == comment);
1312 fail_if(!!strcmp(comment, "Hello")); 1312 fail_if(!!strcmp(comment, "Hello"));
1313 1313
1314 eo_comment_set(obj, "Hello"); 1314 efl_comment_set(obj, "Hello");
1315 eo_comment_set(obj, ""); 1315 efl_comment_set(obj, "");
1316 comment = eo_comment_get(obj); 1316 comment = efl_comment_get(obj);
1317 fail_if(NULL != comment); 1317 fail_if(NULL != comment);
1318 1318
1319 eo_comment_set(obj, "Hello"); 1319 efl_comment_set(obj, "Hello");
1320 eo_comment_set(obj, NULL); 1320 efl_comment_set(obj, NULL);
1321 comment = eo_comment_get(obj); 1321 comment = efl_comment_get(obj);
1322 fail_if(NULL != comment); 1322 fail_if(NULL != comment);
1323 1323
1324 eo_del(obj); 1324 efl_del(obj);
1325 1325
1326 eo_shutdown(); 1326 eo_shutdown();
1327} 1327}
@@ -1335,10 +1335,10 @@ START_TEST(eo_rec_interface)
1335 Eo *obj2 = eo_add(SIMPLE_CLASS, obj); 1335 Eo *obj2 = eo_add(SIMPLE_CLASS, obj);
1336 Eo *objtmp; 1336 Eo *objtmp;
1337 1337
1338 objtmp = eo_provider_find(obj2, SEARCHABLE_CLASS); 1338 objtmp = efl_provider_find(obj2, SEARCHABLE_CLASS);
1339 fail_if(objtmp != s); 1339 fail_if(objtmp != s);
1340 1340
1341 eo_del(obj); 1341 efl_del(obj);
1342 1342
1343 eo_shutdown(); 1343 eo_shutdown();
1344} 1344}
@@ -1352,7 +1352,7 @@ void eo_test_general(TCase *tc)
1352 tcase_add_test(tc, eo_signals); 1352 tcase_add_test(tc, eo_signals);
1353 tcase_add_test(tc, eo_data_fetch); 1353 tcase_add_test(tc, eo_data_fetch);
1354 tcase_add_test(tc, eo_isa_tests); 1354 tcase_add_test(tc, eo_isa_tests);
1355 tcase_add_test(tc, eo_composite_tests); 1355 tcase_add_test(tc, efl_composite_tests);
1356 tcase_add_test(tc, eo_man_free); 1356 tcase_add_test(tc, eo_man_free);
1357 tcase_add_test(tc, eo_refs); 1357 tcase_add_test(tc, eo_refs);
1358 tcase_add_test(tc, eo_weak_reference); 1358 tcase_add_test(tc, eo_weak_reference);
@@ -1362,8 +1362,8 @@ void eo_test_general(TCase *tc)
1362 tcase_add_test(tc, eo_add_do_and_custom); 1362 tcase_add_test(tc, eo_add_do_and_custom);
1363 tcase_add_test(tc, eo_pointers_indirection); 1363 tcase_add_test(tc, eo_pointers_indirection);
1364 tcase_add_test(tc, eo_add_failures); 1364 tcase_add_test(tc, eo_add_failures);
1365 tcase_add_test(tc, eo_del_intercept); 1365 tcase_add_test(tc, efl_del_intercept);
1366 tcase_add_test(tc, eo_name); 1366 tcase_add_test(tc, efl_name);
1367 tcase_add_test(tc, eo_comment); 1367 tcase_add_test(tc, eo_comment);
1368 tcase_add_test(tc, eo_rec_interface); 1368 tcase_add_test(tc, eo_rec_interface);
1369} 1369}
diff --git a/src/tests/eo/suite/eo_test_init.c b/src/tests/eo/suite/eo_test_init.c
index 4a1948ca7d..ec123bf635 100644
--- a/src/tests/eo/suite/eo_test_init.c
+++ b/src/tests/eo/suite/eo_test_init.c
@@ -21,7 +21,7 @@ START_TEST(eo_test_init_shutdown)
21 Eo *obj; 21 Eo *obj;
22 22
23 fail_if(!eo_init()); 23 fail_if(!eo_init());
24 ck_assert_str_eq("Eo_Base", eo_class_name_get(EO_BASE_CLASS)); 24 ck_assert_str_eq("Efl_Object", eo_class_name_get(EFL_OBJECT_CLASS));
25 25
26 /* XXX-1: Essential for the next test to assign the wrong op. */ 26 /* XXX-1: Essential for the next test to assign the wrong op. */
27 obj = eo_add(SIMPLE_CLASS, NULL); 27 obj = eo_add(SIMPLE_CLASS, NULL);
@@ -34,7 +34,7 @@ START_TEST(eo_test_init_shutdown)
34 fail_if(eo_shutdown()); 34 fail_if(eo_shutdown());
35 35
36 fail_if(!eo_init()); 36 fail_if(!eo_init());
37 ck_assert_str_eq("Eo_Base", eo_class_name_get(EO_BASE_CLASS)); 37 ck_assert_str_eq("Efl_Object", eo_class_name_get(EFL_OBJECT_CLASS));
38 38
39 /* XXX-1: Verify that the op was not cached. */ 39 /* XXX-1: Verify that the op was not cached. */
40 ck_assert_int_eq(0xBEEF, simple2_class_beef_get(SIMPLE2_CLASS)); 40 ck_assert_int_eq(0xBEEF, simple2_class_beef_get(SIMPLE2_CLASS));
diff --git a/src/tests/eo/suite/eo_test_threaded_calls.c b/src/tests/eo/suite/eo_test_threaded_calls.c
index 3f2231d88d..ae83b0cad0 100644
--- a/src/tests/eo/suite/eo_test_threaded_calls.c
+++ b/src/tests/eo/suite/eo_test_threaded_calls.c
@@ -18,7 +18,7 @@ typedef struct
18} Thread_Test_Public_Data; 18} Thread_Test_Public_Data;
19 19
20#define THREAD_TEST_CLASS thread_test_class_get() 20#define THREAD_TEST_CLASS thread_test_class_get()
21const Eo_Class *thread_test_class_get(void); 21const Efl_Class *thread_test_class_get(void);
22 22
23EO_FUNC_BODY(thread_test_v_get, int, 0); 23EO_FUNC_BODY(thread_test_v_get, int, 0);
24EO_VOID_FUNC_BODY(thread_test_try_swap_stack); 24EO_VOID_FUNC_BODY(thread_test_try_swap_stack);
@@ -60,13 +60,13 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, int v)
60 return obj; 60 return obj;
61} 61}
62 62
63static Eo_Op_Description op_descs[] = { 63static Efl_Op_Description op_descs[] = {
64 EO_OP_FUNC(thread_test_constructor, _constructor), 64 EO_OP_FUNC(thread_test_constructor, _constructor),
65 EO_OP_FUNC(thread_test_v_get, _v_get), 65 EO_OP_FUNC(thread_test_v_get, _v_get),
66 EO_OP_FUNC(thread_test_try_swap_stack, _try_swap_stack), 66 EO_OP_FUNC(thread_test_try_swap_stack, _try_swap_stack),
67}; 67};
68 68
69static const Eo_Class_Description class_desc = { 69static const Efl_Class_Description class_desc = {
70 EO_VERSION, 70 EO_VERSION,
71 "Thread Test", 71 "Thread Test",
72 EO_CLASS_TYPE_REGULAR, 72 EO_CLASS_TYPE_REGULAR,
diff --git a/src/tests/eo/suite/eo_test_value.c b/src/tests/eo/suite/eo_test_value.c
index 6162389e16..2649000610 100644
--- a/src/tests/eo/suite/eo_test_value.c
+++ b/src/tests/eo/suite/eo_test_value.c
@@ -16,11 +16,11 @@ START_TEST(eo_value)
16 16
17 Eina_Value val2, eo_val; 17 Eina_Value val2, eo_val;
18 void *tmpp = NULL; 18 void *tmpp = NULL;
19 Eo_Dbg_Info *eo_dbg_info; 19 Efl_Dbg_Info *eo_dbg_info;
20 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 20 Eo *obj = eo_add(SIMPLE_CLASS, NULL);
21 21
22 eo_dbg_info = EO_DBG_INFO_LIST_APPEND(NULL, "Root"); 22 eo_dbg_info = EO_DBG_INFO_LIST_APPEND(NULL, "Root");
23 eo_dbg_info_get(obj, eo_dbg_info); 23 efl_dbg_info_get(obj, eo_dbg_info);
24 fail_if(!eo_dbg_info); 24 fail_if(!eo_dbg_info);
25 ck_assert_str_eq(eo_dbg_info->name, "Root"); 25 ck_assert_str_eq(eo_dbg_info->name, "Root");
26 str = eina_value_to_string(&eo_dbg_info->value); 26 str = eina_value_to_string(&eo_dbg_info->value);