summaryrefslogtreecommitdiff
path: root/src/tests/eo/suite
diff options
context:
space:
mode:
authorTom Hacohen <tom@stosb.com>2016-08-15 14:44:41 +0100
committerTom Hacohen <tom@stosb.com>2016-08-15 15:07:42 +0100
commite65aae994e72c1d3f8ac6b5360d3772f177b77ef (patch)
tree7ecaf136e45470635889191aded2b47057720a98 /src/tests/eo/suite
parent35abb3c34d10a4826c98055fb85ecf93915e5ea8 (diff)
Eo: Finish the renaming of Eo to the EFL.
This renames all the rest of the API to the EFL namespace except for Eo_Event that will follow soon. Obviously breaks both API and ABI.
Diffstat (limited to 'src/tests/eo/suite')
-rw-r--r--src/tests/eo/suite/eo_test_call_errors.c32
-rw-r--r--src/tests/eo/suite/eo_test_class_behaviour_errors.c38
-rw-r--r--src/tests/eo/suite/eo_test_class_errors.c132
-rw-r--r--src/tests/eo/suite/eo_test_class_simple.c72
-rw-r--r--src/tests/eo/suite/eo_test_class_singleton.c12
-rw-r--r--src/tests/eo/suite/eo_test_general.c702
-rw-r--r--src/tests/eo/suite/eo_test_init.c24
-rw-r--r--src/tests/eo/suite/eo_test_threaded_calls.c26
-rw-r--r--src/tests/eo/suite/eo_test_value.c14
9 files changed, 526 insertions, 526 deletions
diff --git a/src/tests/eo/suite/eo_test_call_errors.c b/src/tests/eo/suite/eo_test_call_errors.c
index 551c58deae..3b23216711 100644
--- a/src/tests/eo/suite/eo_test_call_errors.c
+++ b/src/tests/eo/suite/eo_test_call_errors.c
@@ -14,55 +14,55 @@ static struct log_ctx ctx;
14 14
15START_TEST(eo_pure_virtual_fct_call) 15START_TEST(eo_pure_virtual_fct_call)
16{ 16{
17 eo_init(); 17 efl_object_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 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 20 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
21 fail_if(!obj); 21 fail_if(!obj);
22 22
23 TEST_EO_ERROR("_eo_call_resolve", "in %s:%d: you called a pure virtual func '%s' (%d) of class '%s'."); 23 TEST_EO_ERROR("_efl_object_call_resolve", "in %s:%d: you called a pure virtual func '%s' (%d) of class '%s'.");
24 simple_pure_virtual(obj); 24 simple_pure_virtual(obj);
25 fail_unless(ctx.did); 25 fail_unless(ctx.did);
26 26
27 eo_unref(obj); 27 efl_unref(obj);
28 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 28 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
29 eo_shutdown(); 29 efl_object_shutdown();
30} 30}
31END_TEST 31END_TEST
32 32
33START_TEST(eo_api_not_implemented_call) 33START_TEST(eo_api_not_implemented_call)
34{ 34{
35 eo_init(); 35 efl_object_init();
36 eina_log_print_cb_set(eo_test_print_cb, &ctx); 36 eina_log_print_cb_set(eo_test_print_cb, &ctx);
37 37
38 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 38 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
39 fail_if(!obj); 39 fail_if(!obj);
40 40
41 TEST_EO_ERROR("_eo_api_op_id_get", "Unable to resolve op for api func %p"); 41 TEST_EO_ERROR("_efl_object_api_op_id_get", "Unable to resolve op for api func %p");
42 simple_no_implementation(obj); 42 simple_no_implementation(obj);
43 fail_unless(ctx.did); 43 fail_unless(ctx.did);
44 44
45 eo_unref(obj); 45 efl_unref(obj);
46 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 46 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
47 eo_shutdown(); 47 efl_object_shutdown();
48} 48}
49END_TEST 49END_TEST
50 50
51START_TEST(eo_op_not_found_in_super) 51START_TEST(eo_op_not_found_in_super)
52{ 52{
53 eo_init(); 53 efl_object_init();
54 eina_log_print_cb_set(eo_test_print_cb, &ctx); 54 eina_log_print_cb_set(eo_test_print_cb, &ctx);
55 55
56 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 56 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
57 fail_if(!obj); 57 fail_if(!obj);
58 58
59 TEST_EO_ERROR("_eo_call_resolve", "in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'."); 59 TEST_EO_ERROR("_efl_object_call_resolve", "in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'.");
60 simple_a_set(eo_super(obj, SIMPLE_CLASS), 10); 60 simple_a_set(efl_super(obj, SIMPLE_CLASS), 10);
61 fail_unless(ctx.did); 61 fail_unless(ctx.did);
62 62
63 eo_unref(obj); 63 efl_unref(obj);
64 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 64 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
65 eo_shutdown(); 65 efl_object_shutdown();
66} 66}
67END_TEST 67END_TEST
68 68
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 5689f91a65..043a0a23ea 100644
--- a/src/tests/eo/suite/eo_test_class_behaviour_errors.c
+++ b/src/tests/eo/suite/eo_test_class_behaviour_errors.c
@@ -16,77 +16,77 @@ const 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 efl_destructor(eo_super(obj, klass)); 19 efl_destructor(efl_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 efl_unref(obj);
23} 23}
24 24
25START_TEST(efl_destructor_unref) 25START_TEST(efl_destructor_unref)
26{ 26{
27 eo_init(); 27 efl_object_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 Efl_Op_Description op_descs [] = { 30 static Efl_Op_Description op_descs [] = {
31 EO_OP_FUNC_OVERRIDE(efl_destructor, _destructor_unref), 31 EFL_OBJECT_OP_FUNC_OVERRIDE(efl_destructor, _destructor_unref),
32 }; 32 };
33 33
34 static Efl_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 EFL_CLASS_TYPE_REGULAR,
38 EO_CLASS_DESCRIPTION_OPS(op_descs), 38 EFL_CLASS_DESCRIPTION_OPS(op_descs),
39 NULL, 39 NULL,
40 0, 40 0,
41 NULL, 41 NULL,
42 NULL 42 NULL
43 }; 43 };
44 44
45 klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); 45 klass = efl_class_new(&class_desc, SIMPLE_CLASS, NULL);
46 fail_if(!klass); 46 fail_if(!klass);
47 47
48 Eo *obj = eo_add(klass, NULL); 48 Eo *obj = efl_add(klass, NULL);
49 fail_if(!obj); 49 fail_if(!obj);
50 50
51 TEST_EO_ERROR("eo_unref", "Obj:%p. User refcount (%d) < 0. Too many unrefs."); 51 TEST_EO_ERROR("efl_unref", "Obj:%p. User refcount (%d) < 0. Too many unrefs.");
52 eo_unref(obj); 52 efl_unref(obj);
53 53
54 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 54 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
55 55
56 eo_shutdown(); 56 efl_object_shutdown();
57} 57}
58END_TEST 58END_TEST
59 59
60START_TEST(efl_destructor_double_del) 60START_TEST(efl_destructor_double_del)
61{ 61{
62 eo_init(); 62 efl_object_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 Efl_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 EFL_CLASS_TYPE_REGULAR,
69 EO_CLASS_DESCRIPTION_NOOPS(), 69 EFL_CLASS_DESCRIPTION_NOOPS(),
70 NULL, 70 NULL,
71 0, 71 0,
72 NULL, 72 NULL,
73 NULL 73 NULL
74 }; 74 };
75 75
76 klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); 76 klass = efl_class_new(&class_desc, SIMPLE_CLASS, NULL);
77 fail_if(!klass); 77 fail_if(!klass);
78 78
79 Eo *obj = eo_add(klass, NULL); 79 Eo *obj = efl_add(klass, NULL);
80 eo_manual_free_set(obj, EINA_TRUE); 80 efl_manual_free_set(obj, EINA_TRUE);
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("efl_unref", "Obj:%p. User refcount (%d) < 0. Too many unrefs.");
84 efl_del(obj); 84 efl_del(obj);
85 efl_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
89 eo_shutdown(); 89 efl_object_shutdown();
90} 90}
91END_TEST 91END_TEST
92 92
diff --git a/src/tests/eo/suite/eo_test_class_errors.c b/src/tests/eo/suite/eo_test_class_errors.c
index d2bac92adf..400ea544ef 100644
--- a/src/tests/eo/suite/eo_test_class_errors.c
+++ b/src/tests/eo/suite/eo_test_class_errors.c
@@ -14,7 +14,7 @@ static struct log_ctx ctx;
14 14
15START_TEST(eo_inherit_errors) 15START_TEST(eo_inherit_errors)
16{ 16{
17 eo_init(); 17 efl_object_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 Efl_Class *klass; 20 const Efl_Class *klass;
@@ -24,8 +24,8 @@ START_TEST(eo_inherit_errors)
24 static const Efl_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 EFL_CLASS_TYPE_REGULAR,
28 EO_CLASS_DESCRIPTION_NOOPS(), 28 EFL_CLASS_DESCRIPTION_NOOPS(),
29 NULL, 29 NULL,
30 0, 30 0,
31 NULL, 31 NULL,
@@ -35,8 +35,8 @@ START_TEST(eo_inherit_errors)
35 static const Efl_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 EFL_CLASS_TYPE_MIXIN,
39 EO_CLASS_DESCRIPTION_NOOPS(), 39 EFL_CLASS_DESCRIPTION_NOOPS(),
40 NULL, 40 NULL,
41 0, 41 0,
42 NULL, 42 NULL,
@@ -46,42 +46,42 @@ START_TEST(eo_inherit_errors)
46 static Efl_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 EFL_CLASS_TYPE_MIXIN,
50 EO_CLASS_DESCRIPTION_NOOPS(), 50 EFL_CLASS_DESCRIPTION_NOOPS(),
51 NULL, 51 NULL,
52 0, 52 0,
53 NULL, 53 NULL,
54 NULL 54 NULL
55 }; 55 };
56 56
57 klass_mixin = eo_class_new(&class_desc_mixin, NULL, NULL); 57 klass_mixin = efl_class_new(&class_desc_mixin, NULL, NULL);
58 fail_if(!klass_mixin); 58 fail_if(!klass_mixin);
59 59
60 klass_simple = eo_class_new(&class_desc_simple, EO_CLASS, NULL); 60 klass_simple = efl_class_new(&class_desc_simple, EO_CLASS, NULL);
61 fail_if(!klass_simple); 61 fail_if(!klass_simple);
62 62
63 TEST_EO_ERROR("eo_class_new", "Non-regular classes ('%s') aren't allowed to inherit from regular classes ('%s')."); 63 TEST_EO_ERROR("efl_class_new", "Non-regular classes ('%s') aren't allowed to inherit from regular classes ('%s').");
64 klass = eo_class_new(&class_desc, klass_simple, NULL); 64 klass = efl_class_new(&class_desc, klass_simple, NULL);
65 fail_if(klass); 65 fail_if(klass);
66 fail_unless(ctx.did); 66 fail_unless(ctx.did);
67 67
68 class_desc.type = EO_CLASS_TYPE_REGULAR; 68 class_desc.type = EFL_CLASS_TYPE_REGULAR;
69 69
70 TEST_EO_ERROR("eo_class_new", "Regular classes ('%s') aren't allowed to inherit from non-regular classes ('%s')."); 70 TEST_EO_ERROR("efl_class_new", "Regular classes ('%s') aren't allowed to inherit from non-regular classes ('%s').");
71 klass = eo_class_new(&class_desc, klass_mixin, NULL); 71 klass = efl_class_new(&class_desc, klass_mixin, NULL);
72 fail_if(klass); 72 fail_if(klass);
73 fail_unless(ctx.did); 73 fail_unless(ctx.did);
74 74
75 (void) klass; 75 (void) klass;
76 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 76 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
77 77
78 eo_shutdown(); 78 efl_object_shutdown();
79} 79}
80END_TEST 80END_TEST
81 81
82START_TEST(eo_inconsistent_mro) 82START_TEST(eo_inconsistent_mro)
83{ 83{
84 eo_init(); 84 efl_object_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 Efl_Class *klass; 87 const Efl_Class *klass;
@@ -92,8 +92,8 @@ START_TEST(eo_inconsistent_mro)
92 static const Efl_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 EFL_CLASS_TYPE_REGULAR,
96 EO_CLASS_DESCRIPTION_NOOPS(), 96 EFL_CLASS_DESCRIPTION_NOOPS(),
97 NULL, 97 NULL,
98 0, 98 0,
99 NULL, 99 NULL,
@@ -103,8 +103,8 @@ START_TEST(eo_inconsistent_mro)
103 static const Efl_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 EFL_CLASS_TYPE_MIXIN,
107 EO_CLASS_DESCRIPTION_NOOPS(), 107 EFL_CLASS_DESCRIPTION_NOOPS(),
108 NULL, 108 NULL,
109 0, 109 0,
110 NULL, 110 NULL,
@@ -114,8 +114,8 @@ START_TEST(eo_inconsistent_mro)
114 static const Efl_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 EFL_CLASS_TYPE_MIXIN,
118 EO_CLASS_DESCRIPTION_NOOPS(), 118 EFL_CLASS_DESCRIPTION_NOOPS(),
119 NULL, 119 NULL,
120 0, 120 0,
121 NULL, 121 NULL,
@@ -125,37 +125,37 @@ START_TEST(eo_inconsistent_mro)
125 static const Efl_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 EFL_CLASS_TYPE_MIXIN,
129 EO_CLASS_DESCRIPTION_NOOPS(), 129 EFL_CLASS_DESCRIPTION_NOOPS(),
130 NULL, 130 NULL,
131 0, 131 0,
132 NULL, 132 NULL,
133 NULL 133 NULL
134 }; 134 };
135 135
136 klass_mixin = eo_class_new(&class_desc_mixin, NULL, NULL); 136 klass_mixin = efl_class_new(&class_desc_mixin, NULL, NULL);
137 fail_if(!klass_mixin); 137 fail_if(!klass_mixin);
138 138
139 klass_mixin2 = eo_class_new(&class_desc_mixin2, klass_mixin, NULL); 139 klass_mixin2 = efl_class_new(&class_desc_mixin2, klass_mixin, NULL);
140 fail_if(!klass_mixin2); 140 fail_if(!klass_mixin2);
141 141
142 klass_mixin3 = eo_class_new(&class_desc_mixin3, klass_mixin, NULL); 142 klass_mixin3 = efl_class_new(&class_desc_mixin3, klass_mixin, NULL);
143 fail_if(!klass_mixin3); 143 fail_if(!klass_mixin3);
144 144
145 TEST_EO_ERROR("_eo_class_mro_init", "Cannot create a consistent method resolution order for class '%s' because of '%s'."); 145 TEST_EO_ERROR("_eo_class_mro_init", "Cannot create a consistent method resolution order for class '%s' because of '%s'.");
146 klass = eo_class_new(&class_desc_simple, EO_CLASS, klass_mixin, klass_mixin2, NULL); 146 klass = efl_class_new(&class_desc_simple, EO_CLASS, klass_mixin, klass_mixin2, NULL);
147 fail_if(klass); 147 fail_if(klass);
148 fail_unless(ctx.did); 148 fail_unless(ctx.did);
149 149
150 klass = eo_class_new(&class_desc_simple, EO_CLASS, klass_mixin2, klass_mixin, NULL); 150 klass = efl_class_new(&class_desc_simple, EO_CLASS, klass_mixin2, klass_mixin, NULL);
151 fail_if(!klass); 151 fail_if(!klass);
152 152
153 klass = eo_class_new(&class_desc_simple, EO_CLASS, klass_mixin2, klass_mixin3, NULL); 153 klass = efl_class_new(&class_desc_simple, EO_CLASS, klass_mixin2, klass_mixin3, NULL);
154 fail_if(!klass); 154 fail_if(!klass);
155 155
156 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 156 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
157 157
158 eo_shutdown(); 158 efl_object_shutdown();
159} 159}
160END_TEST 160END_TEST
161 161
@@ -163,7 +163,7 @@ static 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 efl_object_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 Efl_Class *klass; 169 const Efl_Class *klass;
@@ -171,39 +171,39 @@ START_TEST(eo_bad_interface)
171 static Efl_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 EFL_CLASS_TYPE_INTERFACE,
175 EO_CLASS_DESCRIPTION_NOOPS(), 175 EFL_CLASS_DESCRIPTION_NOOPS(),
176 NULL, 176 NULL,
177 10, 177 10,
178 NULL, 178 NULL,
179 NULL 179 NULL
180 }; 180 };
181 181
182 TEST_EO_ERROR("eo_class_new", "safety check failed: !desc->data_size is false"); 182 TEST_EO_ERROR("efl_class_new", "safety check failed: !desc->data_size is false");
183 klass = eo_class_new(&class_desc, NULL, NULL); 183 klass = efl_class_new(&class_desc, NULL, NULL);
184 fail_if(klass); 184 fail_if(klass);
185 fail_unless(ctx.did); 185 fail_unless(ctx.did);
186 186
187 class_desc.data_size = 0; 187 class_desc.data_size = 0;
188 class_desc.class_constructor = _stub_class_constructor; 188 class_desc.class_constructor = _stub_class_constructor;
189 189
190 klass = eo_class_new(&class_desc, NULL, NULL); 190 klass = efl_class_new(&class_desc, NULL, NULL);
191 fail_if(!klass); 191 fail_if(!klass);
192 192
193 class_desc.class_constructor = NULL; 193 class_desc.class_constructor = NULL;
194 class_desc.class_destructor = _stub_class_constructor; 194 class_desc.class_destructor = _stub_class_constructor;
195 195
196 klass = eo_class_new(&class_desc, NULL, NULL); 196 klass = efl_class_new(&class_desc, NULL, NULL);
197 fail_if(!klass); 197 fail_if(!klass);
198 198
199 class_desc.class_destructor = NULL; 199 class_desc.class_destructor = NULL;
200 200
201 klass = eo_class_new(&class_desc, NULL, NULL); 201 klass = efl_class_new(&class_desc, NULL, NULL);
202 fail_if(!klass); 202 fail_if(!klass);
203 203
204 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 204 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
205 205
206 eo_shutdown(); 206 efl_object_shutdown();
207} 207}
208END_TEST 208END_TEST
209 209
@@ -212,19 +212,19 @@ void null_fct (void) {}
212 212
213START_TEST(eo_null_api) 213START_TEST(eo_null_api)
214{ 214{
215 eo_init(); 215 efl_object_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 Efl_Class *klass; 218 const Efl_Class *klass;
219 219
220 static Efl_Op_Description op_descs[] = { 220 static Efl_Op_Description op_descs[] = {
221 EO_OP_FUNC(NULL, _null_fct), 221 EFL_OBJECT_OP_FUNC(NULL, _null_fct),
222 }; 222 };
223 static Efl_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 EFL_CLASS_TYPE_REGULAR,
227 EO_CLASS_DESCRIPTION_OPS(op_descs), 227 EFL_CLASS_DESCRIPTION_OPS(op_descs),
228 NULL, 228 NULL,
229 0, 229 0,
230 NULL, 230 NULL,
@@ -232,31 +232,31 @@ START_TEST(eo_null_api)
232 }; 232 };
233 233
234 TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': NULL API not allowed (NULL->%p '%s')."); 234 TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': NULL API not allowed (NULL->%p '%s').");
235 klass = eo_class_new(&class_desc, NULL, NULL); 235 klass = efl_class_new(&class_desc, NULL, NULL);
236 fail_if(klass); 236 fail_if(klass);
237 fail_unless(ctx.did); 237 fail_unless(ctx.did);
238 238
239 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 239 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
240 240
241 eo_shutdown(); 241 efl_object_shutdown();
242} 242}
243END_TEST 243END_TEST
244 244
245START_TEST(eo_wrong_override) 245START_TEST(eo_wrong_override)
246{ 246{
247 eo_init(); 247 efl_object_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 Efl_Class *klass; 250 const Efl_Class *klass;
251 251
252 static Efl_Op_Description op_descs[] = { 252 static Efl_Op_Description op_descs[] = {
253 EO_OP_FUNC_OVERRIDE(null_fct, _null_fct), 253 EFL_OBJECT_OP_FUNC_OVERRIDE(null_fct, _null_fct),
254 }; 254 };
255 static Efl_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 EFL_CLASS_TYPE_REGULAR,
259 EO_CLASS_DESCRIPTION_OPS(op_descs), 259 EFL_CLASS_DESCRIPTION_OPS(op_descs),
260 NULL, 260 NULL,
261 0, 261 0,
262 NULL, 262 NULL,
@@ -264,32 +264,32 @@ START_TEST(eo_wrong_override)
264 }; 264 };
265 265
266 TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': Can't find api func description in class hierarchy (%p->%p) (%s)."); 266 TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': Can't find api func description in class hierarchy (%p->%p) (%s).");
267 klass = eo_class_new(&class_desc, NULL, NULL); 267 klass = efl_class_new(&class_desc, NULL, NULL);
268 fail_if(klass); 268 fail_if(klass);
269 fail_unless(ctx.did); 269 fail_unless(ctx.did);
270 270
271 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 271 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
272 272
273 eo_shutdown(); 273 efl_object_shutdown();
274} 274}
275END_TEST 275END_TEST
276 276
277START_TEST(eo_api_redefined) 277START_TEST(eo_api_redefined)
278{ 278{
279 eo_init(); 279 efl_object_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 Efl_Class *klass; 282 const Efl_Class *klass;
283 283
284 static Efl_Op_Description op_descs[] = { 284 static Efl_Op_Description op_descs[] = {
285 EO_OP_FUNC(null_fct, _null_fct), 285 EFL_OBJECT_OP_FUNC(null_fct, _null_fct),
286 EO_OP_FUNC(null_fct, NULL), 286 EFL_OBJECT_OP_FUNC(null_fct, NULL),
287 }; 287 };
288 static Efl_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 EFL_CLASS_TYPE_REGULAR,
292 EO_CLASS_DESCRIPTION_OPS(op_descs), 292 EFL_CLASS_DESCRIPTION_OPS(op_descs),
293 NULL, 293 NULL,
294 0, 294 0,
295 NULL, 295 NULL,
@@ -297,32 +297,32 @@ START_TEST(eo_api_redefined)
297 }; 297 };
298 298
299 TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': API previously defined (%p->%p '%s')."); 299 TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': API previously defined (%p->%p '%s').");
300 klass = eo_class_new(&class_desc, NULL, NULL); 300 klass = efl_class_new(&class_desc, NULL, NULL);
301 fail_if(klass); 301 fail_if(klass);
302 fail_unless(ctx.did); 302 fail_unless(ctx.did);
303 303
304 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 304 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
305 305
306 eo_shutdown(); 306 efl_object_shutdown();
307} 307}
308END_TEST 308END_TEST
309 309
310START_TEST(eo_dich_func_override) 310START_TEST(eo_dich_func_override)
311{ 311{
312 eo_init(); 312 efl_object_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 Efl_Class *klass; 315 const Efl_Class *klass;
316 316
317 static Efl_Op_Description op_descs[] = { 317 static Efl_Op_Description op_descs[] = {
318 EO_OP_FUNC_OVERRIDE(simple_a_set, _null_fct), 318 EFL_OBJECT_OP_FUNC_OVERRIDE(simple_a_set, _null_fct),
319 EO_OP_FUNC_OVERRIDE(simple_a_set, NULL), 319 EFL_OBJECT_OP_FUNC_OVERRIDE(simple_a_set, NULL),
320 }; 320 };
321 static Efl_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 EFL_CLASS_TYPE_REGULAR,
325 EO_CLASS_DESCRIPTION_OPS(op_descs), 325 EFL_CLASS_DESCRIPTION_OPS(op_descs),
326 NULL, 326 NULL,
327 0, 327 0,
328 NULL, 328 NULL,
@@ -330,13 +330,13 @@ START_TEST(eo_dich_func_override)
330 }; 330 };
331 331
332 TEST_EO_ERROR("_vtable_func_set", "Class '%s': Overriding already set func %p for op %d (%s) with %p."); 332 TEST_EO_ERROR("_vtable_func_set", "Class '%s': Overriding already set func %p for op %d (%s) with %p.");
333 klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); 333 klass = efl_class_new(&class_desc, SIMPLE_CLASS, NULL);
334 fail_if(klass); 334 fail_if(klass);
335 fail_unless(ctx.did); 335 fail_unless(ctx.did);
336 336
337 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); 337 eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
338 338
339 eo_shutdown(); 339 efl_object_shutdown();
340} 340}
341END_TEST 341END_TEST
342 342
diff --git a/src/tests/eo/suite/eo_test_class_simple.c b/src/tests/eo/suite/eo_test_class_simple.c
index b4f715d752..0971f88966 100644
--- a/src/tests/eo/suite/eo_test_class_simple.c
+++ b/src/tests/eo/suite/eo_test_class_simple.c
@@ -17,7 +17,7 @@ static 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)
18{ 18{
19 Simple_Public_Data *pd = class_data; 19 Simple_Public_Data *pd = class_data;
20 printf("%s %d\n", eo_class_name_get(MY_CLASS), a); 20 printf("%s %d\n", efl_class_name_get(MY_CLASS), a);
21 pd->a = a; 21 pd->a = a;
22 22
23 efl_event_callback_call(obj, EV_A_CHANGED, &pd->a); 23 efl_event_callback_call(obj, EV_A_CHANGED, &pd->a);
@@ -35,7 +35,7 @@ static Eina_Bool
35_a_print(Eo *obj EINA_UNUSED, void *class_data) 35_a_print(Eo *obj EINA_UNUSED, void *class_data)
36{ 36{
37 const Simple_Public_Data *pd = class_data; 37 const Simple_Public_Data *pd = class_data;
38 printf("Print %s %d\n", eo_class_name_get(MY_CLASS), pd->a); 38 printf("Print %s %d\n", efl_class_name_get(MY_CLASS), pd->a);
39 39
40 return EINA_TRUE; 40 return EINA_TRUE;
41} 41}
@@ -43,21 +43,21 @@ _a_print(Eo *obj EINA_UNUSED, void *class_data)
43static Eina_Bool 43static Eina_Bool
44_class_hi_print(Efl_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", efl_class_name_get(klass));
47 47
48 return EINA_TRUE; 48 return EINA_TRUE;
49} 49}
50 50
51EO_FUNC_BODYV(simple_part_get, Eo *, NULL, EO_FUNC_CALL(name), const char *name); 51EFL_FUNC_BODYV(simple_part_get, Eo *, NULL, EFL_FUNC_CALL(name), const char *name);
52 52
53static Eo * 53static Eo *
54_part_get(Eo *obj, void *class_data EINA_UNUSED, const char *name EINA_UNUSED) 54_part_get(Eo *obj, void *class_data EINA_UNUSED, const char *name EINA_UNUSED)
55{ 55{
56 /* A normal part get will do something saner, we just create objects. */ 56 /* A normal part get will do something saner, we just create objects. */
57 return eo_add(SIMPLE_CLASS, obj); 57 return efl_add(SIMPLE_CLASS, obj);
58} 58}
59 59
60EO_VOID_FUNC_BODYV(simple_recursive, EO_FUNC_CALL(n), int n); 60EFL_VOID_FUNC_BODYV(simple_recursive, EFL_FUNC_CALL(n), int n);
61 61
62static void 62static void
63_recursive(Eo *obj, void *class_data EINA_UNUSED, int n) 63_recursive(Eo *obj, void *class_data EINA_UNUSED, int n)
@@ -76,41 +76,41 @@ _recursive(Eo *obj, void *class_data EINA_UNUSED, int n)
76static void 76static void
77_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, Efl_Dbg_Info *root) 77_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, Efl_Dbg_Info *root)
78{ 78{
79 efl_dbg_info_get(eo_super(eo_obj, MY_CLASS), root); 79 efl_dbg_info_get(efl_super(eo_obj, MY_CLASS), root);
80 Efl_Dbg_Info *group = EO_DBG_INFO_LIST_APPEND(root, "Test list"); 80 Efl_Dbg_Info *group = EFL_DBG_INFO_LIST_APPEND(root, "Test list");
81 EO_DBG_INFO_APPEND(group, "Test", EINA_VALUE_TYPE_INT, 8); 81 EFL_DBG_INFO_APPEND(group, "Test", EINA_VALUE_TYPE_INT, 8);
82} 82}
83 83
84EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a); 84EFL_VOID_FUNC_BODYV(simple_a_set, EFL_FUNC_CALL(a), int a);
85EO_FUNC_BODY(simple_a_get, int, 0); 85EFL_FUNC_BODY(simple_a_get, int, 0);
86EO_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE); 86EFL_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE);
87EO_FUNC_BODY_CONST(simple_class_hi_print, Eina_Bool, EINA_FALSE); 87EFL_FUNC_BODY_CONST(simple_class_hi_print, Eina_Bool, EINA_FALSE);
88EO_VOID_FUNC_BODY(simple_pure_virtual); 88EFL_VOID_FUNC_BODY(simple_pure_virtual);
89EO_VOID_FUNC_BODY(simple_no_implementation); 89EFL_VOID_FUNC_BODY(simple_no_implementation);
90 90
91static Efl_Op_Description op_descs[] = { 91static Efl_Op_Description op_descs[] = {
92 EO_OP_FUNC(simple_a_set, _a_set), 92 EFL_OBJECT_OP_FUNC(simple_a_set, _a_set),
93 EO_OP_FUNC(simple_a_get, _a_get), 93 EFL_OBJECT_OP_FUNC(simple_a_get, _a_get),
94 EO_OP_FUNC(simple_a_print, _a_print), 94 EFL_OBJECT_OP_FUNC(simple_a_print, _a_print),
95 EO_OP_CLASS_FUNC(simple_class_hi_print, _class_hi_print), 95 EFL_OBJECT_OP_CLASS_FUNC(simple_class_hi_print, _class_hi_print),
96 EO_OP_FUNC(simple_recursive, _recursive), 96 EFL_OBJECT_OP_FUNC(simple_recursive, _recursive),
97 EO_OP_FUNC(simple_part_get, _part_get), 97 EFL_OBJECT_OP_FUNC(simple_part_get, _part_get),
98 EO_OP_FUNC(simple_pure_virtual, NULL), 98 EFL_OBJECT_OP_FUNC(simple_pure_virtual, NULL),
99 EO_OP_FUNC_OVERRIDE(efl_dbg_info_get, _dbg_info_get), 99 EFL_OBJECT_OP_FUNC_OVERRIDE(efl_dbg_info_get, _dbg_info_get),
100}; 100};
101 101
102static const Efl_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 EFL_CLASS_TYPE_REGULAR,
106 EO_CLASS_DESCRIPTION_OPS(op_descs), 106 EFL_CLASS_DESCRIPTION_OPS(op_descs),
107 NULL, 107 NULL,
108 sizeof(Simple_Public_Data), 108 sizeof(Simple_Public_Data),
109 NULL, 109 NULL,
110 NULL 110 NULL
111}; 111};
112 112
113EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL) 113EFL_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL)
114 114
115 115
116static int 116static int
@@ -119,46 +119,46 @@ _beef_get(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
119 return 0xBEEF; 119 return 0xBEEF;
120} 120}
121 121
122EO_FUNC_BODY_CONST(simple2_class_beef_get, int, 0); 122EFL_FUNC_BODY_CONST(simple2_class_beef_get, int, 0);
123 123
124static Efl_Op_Description op_descs2[] = { 124static Efl_Op_Description op_descs2[] = {
125 EO_OP_CLASS_FUNC(simple2_class_beef_get, _beef_get), 125 EFL_OBJECT_OP_CLASS_FUNC(simple2_class_beef_get, _beef_get),
126}; 126};
127 127
128static const Efl_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 EFL_CLASS_TYPE_REGULAR,
132 EO_CLASS_DESCRIPTION_OPS(op_descs2), 132 EFL_CLASS_DESCRIPTION_OPS(op_descs2),
133 NULL, 133 NULL,
134 0, 134 0,
135 NULL, 135 NULL,
136 NULL 136 NULL
137}; 137};
138 138
139EO_DEFINE_CLASS(simple2_class_get, &class_desc2, EO_CLASS, NULL) 139EFL_DEFINE_CLASS(simple2_class_get, &class_desc2, EO_CLASS, NULL)
140 140
141static Efl_Object* 141static Efl_Object*
142_interface_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, const Efl_Object *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 efl_provider_find(eo_super(obj, SEARCHABLE_CLASS), klass); 146 return efl_provider_find(efl_super(obj, SEARCHABLE_CLASS), klass);
147} 147}
148 148
149static Efl_Op_Description op_descs_searchable[] = { 149static Efl_Op_Description op_descs_searchable[] = {
150 EO_OP_FUNC_OVERRIDE(efl_provider_find, _interface_get) 150 EFL_OBJECT_OP_FUNC_OVERRIDE(efl_provider_find, _interface_get)
151}; 151};
152 152
153static const Efl_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 EFL_CLASS_TYPE_REGULAR,
157 EO_CLASS_DESCRIPTION_OPS(op_descs_searchable), 157 EFL_CLASS_DESCRIPTION_OPS(op_descs_searchable),
158 NULL, 158 NULL,
159 0, 159 0,
160 NULL, 160 NULL,
161 NULL 161 NULL
162}; 162};
163 163
164EO_DEFINE_CLASS(searchable_class_get, &class_desc_searchable, EO_CLASS, NULL) \ No newline at end of file 164EFL_DEFINE_CLASS(searchable_class_get, &class_desc_searchable, EO_CLASS, NULL) \ No newline at end of file
diff --git a/src/tests/eo/suite/eo_test_class_singleton.c b/src/tests/eo/suite/eo_test_class_singleton.c
index 692e382075..b6ed50dca0 100644
--- a/src/tests/eo/suite/eo_test_class_singleton.c
+++ b/src/tests/eo/suite/eo_test_class_singleton.c
@@ -15,29 +15,29 @@ _singleton_efl_constructor(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED)
15{ 15{
16 if (!singleton_obj) 16 if (!singleton_obj)
17 { 17 {
18 singleton_obj = eo_add(SIMPLE_CLASS, NULL); 18 singleton_obj = efl_add(SIMPLE_CLASS, NULL);
19 } 19 }
20 else 20 else
21 { 21 {
22 eo_ref(singleton_obj); 22 efl_ref(singleton_obj);
23 } 23 }
24 24
25 return singleton_obj; 25 return singleton_obj;
26} 26}
27 27
28static Efl_Op_Description op_descs[] = { 28static Efl_Op_Description op_descs[] = {
29 EO_OP_FUNC_OVERRIDE(efl_constructor, _singleton_efl_constructor), 29 EFL_OBJECT_OP_FUNC_OVERRIDE(efl_constructor, _singleton_efl_constructor),
30}; 30};
31 31
32static const Efl_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 EFL_CLASS_TYPE_REGULAR,
36 EO_CLASS_DESCRIPTION_OPS(op_descs), 36 EFL_CLASS_DESCRIPTION_OPS(op_descs),
37 NULL, 37 NULL,
38 0, 38 0,
39 NULL, 39 NULL,
40 NULL 40 NULL
41}; 41};
42 42
43EO_DEFINE_CLASS(singleton_class_get, &class_desc, EO_CLASS, NULL) 43EFL_DEFINE_CLASS(singleton_class_get, &class_desc, EO_CLASS, NULL)
diff --git a/src/tests/eo/suite/eo_test_general.c b/src/tests/eo/suite/eo_test_general.c
index 24705019fc..a8f4fd6702 100644
--- a/src/tests/eo/suite/eo_test_general.c
+++ b/src/tests/eo/suite/eo_test_general.c
@@ -15,36 +15,36 @@
15 15
16START_TEST(eo_simple) 16START_TEST(eo_simple)
17{ 17{
18 eo_init(); 18 efl_object_init();
19 Eo *obj = eo_add(EO_CLASS, NULL); 19 Eo *obj = efl_add(EO_CLASS, NULL);
20 fail_if(obj); 20 fail_if(obj);
21 21
22 obj = eo_add(SIMPLE_CLASS, NULL); 22 obj = efl_add(SIMPLE_CLASS, NULL);
23 fail_if(!obj); 23 fail_if(!obj);
24 efl_constructor(obj); 24 efl_constructor(obj);
25 efl_destructor(obj); 25 efl_destructor(obj);
26 eo_unref(obj); 26 efl_unref(obj);
27 27
28 eo_shutdown(); 28 efl_object_shutdown();
29} 29}
30END_TEST 30END_TEST
31 31
32START_TEST(eo_singleton) 32START_TEST(eo_singleton)
33{ 33{
34 eo_init(); 34 efl_object_init();
35 35
36 Eo *obj = eo_add(SINGLETON_CLASS, NULL); 36 Eo *obj = efl_add(SINGLETON_CLASS, NULL);
37 fail_if(!obj); 37 fail_if(!obj);
38 38
39 Eo *obj2 = eo_add(SINGLETON_CLASS, NULL); 39 Eo *obj2 = efl_add(SINGLETON_CLASS, NULL);
40 fail_if(!obj2); 40 fail_if(!obj2);
41 41
42 ck_assert_ptr_eq(obj, obj2); 42 ck_assert_ptr_eq(obj, obj2);
43 43
44 eo_unref(obj); 44 efl_unref(obj);
45 eo_unref(obj2); 45 efl_unref(obj2);
46 46
47 eo_shutdown(); 47 efl_object_shutdown();
48} 48}
49END_TEST 49END_TEST
50 50
@@ -53,30 +53,30 @@ 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, EFL_OBJECT_OVERRIDE_CLASS)); 56 return OVERRIDE_A + simple_a_get(efl_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, EFL_OBJECT_OVERRIDE_CLASS), 2 * a); 62 simple_a_set(efl_super(obj, EFL_OBJECT_OVERRIDE_CLASS), 2 * a);
63} 63}
64 64
65START_TEST(eo_override_tests) 65START_TEST(efl_object_override_tests)
66{ 66{
67 eo_init(); 67 efl_object_init();
68 68
69 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 69 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
70 fail_if(!obj); 70 fail_if(!obj);
71 71
72 /* First get the value before the override to make sure it works and to 72 /* First get the value before the override to make sure it works and to
73 * make sure we don't cache. */ 73 * make sure we don't cache. */
74 ck_assert_int_eq(simple_a_get(obj), 0); 74 ck_assert_int_eq(simple_a_get(obj), 0);
75 75
76 EO_OVERRIDE_OPS_DEFINE( 76 EFL_OBJECT_OVERRIDE_OPS_DEFINE(
77 overrides, 77 overrides,
78 EO_OP_FUNC_OVERRIDE(simple_a_get, _simple_obj_override_a_get)); 78 EFL_OBJECT_OP_FUNC_OVERRIDE(simple_a_get, _simple_obj_override_a_get));
79 fail_if(!eo_override(obj, &overrides)); 79 fail_if(!efl_object_override(obj, &overrides));
80 80
81 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A); 81 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A);
82 82
@@ -85,34 +85,34 @@ START_TEST(eo_override_tests)
85 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A + OVERRIDE_A_SIMPLE); 85 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A + OVERRIDE_A_SIMPLE);
86 86
87 /* Override again. */ 87 /* Override again. */
88 EO_OVERRIDE_OPS_DEFINE( 88 EFL_OBJECT_OVERRIDE_OPS_DEFINE(
89 overrides2, 89 overrides2,
90 EO_OP_FUNC_OVERRIDE(simple_a_set, _simple_obj_override_a_double_set)); 90 EFL_OBJECT_OP_FUNC_OVERRIDE(simple_a_set, _simple_obj_override_a_double_set));
91 fail_if(!eo_override(obj, NULL)); 91 fail_if(!efl_object_override(obj, NULL));
92 fail_if(!eo_override(obj, &overrides2)); 92 fail_if(!efl_object_override(obj, &overrides2));
93 93
94 simple_a_set(obj, OVERRIDE_A_SIMPLE); 94 simple_a_set(obj, OVERRIDE_A_SIMPLE);
95 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A_SIMPLE * 2); 95 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A_SIMPLE * 2);
96 96
97 /* Try overriding again - not allowed by policy */ 97 /* Try overriding again - not allowed by policy */
98 fail_if(eo_override(obj, &overrides)); 98 fail_if(efl_object_override(obj, &overrides));
99 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A_SIMPLE * 2); 99 ck_assert_int_eq(simple_a_get(obj), OVERRIDE_A_SIMPLE * 2);
100 100
101 /* Try introducing a new function */ 101 /* Try introducing a new function */
102 EO_OVERRIDE_OPS_DEFINE( 102 EFL_OBJECT_OVERRIDE_OPS_DEFINE(
103 overrides3, 103 overrides3,
104 EO_OP_FUNC(simple2_class_beef_get, _simple_obj_override_a_double_set)); 104 EFL_OBJECT_OP_FUNC(simple2_class_beef_get, _simple_obj_override_a_double_set));
105 fail_if(!eo_override(obj, NULL)); 105 fail_if(!efl_object_override(obj, NULL));
106 fail_if(eo_override(obj, &overrides3)); 106 fail_if(efl_object_override(obj, &overrides3));
107 107
108 /* Test override reset */ 108 /* Test override reset */
109 fail_if(!eo_override(obj, NULL)); 109 fail_if(!efl_object_override(obj, NULL));
110 simple_a_set(obj, 42 * OVERRIDE_A_SIMPLE); 110 simple_a_set(obj, 42 * OVERRIDE_A_SIMPLE);
111 ck_assert_int_eq(simple_a_get(obj), 42 * OVERRIDE_A_SIMPLE); 111 ck_assert_int_eq(simple_a_get(obj), 42 * OVERRIDE_A_SIMPLE);
112 112
113 eo_unref(obj); 113 efl_unref(obj);
114 114
115 eo_shutdown(); 115 efl_object_shutdown();
116} 116}
117END_TEST 117END_TEST
118 118
@@ -166,7 +166,7 @@ _eo_signals_cb_added_deled(void *data, const Eo_Event *event)
166 (callback_array->func != _eo_signals_cb_added_deled)); 166 (callback_array->func != _eo_signals_cb_added_deled));
167} 167}
168 168
169EO_CALLBACKS_ARRAY_DEFINE(_eo_signals_callbacks, 169EFL_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 },
@@ -174,9 +174,9 @@ EO_CALLBACKS_ARRAY_DEFINE(_eo_signals_callbacks,
174 174
175START_TEST(eo_signals) 175START_TEST(eo_signals)
176{ 176{
177 eo_init(); 177 efl_object_init();
178 178
179 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 179 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
180 Eina_Bool r; 180 Eina_Bool r;
181 181
182 efl_event_callback_add(obj, EFL_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);
@@ -203,9 +203,9 @@ START_TEST(eo_signals)
203 r = efl_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 efl_unref(obj);
207 207
208 obj = eo_add(SIMPLE_CLASS, NULL); 208 obj = efl_add(SIMPLE_CLASS, NULL);
209 /* Legacy support signals. */ 209 /* Legacy support signals. */
210 { 210 {
211 const Efl_Event_Description *a_desc = efl_object_legacy_only_event_description_get("a,changed"); 211 const Efl_Event_Description *a_desc = efl_object_legacy_only_event_description_get("a,changed");
@@ -252,55 +252,55 @@ START_TEST(eo_signals)
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 }
255 eo_unref(obj); 255 efl_unref(obj);
256 256
257 eo_shutdown(); 257 efl_object_shutdown();
258} 258}
259END_TEST 259END_TEST
260 260
261START_TEST(eo_data_fetch) 261START_TEST(efl_data_fetch)
262{ 262{
263 eo_init(); 263 efl_object_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 Efl_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 EFL_CLASS_TYPE_REGULAR,
270 EO_CLASS_DESCRIPTION_NOOPS(), 270 EFL_CLASS_DESCRIPTION_NOOPS(),
271 NULL, 271 NULL,
272 10, 272 10,
273 NULL, 273 NULL,
274 NULL 274 NULL
275 }; 275 };
276 276
277 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 277 const Efl_Class *klass = efl_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 = efl_add(klass, NULL);
281 fail_if(!obj); 281 fail_if(!obj);
282#ifdef EO_DEBUG 282#ifdef EO_DEBUG
283 fail_if(eo_data_scope_get(obj, SIMPLE_CLASS)); 283 fail_if(efl_data_scope_get(obj, SIMPLE_CLASS));
284#endif 284#endif
285 eo_unref(obj); 285 efl_unref(obj);
286 286
287 class_desc.data_size = 0; 287 class_desc.data_size = 0;
288 klass = eo_class_new(&class_desc, EO_CLASS, NULL); 288 klass = efl_class_new(&class_desc, EO_CLASS, NULL);
289 fail_if(!klass); 289 fail_if(!klass);
290 290
291 obj = eo_add(klass, NULL); 291 obj = efl_add(klass, NULL);
292 fail_if(!obj); 292 fail_if(!obj);
293 fail_if(eo_data_scope_get(obj, klass)); 293 fail_if(efl_data_scope_get(obj, klass));
294 fail_if(!eo_data_scope_get(obj, EFL_OBJECT_CLASS)); 294 fail_if(!efl_data_scope_get(obj, EFL_OBJECT_CLASS));
295 eo_unref(obj); 295 efl_unref(obj);
296 296
297 eo_shutdown(); 297 efl_object_shutdown();
298} 298}
299END_TEST 299END_TEST
300 300
301START_TEST(eo_isa_tests) 301START_TEST(efl_isa_tests)
302{ 302{
303 eo_init(); 303 efl_object_init();
304 304
305 const Efl_Class *klass, *iface, *mixin; 305 const Efl_Class *klass, *iface, *mixin;
306 306
@@ -309,15 +309,15 @@ START_TEST(eo_isa_tests)
309 static Efl_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 EFL_CLASS_TYPE_INTERFACE,
313 EO_CLASS_DESCRIPTION_NOOPS(), 313 EFL_CLASS_DESCRIPTION_NOOPS(),
314 NULL, 314 NULL,
315 0, 315 0,
316 NULL, 316 NULL,
317 NULL 317 NULL
318 }; 318 };
319 319
320 iface = eo_class_new(&class_desc, NULL, NULL); 320 iface = efl_class_new(&class_desc, NULL, NULL);
321 fail_if(!iface); 321 fail_if(!iface);
322 } 322 }
323 323
@@ -326,15 +326,15 @@ START_TEST(eo_isa_tests)
326 static Efl_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 EFL_CLASS_TYPE_MIXIN,
330 EO_CLASS_DESCRIPTION_NOOPS(), 330 EFL_CLASS_DESCRIPTION_NOOPS(),
331 NULL, 331 NULL,
332 0, 332 0,
333 NULL, 333 NULL,
334 NULL 334 NULL
335 }; 335 };
336 336
337 mixin = eo_class_new(&class_desc, NULL, NULL); 337 mixin = efl_class_new(&class_desc, NULL, NULL);
338 fail_if(!mixin); 338 fail_if(!mixin);
339 } 339 }
340 340
@@ -343,50 +343,50 @@ START_TEST(eo_isa_tests)
343 static Efl_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 EFL_CLASS_TYPE_REGULAR,
347 EO_CLASS_DESCRIPTION_NOOPS(), 347 EFL_CLASS_DESCRIPTION_NOOPS(),
348 NULL, 348 NULL,
349 10, 349 10,
350 NULL, 350 NULL,
351 NULL 351 NULL
352 }; 352 };
353 353
354 klass = eo_class_new(&class_desc, EO_CLASS, iface, mixin, NULL); 354 klass = efl_class_new(&class_desc, EO_CLASS, iface, mixin, NULL);
355 fail_if(!klass); 355 fail_if(!klass);
356 } 356 }
357 357
358 Eo *obj = eo_add(klass, NULL); 358 Eo *obj = efl_add(klass, NULL);
359 fail_if(!obj); 359 fail_if(!obj);
360 fail_if(eo_isa(obj, SIMPLE_CLASS)); 360 fail_if(efl_isa(obj, SIMPLE_CLASS));
361 fail_if(!eo_isa(obj, iface)); 361 fail_if(!efl_isa(obj, iface));
362 fail_if(!eo_isa(obj, mixin)); 362 fail_if(!efl_isa(obj, mixin));
363 fail_if(!eo_isa(obj, klass)); 363 fail_if(!efl_isa(obj, klass));
364 fail_if(!eo_isa(obj, EO_CLASS)); 364 fail_if(!efl_isa(obj, EO_CLASS));
365 eo_unref(obj); 365 efl_unref(obj);
366 366
367 obj = eo_add(SIMPLE_CLASS, NULL); 367 obj = efl_add(SIMPLE_CLASS, NULL);
368 fail_if(!obj); 368 fail_if(!obj);
369 fail_if(eo_isa(obj, klass)); 369 fail_if(efl_isa(obj, klass));
370 fail_if(eo_isa(obj, iface)); 370 fail_if(efl_isa(obj, iface));
371 fail_if(eo_isa(obj, mixin)); 371 fail_if(efl_isa(obj, mixin));
372 fail_if(!eo_isa(obj, SIMPLE_CLASS)); 372 fail_if(!efl_isa(obj, SIMPLE_CLASS));
373 fail_if(!eo_isa(obj, EO_CLASS)); 373 fail_if(!efl_isa(obj, EO_CLASS));
374 eo_unref(obj); 374 efl_unref(obj);
375 375
376 eo_shutdown(); 376 efl_object_shutdown();
377} 377}
378END_TEST 378END_TEST
379 379
380 380
381START_TEST(efl_composite_tests) 381START_TEST(efl_composite_tests)
382{ 382{
383 eo_init(); 383 efl_object_init();
384 384
385 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 385 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
386 fail_if(!obj); 386 fail_if(!obj);
387 Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); 387 Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
388 fail_if(!obj2); 388 fail_if(!obj2);
389 Eo *obj3 = eo_add(SIMPLE_CLASS, NULL); 389 Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
390 fail_if(!obj3); 390 fail_if(!obj3);
391 391
392 efl_composite_attach(obj, obj2); 392 efl_composite_attach(obj, obj2);
@@ -404,9 +404,9 @@ START_TEST(efl_composite_tests)
404 efl_del(obj3); 404 efl_del(obj3);
405 fail_if(efl_composite_part_is(obj)); 405 fail_if(efl_composite_part_is(obj));
406 406
407 eo_unref(obj); 407 efl_unref(obj);
408 408
409 eo_shutdown(); 409 efl_object_shutdown();
410} 410}
411END_TEST 411END_TEST
412 412
@@ -418,236 +418,236 @@ static 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 efl_manual_free_set(obj, EINA_TRUE);
422 return efl_constructor(eo_super(obj, cur_klass)); 422 return efl_constructor(efl_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 efl_destructor(eo_super(obj, cur_klass)); 428 efl_destructor(efl_super(obj, cur_klass));
429 if (_man_should_des) 429 if (_man_should_des)
430 eo_manual_free_set(obj, EINA_FALSE); 430 efl_manual_free_set(obj, EINA_FALSE);
431} 431}
432 432
433static Efl_Op_Description op_descs[] = { 433static Efl_Op_Description op_descs[] = {
434 EO_OP_FUNC_OVERRIDE(efl_constructor, _man_con), 434 EFL_OBJECT_OP_FUNC_OVERRIDE(efl_constructor, _man_con),
435 EO_OP_FUNC_OVERRIDE(efl_destructor, _man_des), 435 EFL_OBJECT_OP_FUNC_OVERRIDE(efl_destructor, _man_des),
436}; 436};
437 437
438START_TEST(eo_man_free) 438START_TEST(eo_man_free)
439{ 439{
440 eo_init(); 440 efl_object_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 Efl_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 EFL_CLASS_TYPE_REGULAR,
447 EO_CLASS_DESCRIPTION_OPS(op_descs), 447 EFL_CLASS_DESCRIPTION_OPS(op_descs),
448 NULL, 448 NULL,
449 10, 449 10,
450 NULL, 450 NULL,
451 NULL 451 NULL
452 }; 452 };
453 453
454 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 454 const Efl_Class *klass = efl_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
458 Eo *obj = eo_add(klass, NULL); 458 Eo *obj = efl_add(klass, NULL);
459 fail_if(!obj); 459 fail_if(!obj);
460 eo_unref(obj); 460 efl_unref(obj);
461 461
462 obj = eo_add(klass, NULL); 462 obj = efl_add(klass, NULL);
463 fail_if(!obj); 463 fail_if(!obj);
464 fail_if(eo_manual_free(obj)); 464 fail_if(efl_manual_free(obj));
465 eo_unref(obj); 465 efl_unref(obj);
466 466
467 _man_should_des = EINA_FALSE; 467 _man_should_des = EINA_FALSE;
468 klass = eo_class_new(&class_desc, EO_CLASS, NULL); 468 klass = efl_class_new(&class_desc, EO_CLASS, NULL);
469 cur_klass = klass; 469 cur_klass = klass;
470 fail_if(!klass); 470 fail_if(!klass);
471 471
472 obj = eo_add(klass, NULL); 472 obj = efl_add(klass, NULL);
473 fail_if(!obj); 473 fail_if(!obj);
474 fail_if(eo_manual_free(obj)); 474 fail_if(efl_manual_free(obj));
475 fail_if(eo_destructed_is(obj)); 475 fail_if(efl_destructed_is(obj));
476 eo_unref(obj); 476 efl_unref(obj);
477 fail_if(!eo_destructed_is(obj)); 477 fail_if(!efl_destructed_is(obj));
478 fail_if(!eo_manual_free(obj)); 478 fail_if(!efl_manual_free(obj));
479 479
480 obj = eo_add(klass, NULL); 480 obj = efl_add(klass, NULL);
481 fail_if(!obj); 481 fail_if(!obj);
482 eo_unref(obj); 482 efl_unref(obj);
483 fail_if(!eo_destructed_is(obj)); 483 fail_if(!efl_destructed_is(obj));
484 fail_if(!eo_manual_free(obj)); 484 fail_if(!efl_manual_free(obj));
485 485
486 _man_should_con = EINA_FALSE; 486 _man_should_con = EINA_FALSE;
487 klass = eo_class_new(&class_desc, EO_CLASS, NULL); 487 klass = efl_class_new(&class_desc, EO_CLASS, NULL);
488 cur_klass = klass; 488 cur_klass = klass;
489 fail_if(!klass); 489 fail_if(!klass);
490 490
491 obj = eo_add(klass, NULL); 491 obj = efl_add(klass, NULL);
492 fail_if(!obj); 492 fail_if(!obj);
493 fail_if(eo_manual_free(obj)); 493 fail_if(efl_manual_free(obj));
494 eo_unref(obj); 494 efl_unref(obj);
495 495
496 obj = eo_add(klass, NULL); 496 obj = efl_add(klass, NULL);
497 fail_if(!obj); 497 fail_if(!obj);
498 eo_manual_free_set(obj, EINA_TRUE); 498 efl_manual_free_set(obj, EINA_TRUE);
499 eo_unref(obj); 499 efl_unref(obj);
500 eo_ref(obj); 500 efl_ref(obj);
501 eo_unref(obj); 501 efl_unref(obj);
502 eo_unref(obj); 502 efl_unref(obj);
503 fail_if(!eo_manual_free(obj)); 503 fail_if(!efl_manual_free(obj));
504 504
505 obj = eo_add(klass, NULL); 505 obj = efl_add(klass, NULL);
506 fail_if(!obj); 506 fail_if(!obj);
507 eo_manual_free_set(obj, EINA_TRUE); 507 efl_manual_free_set(obj, EINA_TRUE);
508 eo_unref(obj); 508 efl_unref(obj);
509 eo_ref(obj); 509 efl_ref(obj);
510 eo_unref(obj); 510 efl_unref(obj);
511 eo_unref(obj); 511 efl_unref(obj);
512 eo_unref(obj); 512 efl_unref(obj);
513 eo_unref(obj); 513 efl_unref(obj);
514 fail_if(!eo_manual_free(obj)); 514 fail_if(!efl_manual_free(obj));
515 515
516 eo_shutdown(); 516 efl_object_shutdown();
517} 517}
518END_TEST 518END_TEST
519 519
520START_TEST(eo_refs) 520START_TEST(efl_refs)
521{ 521{
522 eo_init(); 522 efl_object_init();
523 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 523 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
524 Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); 524 Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
525 Eo *obj3 = eo_add(SIMPLE_CLASS, NULL); 525 Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
526 526
527 eo_xref(obj, obj2); 527 efl_xref(obj, obj2);
528 fail_if(eo_ref_get(obj) != 2); 528 fail_if(efl_ref_get(obj) != 2);
529 eo_xref(obj, obj3); 529 efl_xref(obj, obj3);
530 fail_if(eo_ref_get(obj) != 3); 530 fail_if(efl_ref_get(obj) != 3);
531 531
532 eo_xunref(obj, obj2); 532 efl_xunref(obj, obj2);
533 fail_if(eo_ref_get(obj) != 2); 533 fail_if(efl_ref_get(obj) != 2);
534 eo_xunref(obj, obj3); 534 efl_xunref(obj, obj3);
535 fail_if(eo_ref_get(obj) != 1); 535 fail_if(efl_ref_get(obj) != 1);
536 536
537#ifdef EO_DEBUG 537#ifdef EO_DEBUG
538 eo_xunref(obj, obj3); 538 efl_xunref(obj, obj3);
539 fail_if(eo_ref_get(obj) != 1); 539 fail_if(efl_ref_get(obj) != 1);
540 540
541 eo_xref(obj, obj2); 541 efl_xref(obj, obj2);
542 fail_if(eo_ref_get(obj) != 2); 542 fail_if(efl_ref_get(obj) != 2);
543 543
544 eo_xunref(obj, obj3); 544 efl_xunref(obj, obj3);
545 fail_if(eo_ref_get(obj) != 2); 545 fail_if(efl_ref_get(obj) != 2);
546 546
547 eo_xunref(obj, obj2); 547 efl_xunref(obj, obj2);
548 fail_if(eo_ref_get(obj) != 1); 548 fail_if(efl_ref_get(obj) != 1);
549#endif 549#endif
550 550
551 /* Check we don't seg if there's an extra xref. */ 551 /* Check we don't seg if there's an extra xref. */
552 eo_xref(obj, obj2); 552 efl_xref(obj, obj2);
553 eo_unref(obj); 553 efl_unref(obj);
554 554
555 eo_unref(obj); 555 efl_unref(obj);
556 eo_unref(obj2); 556 efl_unref(obj2);
557 eo_unref(obj3); 557 efl_unref(obj3);
558 558
559 /* Check hierarchy */ 559 /* Check hierarchy */
560 obj = eo_add(SIMPLE_CLASS, NULL); 560 obj = efl_add(SIMPLE_CLASS, NULL);
561 obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj)); 561 obj2 = efl_ref(efl_add(SIMPLE_CLASS, obj));
562 562
563 Eo *wref = NULL; 563 Eo *wref = NULL;
564 efl_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 efl_unref(obj2);
568 568
569 fail_if(!wref); /* Parent is still holding a reference. */ 569 fail_if(!wref); /* Parent is still holding a reference. */
570 570
571 eo_unref(obj); 571 efl_unref(obj);
572 572
573 fail_if(wref); 573 fail_if(wref);
574 574
575 /* eo_add_ref and normal eo_add */ 575 /* efl_add_ref and normal efl_add */
576 obj = eo_add(SIMPLE_CLASS, NULL); 576 obj = efl_add(SIMPLE_CLASS, NULL);
577 obj2 = eo_add(SIMPLE_CLASS, obj); 577 obj2 = efl_add(SIMPLE_CLASS, obj);
578 obj3 = eo_add_ref(SIMPLE_CLASS, obj); 578 obj3 = efl_add_ref(SIMPLE_CLASS, obj);
579 579
580 ck_assert_int_eq(eo_ref_get(obj), 1); 580 ck_assert_int_eq(efl_ref_get(obj), 1);
581 ck_assert_int_eq(eo_ref_get(obj2), 1); 581 ck_assert_int_eq(efl_ref_get(obj2), 1);
582 ck_assert_int_eq(eo_ref_get(obj3), 2); 582 ck_assert_int_eq(efl_ref_get(obj3), 2);
583 583
584 /* Setting and removing parents. */ 584 /* Setting and removing parents. */
585 obj = eo_add(SIMPLE_CLASS, NULL); 585 obj = efl_add(SIMPLE_CLASS, NULL);
586 obj2 = eo_ref(eo_add(SIMPLE_CLASS, obj)); 586 obj2 = efl_ref(efl_add(SIMPLE_CLASS, obj));
587 obj3 = eo_ref(eo_add(SIMPLE_CLASS, NULL)); 587 obj3 = efl_ref(efl_add(SIMPLE_CLASS, NULL));
588 588
589 efl_parent_set(obj2, obj3); 589 efl_parent_set(obj2, obj3);
590 efl_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(efl_ref_get(obj2), 2);
592 ck_assert_int_eq(eo_ref_get(obj3), 2); 592 ck_assert_int_eq(efl_ref_get(obj3), 2);
593 593
594 efl_parent_set(obj2, NULL); 594 efl_parent_set(obj2, NULL);
595 efl_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(efl_ref_get(obj2), 1);
597 ck_assert_int_eq(eo_ref_get(obj3), 1); 597 ck_assert_int_eq(efl_ref_get(obj3), 1);
598 598
599 efl_parent_set(obj2, obj); 599 efl_parent_set(obj2, obj);
600 efl_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(efl_ref_get(obj2), 1);
602 ck_assert_int_eq(eo_ref_get(obj3), 1); 602 ck_assert_int_eq(efl_ref_get(obj3), 1);
603 603
604 efl_del(obj); 604 efl_del(obj);
605 efl_del(obj2); 605 efl_del(obj2);
606 efl_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 = efl_add(SIMPLE_CLASS, NULL);
610 eo_ref(obj); 610 efl_ref(obj);
611 eo_unref(obj); 611 efl_unref(obj);
612 eo_unref(obj); 612 efl_unref(obj);
613 613
614 obj = eo_add(SIMPLE_CLASS, NULL); 614 obj = efl_add(SIMPLE_CLASS, NULL);
615 obj2 = eo_add(SIMPLE_CLASS, obj); 615 obj2 = efl_add(SIMPLE_CLASS, obj);
616 eo_unref(obj2); 616 efl_unref(obj2);
617 eo_ref(obj2); 617 efl_ref(obj2);
618 efl_del(obj2); 618 efl_del(obj2);
619 eo_unref(obj); 619 efl_unref(obj);
620 620
621 eo_shutdown(); 621 efl_object_shutdown();
622} 622}
623END_TEST 623END_TEST
624 624
625START_TEST(eo_weak_reference) 625START_TEST(efl_weak_reference)
626{ 626{
627 eo_init(); 627 efl_object_init();
628 628
629 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 629 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
630 Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); 630 Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
631 Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL; 631 Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL;
632 efl_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 efl_unref(obj);
636 fail_if(wref); 636 fail_if(wref);
637 637
638 obj = eo_add(SIMPLE_CLASS, NULL); 638 obj = efl_add(SIMPLE_CLASS, NULL);
639 efl_wref_add(obj, &wref); 639 efl_wref_add(obj, &wref);
640 640
641 eo_ref(obj); 641 efl_ref(obj);
642 fail_if(!wref); 642 fail_if(!wref);
643 643
644 eo_unref(obj); 644 efl_unref(obj);
645 fail_if(!wref); 645 fail_if(!wref);
646 646
647 eo_unref(obj); 647 efl_unref(obj);
648 fail_if(wref); 648 fail_if(wref);
649 649
650 obj = eo_add(SIMPLE_CLASS, NULL); 650 obj = efl_add(SIMPLE_CLASS, NULL);
651 651
652 efl_wref_add(obj, &wref); 652 efl_wref_add(obj, &wref);
653 efl_wref_del(obj, &wref); 653 efl_wref_del(obj, &wref);
@@ -685,20 +685,20 @@ START_TEST(eo_weak_reference)
685 efl_wref_del(obj, &wref2); 685 efl_wref_del(obj, &wref2);
686 efl_wref_del(obj, &wref3); 686 efl_wref_del(obj, &wref3);
687 687
688 eo_unref(obj); 688 efl_unref(obj);
689 eo_unref(obj2); 689 efl_unref(obj2);
690 690
691 691
692 eo_shutdown(); 692 efl_object_shutdown();
693} 693}
694END_TEST 694END_TEST
695 695
696START_TEST(eo_generic_data) 696START_TEST(eo_generic_data)
697{ 697{
698 eo_init(); 698 efl_object_init();
699 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 699 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
700 Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); 700 Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
701 Eo *obj3 = eo_add(SIMPLE_CLASS, NULL); 701 Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
702 Eo *objtmp; 702 Eo *objtmp;
703 void *data = NULL; 703 void *data = NULL;
704 Eina_Value *value; 704 Eina_Value *value;
@@ -747,10 +747,10 @@ START_TEST(eo_generic_data)
747 fail_if(objtmp); 747 fail_if(objtmp);
748 748
749 efl_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(efl_ref_get(obj2) != 2);
751 751
752 efl_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(efl_ref_get(obj3) != 2);
754 754
755 objtmp = efl_key_ref_get(obj, "test1"); 755 objtmp = efl_key_ref_get(obj, "test1");
756 fail_if(obj2 != objtmp); 756 fail_if(obj2 != objtmp);
@@ -762,7 +762,7 @@ START_TEST(eo_generic_data)
762 fail_if(obj3 != objtmp); 762 fail_if(obj3 != objtmp);
763 763
764 efl_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(efl_ref_get(obj3) != 1);
766 766
767 objtmp = efl_key_ref_get(obj, "test2"); 767 objtmp = efl_key_ref_get(obj, "test2");
768 fail_if(objtmp); 768 fail_if(objtmp);
@@ -771,7 +771,7 @@ START_TEST(eo_generic_data)
771 fail_if(obj2 != objtmp); 771 fail_if(obj2 != objtmp);
772 772
773 efl_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(efl_ref_get(obj2) != 1);
775 775
776 objtmp = efl_key_ref_get(obj, "test1"); 776 objtmp = efl_key_ref_get(obj, "test1");
777 fail_if(objtmp); 777 fail_if(objtmp);
@@ -790,8 +790,8 @@ START_TEST(eo_generic_data)
790 790
791 791
792 792
793 obj2 = eo_add(SIMPLE_CLASS, NULL); 793 obj2 = efl_add(SIMPLE_CLASS, NULL);
794 obj3 = eo_add(SIMPLE_CLASS, NULL); 794 obj3 = efl_add(SIMPLE_CLASS, NULL);
795 795
796 efl_key_wref_set(obj, "test1", obj2); 796 efl_key_wref_set(obj, "test1", obj2);
797 objtmp = efl_key_wref_get(obj, "test1"); 797 objtmp = efl_key_wref_get(obj, "test1");
@@ -802,10 +802,10 @@ START_TEST(eo_generic_data)
802 fail_if(objtmp); 802 fail_if(objtmp);
803 803
804 efl_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(efl_ref_get(obj2) != 1);
806 806
807 efl_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(efl_ref_get(obj3) != 1);
809 809
810 objtmp = efl_key_wref_get(obj, "test1"); 810 objtmp = efl_key_wref_get(obj, "test1");
811 fail_if(obj2 != objtmp); 811 fail_if(obj2 != objtmp);
@@ -817,7 +817,7 @@ START_TEST(eo_generic_data)
817 fail_if(obj3 != objtmp); 817 fail_if(obj3 != objtmp);
818 818
819 efl_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(efl_ref_get(obj3) != 1);
821 821
822 objtmp = efl_key_wref_get(obj, "test2"); 822 objtmp = efl_key_wref_get(obj, "test2");
823 fail_if(objtmp); 823 fail_if(objtmp);
@@ -826,7 +826,7 @@ START_TEST(eo_generic_data)
826 fail_if(obj2 != objtmp); 826 fail_if(obj2 != objtmp);
827 827
828 efl_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(efl_ref_get(obj2) != 1);
830 830
831 objtmp = efl_key_wref_get(obj, "test1"); 831 objtmp = efl_key_wref_get(obj, "test1");
832 fail_if(objtmp); 832 fail_if(objtmp);
@@ -858,11 +858,11 @@ START_TEST(eo_generic_data)
858 858
859 efl_key_value_set(obj, "value1", NULL); 859 efl_key_value_set(obj, "value1", NULL);
860 860
861 eo_unref(obj); 861 efl_unref(obj);
862 eo_unref(obj2); 862 efl_unref(obj2);
863 eo_unref(obj3); 863 efl_unref(obj3);
864 864
865 eo_shutdown(); 865 efl_object_shutdown();
866} 866}
867END_TEST 867END_TEST
868 868
@@ -871,11 +871,11 @@ START_TEST(eo_magic_checks)
871{ 871{
872 char _buf[sizeof(long)]; /* Just enough to hold eina magic + a bit more. */ 872 char _buf[sizeof(long)]; /* Just enough to hold eina magic + a bit more. */
873 char *buf = _buf; 873 char *buf = _buf;
874 eo_init(); 874 efl_object_init();
875 875
876 memset(_buf, 1, sizeof(_buf)); 876 memset(_buf, 1, sizeof(_buf));
877 877
878 Eo *obj = eo_add(SIMPLE_CLASS, (Eo *) buf); 878 Eo *obj = efl_add(SIMPLE_CLASS, (Eo *) buf);
879 fail_if(obj); 879 fail_if(obj);
880 880
881 while (1) 881 while (1)
@@ -885,50 +885,50 @@ 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((Efl_Class *) buf, NULL); 888 obj = efl_add((Efl_Class *) buf, NULL);
889 fail_if(obj); 889 fail_if(obj);
890 890
891 obj = eo_add(SIMPLE_CLASS, NULL); 891 obj = efl_add(SIMPLE_CLASS, NULL);
892 fail_if(!obj); 892 fail_if(!obj);
893 893
894 simple_a_set((Eo *) buf, ++i); 894 simple_a_set((Eo *) buf, ++i);
895 a = simple_a_get((Eo *) buf); 895 a = simple_a_get((Eo *) buf);
896 ck_assert_int_ne(i, a); 896 ck_assert_int_ne(i, a);
897 simple_a_set(eo_super((Eo *) buf, SIMPLE_CLASS), ++i); 897 simple_a_set(efl_super((Eo *) buf, SIMPLE_CLASS), ++i);
898 a = simple_a_get(eo_super((Eo *) buf, SIMPLE_CLASS)); 898 a = simple_a_get(efl_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 Efl_Class *) buf), ++i); 900 simple_a_set(efl_super(obj, (const Efl_Class *) buf), ++i);
901 a = simple_a_get(eo_super(obj, (const Efl_Class *) buf)); 901 a = simple_a_get(efl_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(efl_class_get((Eo *) buf));
904 fail_if(eo_class_name_get((Efl_Class*) buf)); 904 fail_if(efl_class_name_get((Efl_Class*) buf));
905 fail_if(eo_class_get(obj) != SIMPLE_CLASS); 905 fail_if(efl_class_get(obj) != SIMPLE_CLASS);
906 fail_if(eo_class_get(SIMPLE_CLASS) != EFL_CLASS_CLASS); 906 fail_if(efl_class_get(SIMPLE_CLASS) != EFL_CLASS_CLASS);
907 simple_a_set((Efl_Class *) buf, 1); 907 simple_a_set((Efl_Class *) buf, 1);
908 simple_a_set(eo_super((Efl_Class *) buf, SIMPLE_CLASS), ++i); 908 simple_a_set(efl_super((Efl_Class *) buf, SIMPLE_CLASS), ++i);
909 simple_a_set(eo_super(SIMPLE_CLASS, (Efl_Class *) buf), ++i); 909 simple_a_set(efl_super(SIMPLE_CLASS, (Efl_Class *) buf), ++i);
910 fail_if(eo_class_new(NULL, (Efl_Class *) buf), NULL); 910 fail_if(efl_class_new(NULL, (Efl_Class *) buf), NULL);
911 911
912 eo_xref(obj, (Eo *) buf); 912 efl_xref(obj, (Eo *) buf);
913 eo_xunref(obj, (Eo *) buf); 913 efl_xunref(obj, (Eo *) buf);
914 eo_xref((Eo *) buf, obj); 914 efl_xref((Eo *) buf, obj);
915 eo_xunref((Eo *) buf, obj); 915 efl_xunref((Eo *) buf, obj);
916 916
917 eo_ref((Eo *) buf); 917 efl_ref((Eo *) buf);
918 eo_unref((Eo *) buf); 918 efl_unref((Eo *) buf);
919 efl_del((Eo *) buf); 919 efl_del((Eo *) buf);
920 920
921 eo_isa((Eo *) buf, SIMPLE_CLASS); 921 efl_isa((Eo *) buf, SIMPLE_CLASS);
922 eo_isa(obj, (Efl_Class *) buf); 922 efl_isa(obj, (Efl_Class *) buf);
923 923
924 fail_if(0 != eo_ref_get((Eo *) buf)); 924 fail_if(0 != efl_ref_get((Eo *) buf));
925 925
926 efl_wref_add((Eo *) buf, &wref); 926 efl_wref_add((Eo *) buf, &wref);
927 parent = efl_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(efl_data_scope_get((Eo *) buf, SIMPLE_CLASS));
932 932
933 efl_composite_attach(obj, (Eo *) buf); 933 efl_composite_attach(obj, (Eo *) buf);
934 efl_composite_detach(obj, (Eo *) buf); 934 efl_composite_detach(obj, (Eo *) buf);
@@ -937,16 +937,16 @@ START_TEST(eo_magic_checks)
937 efl_event_callback_forwarder_add(obj, NULL, (Eo *) buf); 937 efl_event_callback_forwarder_add(obj, NULL, (Eo *) buf);
938 efl_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 efl_manual_free_set((Eo *) buf, EINA_TRUE);
941 eo_manual_free((Eo *) buf); 941 efl_manual_free((Eo *) buf);
942 eo_destructed_is((Eo *) buf); 942 efl_destructed_is((Eo *) buf);
943 943
944 obj2 = NULL; 944 obj2 = NULL;
945 efl_parent_set(obj, (Eo *) buf); 945 efl_parent_set(obj, (Eo *) buf);
946 obj2 = efl_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 efl_unref(obj);
950 950
951 if (!buf) 951 if (!buf)
952 break; 952 break;
@@ -954,7 +954,7 @@ START_TEST(eo_magic_checks)
954 buf = NULL; 954 buf = NULL;
955 } 955 }
956 956
957 eo_shutdown(); 957 efl_object_shutdown();
958} 958}
959END_TEST 959END_TEST
960 960
@@ -976,34 +976,34 @@ _class_hi_print(Efl_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
976 return EINA_TRUE; 976 return EINA_TRUE;
977} 977}
978 978
979EO_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE); 979EFL_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE);
980EO_FUNC_BODY_CONST(multi_class_hi_print, Eina_Bool, EINA_FALSE); 980EFL_FUNC_BODY_CONST(multi_class_hi_print, Eina_Bool, EINA_FALSE);
981 981
982static Efl_Op_Description _multi_do_op_descs[] = { 982static Efl_Op_Description _multi_do_op_descs[] = {
983 EO_OP_FUNC(multi_a_print, _a_print), 983 EFL_OBJECT_OP_FUNC(multi_a_print, _a_print),
984 EO_OP_FUNC(multi_class_hi_print, _class_hi_print), 984 EFL_OBJECT_OP_FUNC(multi_class_hi_print, _class_hi_print),
985}; 985};
986 986
987START_TEST(eo_multiple_do) 987START_TEST(eo_multiple_do)
988{ 988{
989 eo_init(); 989 efl_object_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 Efl_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 EFL_CLASS_TYPE_REGULAR,
996 EO_CLASS_DESCRIPTION_OPS(_multi_do_op_descs), 996 EFL_CLASS_DESCRIPTION_OPS(_multi_do_op_descs),
997 NULL, 997 NULL,
998 0, 998 0,
999 NULL, 999 NULL,
1000 NULL 1000 NULL
1001 }; 1001 };
1002 1002
1003 const Efl_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); 1003 const Efl_Class *klass = efl_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 = efl_add(klass, NULL);
1007 fail_if(!obj); 1007 fail_if(!obj);
1008 1008
1009 Eina_Bool ca, cb, cc; 1009 Eina_Bool ca, cb, cc;
@@ -1020,92 +1020,92 @@ START_TEST(eo_multiple_do)
1020 cc = multi_class_hi_print(klass); 1020 cc = multi_class_hi_print(klass);
1021 fail_if(!(ca && cb && cc)); 1021 fail_if(!(ca && cb && cc));
1022 1022
1023 eo_unref(obj); 1023 efl_unref(obj);
1024 1024
1025 eo_shutdown(); 1025 efl_object_shutdown();
1026} 1026}
1027END_TEST 1027END_TEST
1028 1028
1029START_TEST(eo_add_do_and_custom) 1029START_TEST(efl_add_do_and_custom)
1030{ 1030{
1031 Simple_Public_Data *pd = NULL; 1031 Simple_Public_Data *pd = NULL;
1032 Eo *obj = NULL; 1032 Eo *obj = NULL;
1033 eo_init(); 1033 efl_object_init();
1034 1034
1035 obj = eo_add(SIMPLE_CLASS, NULL, efl_constructor(eo_self)); 1035 obj = efl_add(SIMPLE_CLASS, NULL, efl_constructor(efl_self));
1036 fail_if(!obj); 1036 fail_if(!obj);
1037 eo_unref(obj); 1037 efl_unref(obj);
1038 1038
1039 obj = eo_add(SIMPLE_CLASS, NULL, simple_a_set(eo_self, 7)); 1039 obj = efl_add(SIMPLE_CLASS, NULL, simple_a_set(efl_self, 7));
1040 fail_if(!obj); 1040 fail_if(!obj);
1041 pd = eo_data_scope_get(obj, SIMPLE_CLASS); 1041 pd = efl_data_scope_get(obj, SIMPLE_CLASS);
1042 fail_if(pd->a != 7); 1042 fail_if(pd->a != 7);
1043 eo_unref(obj); 1043 efl_unref(obj);
1044 1044
1045 obj = eo_add(SIMPLE_CLASS, NULL, efl_constructor(eo_self), simple_a_set(eo_self, 7)); 1045 obj = efl_add(SIMPLE_CLASS, NULL, efl_constructor(efl_self), simple_a_set(efl_self, 7));
1046 fail_if(!obj); 1046 fail_if(!obj);
1047 pd = eo_data_scope_get(obj, SIMPLE_CLASS); 1047 pd = efl_data_scope_get(obj, SIMPLE_CLASS);
1048 fail_if(pd->a != 7); 1048 fail_if(pd->a != 7);
1049 eo_unref(obj); 1049 efl_unref(obj);
1050 1050
1051 Eina_Bool finalized; 1051 Eina_Bool finalized;
1052 obj = eo_add(SIMPLE_CLASS, NULL, finalized = efl_finalized_get(eo_self)); 1052 obj = efl_add(SIMPLE_CLASS, NULL, finalized = efl_finalized_get(efl_self));
1053 fail_if(finalized); 1053 fail_if(finalized);
1054 1054
1055 finalized = efl_finalized_get(obj); 1055 finalized = efl_finalized_get(obj);
1056 fail_if(!finalized); 1056 fail_if(!finalized);
1057 eo_unref(obj); 1057 efl_unref(obj);
1058 1058
1059 eo_shutdown(); 1059 efl_object_shutdown();
1060} 1060}
1061END_TEST 1061END_TEST
1062 1062
1063START_TEST(eo_pointers_indirection) 1063START_TEST(eo_pointers_indirection)
1064{ 1064{
1065#ifdef HAVE_EO_ID 1065#ifdef HAVE_EO_ID
1066 eo_init(); 1066 efl_object_init();
1067 1067
1068 static const Efl_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 EFL_CLASS_TYPE_REGULAR,
1072 EO_CLASS_DESCRIPTION_NOOPS(), 1072 EFL_CLASS_DESCRIPTION_NOOPS(),
1073 NULL, 1073 NULL,
1074 0, 1074 0,
1075 NULL, 1075 NULL,
1076 NULL 1076 NULL
1077 }; 1077 };
1078 1078
1079 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 1079 const Efl_Class *klass = efl_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 */
1083 Eo *obj = eo_add(klass, NULL); 1083 Eo *obj = efl_add(klass, NULL);
1084 fail_if(!obj); 1084 fail_if(!obj);
1085 fail_if(!eo_isa(obj, klass)); 1085 fail_if(!efl_isa(obj, klass));
1086 obj = (Eo *)((char *)(obj) + 1); 1086 obj = (Eo *)((char *)(obj) + 1);
1087 fail_if(eo_isa(obj, klass)); 1087 fail_if(efl_isa(obj, klass));
1088 obj = (Eo *)((char *)(obj) - 1); 1088 obj = (Eo *)((char *)(obj) - 1);
1089 fail_if(!eo_isa(obj, klass)); 1089 fail_if(!efl_isa(obj, klass));
1090 eo_unref(obj); 1090 efl_unref(obj);
1091 fail_if(eo_isa(obj, klass)); 1091 fail_if(efl_isa(obj, klass));
1092 1092
1093 /* Check id invalidity after deletion */ 1093 /* Check id invalidity after deletion */
1094 Eo *obj1 = eo_add(klass, NULL); 1094 Eo *obj1 = efl_add(klass, NULL);
1095 fail_if(!obj1); 1095 fail_if(!obj1);
1096 eo_unref(obj1); 1096 efl_unref(obj1);
1097 Eo *obj2 = eo_add(klass, NULL); 1097 Eo *obj2 = efl_add(klass, NULL);
1098 fail_if(!obj2); 1098 fail_if(!obj2);
1099 fail_if(!eo_isa(obj2, klass)); 1099 fail_if(!efl_isa(obj2, klass));
1100 fail_if(eo_isa(obj1, klass)); 1100 fail_if(efl_isa(obj1, klass));
1101 eo_unref(obj2); 1101 efl_unref(obj2);
1102 1102
1103 /* Check id sanity checks for "close enough" ids. */ 1103 /* Check id sanity checks for "close enough" ids. */
1104 obj1 = eo_add(klass, NULL); 1104 obj1 = efl_add(klass, NULL);
1105 fail_if(!obj1); 1105 fail_if(!obj1);
1106 obj2 = (Eo *) (((Eo_Id) obj1) & ~MASK_OBJ_TAG); 1106 obj2 = (Eo *) (((Eo_Id) obj1) & ~MASK_OBJ_TAG);
1107 fail_if(eo_class_get(obj2)); 1107 fail_if(efl_class_get(obj2));
1108 eo_unref(obj1); 1108 efl_unref(obj1);
1109 1109
1110#define NB_OBJS 10000 1110#define NB_OBJS 10000
1111 unsigned int obj_id; 1111 unsigned int obj_id;
@@ -1114,73 +1114,73 @@ START_TEST(eo_pointers_indirection)
1114 /* Creation of the objects */ 1114 /* Creation of the objects */
1115 for ( obj_id = 0; obj_id < NB_OBJS; obj_id++) 1115 for ( obj_id = 0; obj_id < NB_OBJS; obj_id++)
1116 { 1116 {
1117 objs[obj_id] = eo_add(klass, NULL); 1117 objs[obj_id] = efl_add(klass, NULL);
1118 if(!objs[obj_id]) 1118 if(!objs[obj_id])
1119 fail_if(!objs[obj_id]); 1119 fail_if(!objs[obj_id]);
1120 if(!eo_isa(objs[obj_id], klass)) 1120 if(!efl_isa(objs[obj_id], klass))
1121 fail_if(!eo_isa(objs[obj_id], klass)); 1121 fail_if(!efl_isa(objs[obj_id], klass));
1122 } 1122 }
1123 /* Deletion of a few objects */ 1123 /* Deletion of a few objects */
1124 for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000) 1124 for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000)
1125 { 1125 {
1126 eo_unref(objs[obj_id]); 1126 efl_unref(objs[obj_id]);
1127 if(eo_isa(objs[obj_id], klass)) 1127 if(efl_isa(objs[obj_id], klass))
1128 fail_if(eo_isa(objs[obj_id], klass)); 1128 fail_if(efl_isa(objs[obj_id], klass));
1129 } 1129 }
1130 /* Creation of the deleted objects */ 1130 /* Creation of the deleted objects */
1131 for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000) 1131 for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000)
1132 { 1132 {
1133 objs[obj_id] = eo_add(klass, NULL); 1133 objs[obj_id] = efl_add(klass, NULL);
1134 if(!objs[obj_id]) 1134 if(!objs[obj_id])
1135 fail_if(!objs[obj_id]); 1135 fail_if(!objs[obj_id]);
1136 if(!eo_isa(objs[obj_id], klass)) 1136 if(!efl_isa(objs[obj_id], klass))
1137 fail_if(!eo_isa(objs[obj_id], klass)); 1137 fail_if(!efl_isa(objs[obj_id], klass));
1138 } 1138 }
1139 /* Deletion of all the objects */ 1139 /* Deletion of all the objects */
1140 for ( obj_id = 0; obj_id < NB_OBJS; obj_id++) 1140 for ( obj_id = 0; obj_id < NB_OBJS; obj_id++)
1141 eo_unref(objs[obj_id]); 1141 efl_unref(objs[obj_id]);
1142 /* Just be sure that we trigger an already freed error */ 1142 /* Just be sure that we trigger an already freed error */
1143 eo_unref(objs[0]); 1143 efl_unref(objs[0]);
1144 free(objs); 1144 free(objs);
1145 1145
1146 eo_shutdown(); 1146 efl_object_shutdown();
1147#endif 1147#endif
1148} 1148}
1149END_TEST 1149END_TEST
1150 1150
1151 1151
1152static Eo * 1152static Eo *
1153_eo_add_failures_finalize(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED) 1153_efl_add_failures_finalize(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED)
1154{ 1154{
1155 return NULL; 1155 return NULL;
1156} 1156}
1157 1157
1158static Efl_Op_Description _eo_add_failures_op_descs[] = { 1158static Efl_Op_Description _efl_add_failures_op_descs[] = {
1159 EO_OP_FUNC_OVERRIDE(efl_finalize, _eo_add_failures_finalize), 1159 EFL_OBJECT_OP_FUNC_OVERRIDE(efl_finalize, _efl_add_failures_finalize),
1160}; 1160};
1161 1161
1162START_TEST(eo_add_failures) 1162START_TEST(efl_add_failures)
1163{ 1163{
1164 eo_init(); 1164 efl_object_init();
1165 1165
1166 static const Efl_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 EFL_CLASS_TYPE_REGULAR,
1170 EO_CLASS_DESCRIPTION_OPS(_eo_add_failures_op_descs), 1170 EFL_CLASS_DESCRIPTION_OPS(_efl_add_failures_op_descs),
1171 NULL, 1171 NULL,
1172 0, 1172 0,
1173 NULL, 1173 NULL,
1174 NULL 1174 NULL
1175 }; 1175 };
1176 1176
1177 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 1177 const Efl_Class *klass = efl_class_new(&class_desc, EO_CLASS, NULL);
1178 1178
1179 Eo *obj = eo_add(klass, NULL); 1179 Eo *obj = efl_add(klass, NULL);
1180 1180
1181 fail_if(obj); 1181 fail_if(obj);
1182 1182
1183 eo_shutdown(); 1183 efl_object_shutdown();
1184} 1184}
1185END_TEST 1185END_TEST
1186 1186
@@ -1192,60 +1192,60 @@ _del_intercept(Eo *obj)
1192{ 1192{
1193 intercepted = EINA_TRUE; 1193 intercepted = EINA_TRUE;
1194 efl_del_intercept_set(obj, NULL); 1194 efl_del_intercept_set(obj, NULL);
1195 eo_unref(obj); 1195 efl_unref(obj);
1196} 1196}
1197#endif 1197#endif
1198 1198
1199START_TEST(efl_del_intercept) 1199START_TEST(efl_del_intercept)
1200{ 1200{
1201#ifdef HAVE_EO_ID 1201#ifdef HAVE_EO_ID
1202 eo_init(); 1202 efl_object_init();
1203 1203
1204 static const Efl_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 EFL_CLASS_TYPE_REGULAR,
1208 EO_CLASS_DESCRIPTION_NOOPS(), 1208 EFL_CLASS_DESCRIPTION_NOOPS(),
1209 NULL, 1209 NULL,
1210 0, 1210 0,
1211 NULL, 1211 NULL,
1212 NULL 1212 NULL
1213 }; 1213 };
1214 1214
1215 const Efl_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); 1215 const Efl_Class *klass = efl_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 */
1219 intercepted = EINA_FALSE; 1219 intercepted = EINA_FALSE;
1220 Eo *obj = eo_add(klass, NULL); 1220 Eo *obj = efl_add(klass, NULL);
1221 fail_if(!obj); 1221 fail_if(!obj);
1222 fail_if(!eo_isa(obj, klass)); 1222 fail_if(!efl_isa(obj, klass));
1223 efl_del_intercept_set(obj, _del_intercept); 1223 efl_del_intercept_set(obj, _del_intercept);
1224 eo_unref(obj); 1224 efl_unref(obj);
1225 fail_if(!intercepted); 1225 fail_if(!intercepted);
1226 fail_if(eo_isa(obj, klass)); 1226 fail_if(efl_isa(obj, klass));
1227 1227
1228 /* Check del interception */ 1228 /* Check del interception */
1229 intercepted = EINA_FALSE; 1229 intercepted = EINA_FALSE;
1230 obj = eo_add(klass, NULL); 1230 obj = efl_add(klass, NULL);
1231 fail_if(!obj); 1231 fail_if(!obj);
1232 fail_if(!eo_isa(obj, klass)); 1232 fail_if(!efl_isa(obj, klass));
1233 efl_del_intercept_set(obj, _del_intercept); 1233 efl_del_intercept_set(obj, _del_intercept);
1234 efl_del(obj); 1234 efl_del(obj);
1235 fail_if(!intercepted); 1235 fail_if(!intercepted);
1236 fail_if(eo_isa(obj, klass)); 1236 fail_if(efl_isa(obj, klass));
1237 1237
1238 eo_shutdown(); 1238 efl_object_shutdown();
1239#endif 1239#endif
1240} 1240}
1241END_TEST 1241END_TEST
1242 1242
1243START_TEST(efl_name) 1243START_TEST(efl_name)
1244{ 1244{
1245 eo_init(); 1245 efl_object_init();
1246 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 1246 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
1247 Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); 1247 Eo *obj2 = efl_add(SIMPLE_CLASS, NULL);
1248 Eo *obj3 = eo_add(SIMPLE_CLASS, NULL); 1248 Eo *obj3 = efl_add(SIMPLE_CLASS, NULL);
1249 Eo *objtmp; 1249 Eo *objtmp;
1250 const char *id; 1250 const char *id;
1251 1251
@@ -1293,14 +1293,14 @@ START_TEST(efl_name)
1293 1293
1294 efl_del(obj); 1294 efl_del(obj);
1295 1295
1296 eo_shutdown(); 1296 efl_object_shutdown();
1297} 1297}
1298END_TEST 1298END_TEST
1299 1299
1300START_TEST(eo_comment) 1300START_TEST(eo_comment)
1301{ 1301{
1302 eo_init(); 1302 efl_object_init();
1303 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 1303 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
1304 const char *comment; 1304 const char *comment;
1305 1305
1306 comment = efl_comment_get(obj); 1306 comment = efl_comment_get(obj);
@@ -1323,16 +1323,16 @@ START_TEST(eo_comment)
1323 1323
1324 efl_del(obj); 1324 efl_del(obj);
1325 1325
1326 eo_shutdown(); 1326 efl_object_shutdown();
1327} 1327}
1328END_TEST 1328END_TEST
1329 1329
1330START_TEST(eo_rec_interface) 1330START_TEST(eo_rec_interface)
1331{ 1331{
1332 eo_init(); 1332 efl_object_init();
1333 Eo *s = eo_add(SEARCHABLE_CLASS, NULL); 1333 Eo *s = efl_add(SEARCHABLE_CLASS, NULL);
1334 Eo *obj = eo_add(SIMPLE_CLASS, s); 1334 Eo *obj = efl_add(SIMPLE_CLASS, s);
1335 Eo *obj2 = eo_add(SIMPLE_CLASS, obj); 1335 Eo *obj2 = efl_add(SIMPLE_CLASS, obj);
1336 Eo *objtmp; 1336 Eo *objtmp;
1337 1337
1338 objtmp = efl_provider_find(obj2, SEARCHABLE_CLASS); 1338 objtmp = efl_provider_find(obj2, SEARCHABLE_CLASS);
@@ -1340,7 +1340,7 @@ START_TEST(eo_rec_interface)
1340 1340
1341 efl_del(obj); 1341 efl_del(obj);
1342 1342
1343 eo_shutdown(); 1343 efl_object_shutdown();
1344} 1344}
1345END_TEST 1345END_TEST
1346 1346
@@ -1348,20 +1348,20 @@ void eo_test_general(TCase *tc)
1348{ 1348{
1349 tcase_add_test(tc, eo_simple); 1349 tcase_add_test(tc, eo_simple);
1350 tcase_add_test(tc, eo_singleton); 1350 tcase_add_test(tc, eo_singleton);
1351 tcase_add_test(tc, eo_override_tests); 1351 tcase_add_test(tc, efl_object_override_tests);
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, efl_data_fetch);
1354 tcase_add_test(tc, eo_isa_tests); 1354 tcase_add_test(tc, efl_isa_tests);
1355 tcase_add_test(tc, efl_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, efl_refs);
1358 tcase_add_test(tc, eo_weak_reference); 1358 tcase_add_test(tc, efl_weak_reference);
1359 tcase_add_test(tc, eo_generic_data); 1359 tcase_add_test(tc, eo_generic_data);
1360 tcase_add_test(tc, eo_magic_checks); 1360 tcase_add_test(tc, eo_magic_checks);
1361 tcase_add_test(tc, eo_multiple_do); 1361 tcase_add_test(tc, eo_multiple_do);
1362 tcase_add_test(tc, eo_add_do_and_custom); 1362 tcase_add_test(tc, efl_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, efl_add_failures);
1365 tcase_add_test(tc, efl_del_intercept); 1365 tcase_add_test(tc, efl_del_intercept);
1366 tcase_add_test(tc, efl_name); 1366 tcase_add_test(tc, efl_name);
1367 tcase_add_test(tc, eo_comment); 1367 tcase_add_test(tc, eo_comment);
diff --git a/src/tests/eo/suite/eo_test_init.c b/src/tests/eo/suite/eo_test_init.c
index ec123bf635..9bf0d9bada 100644
--- a/src/tests/eo/suite/eo_test_init.c
+++ b/src/tests/eo/suite/eo_test_init.c
@@ -9,10 +9,10 @@
9 9
10START_TEST(eo_test_simple) 10START_TEST(eo_test_simple)
11{ 11{
12 fail_if(!eo_init()); /* one init by test suite */ 12 fail_if(!efl_object_init()); /* one init by test suite */
13 fail_if(!eo_init()); 13 fail_if(!efl_object_init());
14 fail_if(!eo_shutdown()); 14 fail_if(!efl_object_shutdown());
15 fail_if(eo_shutdown()); 15 fail_if(efl_object_shutdown());
16} 16}
17END_TEST 17END_TEST
18 18
@@ -20,25 +20,25 @@ START_TEST(eo_test_init_shutdown)
20{ 20{
21 Eo *obj; 21 Eo *obj;
22 22
23 fail_if(!eo_init()); 23 fail_if(!efl_object_init());
24 ck_assert_str_eq("Efl_Object", eo_class_name_get(EFL_OBJECT_CLASS)); 24 ck_assert_str_eq("Efl_Object", efl_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 = efl_add(SIMPLE_CLASS, NULL);
28 simple_a_set(obj, 1); 28 simple_a_set(obj, 1);
29 ck_assert_int_eq(1, simple_a_get(obj)); 29 ck_assert_int_eq(1, simple_a_get(obj));
30 30
31 /* XXX-1: Essential for the next test to cache the op. */ 31 /* XXX-1: Essential for the next test to cache the op. */
32 ck_assert_int_eq(0xBEEF, simple2_class_beef_get(SIMPLE2_CLASS)); 32 ck_assert_int_eq(0xBEEF, simple2_class_beef_get(SIMPLE2_CLASS));
33 eo_unref(obj); 33 efl_unref(obj);
34 fail_if(eo_shutdown()); 34 fail_if(efl_object_shutdown());
35 35
36 fail_if(!eo_init()); 36 fail_if(!efl_object_init());
37 ck_assert_str_eq("Efl_Object", eo_class_name_get(EFL_OBJECT_CLASS)); 37 ck_assert_str_eq("Efl_Object", efl_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));
41 fail_if(eo_shutdown()); 41 fail_if(efl_object_shutdown());
42} 42}
43END_TEST 43END_TEST
44 44
diff --git a/src/tests/eo/suite/eo_test_threaded_calls.c b/src/tests/eo/suite/eo_test_threaded_calls.c
index ae83b0cad0..df840974cf 100644
--- a/src/tests/eo/suite/eo_test_threaded_calls.c
+++ b/src/tests/eo/suite/eo_test_threaded_calls.c
@@ -20,9 +20,9 @@ typedef struct
20#define THREAD_TEST_CLASS thread_test_class_get() 20#define THREAD_TEST_CLASS thread_test_class_get()
21const Efl_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); 23EFL_FUNC_BODY(thread_test_v_get, int, 0);
24EO_VOID_FUNC_BODY(thread_test_try_swap_stack); 24EFL_VOID_FUNC_BODY(thread_test_try_swap_stack);
25EO_VOID_FUNC_BODYV(thread_test_constructor, EO_FUNC_CALL(v), int v); 25EFL_VOID_FUNC_BODYV(thread_test_constructor, EFL_FUNC_CALL(v), int v);
26 26
27static int 27static int
28_v_get(Eo *obj EINA_UNUSED, void *class_data) 28_v_get(Eo *obj EINA_UNUSED, void *class_data)
@@ -61,23 +61,23 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, int v)
61} 61}
62 62
63static Efl_Op_Description op_descs[] = { 63static Efl_Op_Description op_descs[] = {
64 EO_OP_FUNC(thread_test_constructor, _constructor), 64 EFL_OBJECT_OP_FUNC(thread_test_constructor, _constructor),
65 EO_OP_FUNC(thread_test_v_get, _v_get), 65 EFL_OBJECT_OP_FUNC(thread_test_v_get, _v_get),
66 EO_OP_FUNC(thread_test_try_swap_stack, _try_swap_stack), 66 EFL_OBJECT_OP_FUNC(thread_test_try_swap_stack, _try_swap_stack),
67}; 67};
68 68
69static const Efl_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 EFL_CLASS_TYPE_REGULAR,
73 EO_CLASS_DESCRIPTION_OPS(op_descs), 73 EFL_CLASS_DESCRIPTION_OPS(op_descs),
74 NULL, 74 NULL,
75 sizeof(Thread_Test_Public_Data), 75 sizeof(Thread_Test_Public_Data),
76 NULL, 76 NULL,
77 NULL 77 NULL
78}; 78};
79 79
80EO_DEFINE_CLASS(thread_test_class_get, &class_desc, EO_CLASS, NULL) 80EFL_DEFINE_CLASS(thread_test_class_get, &class_desc, EO_CLASS, NULL)
81 81
82static void * 82static void *
83_thread_job(void *data, Eina_Thread t EINA_UNUSED) 83_thread_job(void *data, Eina_Thread t EINA_UNUSED)
@@ -94,14 +94,14 @@ _thread_job(void *data, Eina_Thread t EINA_UNUSED)
94 fail_if(EINA_LOCK_SUCCEED != eina_spinlock_take(&locks[0])); 94 fail_if(EINA_LOCK_SUCCEED != eina_spinlock_take(&locks[0]));
95 } 95 }
96 96
97 obj = eo_add(THREAD_TEST_CLASS, NULL, thread_test_constructor(eo_self, v)); 97 obj = efl_add(THREAD_TEST_CLASS, NULL, thread_test_constructor(efl_self, v));
98 98
99 thread_test_try_swap_stack(obj); 99 thread_test_try_swap_stack(obj);
100 v = thread_test_v_get(obj); 100 v = thread_test_v_get(obj);
101 101
102 fail_if(EINA_LOCK_SUCCEED != eina_spinlock_release(&locks[1])); 102 fail_if(EINA_LOCK_SUCCEED != eina_spinlock_release(&locks[1]));
103 103
104 eo_unref(obj); 104 efl_unref(obj);
105 105
106 return (void *) (uintptr_t) v; 106 return (void *) (uintptr_t) v;
107} 107}
@@ -110,7 +110,7 @@ START_TEST(eo_threaded_calls_test)
110{ 110{
111 Eina_Thread threads[2]; 111 Eina_Thread threads[2];
112 112
113 eo_init(); 113 efl_object_init();
114 114
115 fail_if(!eina_spinlock_new(&locks[0])); 115 fail_if(!eina_spinlock_new(&locks[0]));
116 fail_if(!eina_spinlock_new(&locks[1])); 116 fail_if(!eina_spinlock_new(&locks[1]));
@@ -128,7 +128,7 @@ START_TEST(eo_threaded_calls_test)
128 eina_barrier_free(&barrier); 128 eina_barrier_free(&barrier);
129 eina_barrier_free(&barrier0); 129 eina_barrier_free(&barrier0);
130 130
131 eo_shutdown(); 131 efl_object_shutdown();
132} 132}
133END_TEST 133END_TEST
134 134
diff --git a/src/tests/eo/suite/eo_test_value.c b/src/tests/eo/suite/eo_test_value.c
index 2649000610..7daaf60c47 100644
--- a/src/tests/eo/suite/eo_test_value.c
+++ b/src/tests/eo/suite/eo_test_value.c
@@ -11,22 +11,22 @@
11 11
12START_TEST(eo_value) 12START_TEST(eo_value)
13{ 13{
14 eo_init(); 14 efl_object_init();
15 char *str, *str2; 15 char *str, *str2;
16 16
17 Eina_Value val2, eo_val; 17 Eina_Value val2, eo_val;
18 void *tmpp = NULL; 18 void *tmpp = NULL;
19 Efl_Dbg_Info *eo_dbg_info; 19 Efl_Dbg_Info *eo_dbg_info;
20 Eo *obj = eo_add(SIMPLE_CLASS, NULL); 20 Eo *obj = efl_add(SIMPLE_CLASS, NULL);
21 21
22 eo_dbg_info = EO_DBG_INFO_LIST_APPEND(NULL, "Root"); 22 eo_dbg_info = EFL_DBG_INFO_LIST_APPEND(NULL, "Root");
23 efl_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);
27 ck_assert_str_eq(str, "[[8]]"); 27 ck_assert_str_eq(str, "[[8]]");
28 28
29 eina_value_setup(&val2, EO_DBG_INFO_TYPE); 29 eina_value_setup(&val2, EFL_DBG_INFO_TYPE);
30 eina_value_copy(&eo_dbg_info->value, &val2); 30 eina_value_copy(&eo_dbg_info->value, &val2);
31 str2 = eina_value_to_string(&val2); 31 str2 = eina_value_to_string(&val2);
32 ck_assert_str_eq(str, str2); 32 ck_assert_str_eq(str, str2);
@@ -42,10 +42,10 @@ START_TEST(eo_value)
42 42
43 free(str); 43 free(str);
44 free(str2); 44 free(str2);
45 eo_dbg_info_free(eo_dbg_info); 45 efl_dbg_info_free(eo_dbg_info);
46 eo_unref(obj); 46 efl_unref(obj);
47 47
48 eo_shutdown(); 48 efl_object_shutdown();
49} 49}
50END_TEST 50END_TEST
51 51