efl

1
#ifdef HAVE_CONFIG_H
2
# include <config.h>
3
#endif
4

5
#include <stdbool.h>
6
#include <stdio.h>
7
#include <unistd.h>
8

9
#include <Eina.h>
10
#include <Ecore.h>
11
#include <Eldbus.h>
12
#include <Eldbus_Model.h>
13

14
#include "eldbus_test_eldbus_model.h"
15
#include "eldbus_suite.h"
16

17
static Eina_Value
18
_future_then_quit_u_cb(void *data,
19
                       const Eina_Value v,
20
                       const Eina_Future *dead_future EINA_UNUSED)
21
{
22
   unsigned *lhs = data;
23
   unsigned r = 0;
24

25
   eina_value_uint_get(&v, &r);
26

27
   *lhs = r;
28
   ecore_main_loop_quit();
29

30
   return v;
31
}
32

33
static Eina_Value
34
_future_then_cp(void *data ,
35
                const Eina_Value v,
36
                const Eina_Future *dead_future EINA_UNUSED)
37
{
38
   Eina_Value *value = data;
39

40
   eina_value_copy(&v, value);
41
   ecore_main_loop_quit();
42

43
   return v;
44
}
45

46

47
static Eina_Value
48
_future_check_err(void *data,
49
                  const Eina_Value v,
50
                  const Eina_Future *dead_future EINA_UNUSED)
51
{
52
   Eina_Error *expected_error = data;
53
   Eina_Error got = 0;
54

55
   fail_if(eina_value_type_get(&v) != EINA_VALUE_TYPE_ERROR);
56

57
   eina_value_error_get(&v, &got);
58

59
   if (expected_error)
60
     ck_assert_int_eq(got, *expected_error);
61

62
   ecore_main_loop_quit();
63

64
   return v;
65
}
66

67
static Eina_Value
68
_future_then_quit_cb(void* data,
69
                     const Eina_Value v,
70
                     const Eina_Future *dead_future EINA_UNUSED)
71
{
72
   Eina_Value **value = data;
73

74
   *value = eina_value_dup(&v);
75

76
   ecore_main_loop_quit();
77

78
   return v;
79
}
80

81
static void
82
_efl_event_quit_cb(void *data EINA_UNUSED, const Efl_Event *event EINA_UNUSED)
83
{
84
   ecore_main_loop_quit();
85
   efl_event_callback_stop(event->object);
86
}
87

88
Eina_Value *
89
efl_model_future_then(Eina_Future *future)
90
{
91
   Eina_Value *data = NULL;
92
   eina_future_then(future, &_future_then_quit_cb, &data, NULL);
93
   ecore_main_loop_begin();
94
   return data;
95
}
96

97
void
98
check_efl_model_future_error(Eina_Future *future, Eina_Error *err)
99
{
100
   eina_future_then(future, &_future_check_err, err, NULL);
101
   ecore_main_loop_begin();
102
}
103

104
int
105
efl_model_future_then_u(Eina_Future *future)
106
{
107
   unsigned i = -1;
108
   eina_future_then(future, &_future_then_quit_u_cb, &i, NULL);
109
   ecore_main_loop_begin();
110
   return i;
111
}
112

113
void
114
efl_model_wait_for_event(Eo *obj, const Efl_Event_Description* event)
115
{
116
   efl_event_callback_add(obj, event, _efl_event_quit_cb, NULL);
117
   ecore_main_loop_begin();
118
   efl_event_callback_del(obj, event, _efl_event_quit_cb, NULL);
119
}
120

121
Efl_Model *
122
efl_model_nth_child_get(Efl_Model *efl_model, unsigned int n)
123
{
124
   Eina_Future *future;
125
   Eina_Value *array;
126
   Eo *child = NULL;
127
   unsigned int len, i;
128

129
   future = efl_model_children_slice_get(efl_model, n, 1);
130

131
   array = efl_model_future_then(future);
132
   fail_if(eina_value_type_get(array) != EINA_VALUE_TYPE_ARRAY);
133

134
   EINA_VALUE_ARRAY_FOREACH(array, len, i, child)
135
     ;
136

137
   child = efl_ref(child);
138
   eina_value_free(array);
139

140
   fail_if(!child);
141

142
   return child;
143
}
144

145
Efl_Model *
146
efl_model_first_child_get(Efl_Model *efl_model)
147
{
148
   return efl_model_nth_child_get(efl_model, 0);
149
}
150

151
void
152
check_property(Eo *object, const char *property_name, const char *expected_value)
153
{
154
   Eina_Value *value;
155
   char *actual_value;
156

157
   value = efl_model_property_get(object, property_name);
158
   actual_value = eina_value_to_string(value);
159
   if (!actual_value)
160
     ck_assert_ptr_eq(expected_value, actual_value);
161
   else
162
     {
163
        bool is_property_equal = strcmp(expected_value, actual_value) == 0;
164
        ck_assert_msg(is_property_equal, "'%s' != '%s'", expected_value, actual_value);
165
        free(actual_value);
166
     }
167
   eina_value_free(value);
168
}
169

170
Eo *
171
create_connection(void)
172
{
173
   Eo *connection = efl_add(ELDBUS_MODEL_CONNECTION_CLASS, efl_main_loop_get(),
174
                            eldbus_model_connect(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE));
175
   ck_assert_ptr_ne(NULL, connection);
176
   return connection;
177
}
178

179
Eo *
180
create_object(void)
181
{
182
   Eo *object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(),
183
                        eldbus_model_connect(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE),
184
                        eldbus_model_object_bus_set(efl_added, ELDBUS_FDO_BUS),
185
                        eldbus_model_object_path_set(efl_added, ELDBUS_FDO_PATH));
186
   ck_assert_ptr_ne(NULL, object);
187
   return object;
188
}
189

190
void
191
check_efl_model_children_count_eq(Efl_Model *efl_model, unsigned int expected_children_count)
192
{
193
   unsigned int actual_children_count;
194

195
   actual_children_count = efl_model_children_count_get(efl_model);
196
   ck_assert_int_eq(expected_children_count, actual_children_count);
197
}
198

199
void
200
check_efl_model_children_count_ge(Efl_Model *efl_model, unsigned int minimum_children_count)
201
{
202
   unsigned int actual_children_count;
203

204
   actual_children_count = efl_model_children_count_get(efl_model);
205
   ck_assert_int_ge(actual_children_count, minimum_children_count);
206
}
207

208
void
209
check_efl_model_children_slice_get(Efl_Model *efl_model)
210
{
211
   unsigned count;
212
   Eina_Future *future;
213
   Eina_Value *array;
214
   Eo *first_child = NULL;
215
   Eo *last_child = NULL;
216
   Eo *nonexistent_child = NULL;
217
   Eo *child = NULL;
218

219
   count = efl_model_children_count_get(efl_model);
220
   ck_assert_msg((int)count > 0, "There must be at least 1 child to test");
221

222
   // Test slice all
223
   future = efl_model_children_slice_get(efl_model, 0, count);
224
   array = efl_model_future_then(future);
225
   ck_assert_ptr_ne(NULL, array);
226
   fail_if(eina_value_type_get(array) != EINA_VALUE_TYPE_ARRAY);
227

228
   // Get first child
229
   eina_value_array_get(array, 0, &first_child);
230
   ck_assert_ptr_ne(NULL, first_child);
231

232
   // get last child
233
   eina_value_array_get(array, count - 1, &last_child);
234
   ck_assert_ptr_ne(NULL, last_child);
235

236
   // Test nonexistent child
237
   eina_value_array_get(array, count, &nonexistent_child);
238
   ck_assert_ptr_eq(NULL, nonexistent_child);
239
   eina_value_free(array);
240

241
   // Test slice first child
242
   future = efl_model_children_slice_get(efl_model, 0, 1);
243
   array = efl_model_future_then(future);
244
   ck_assert_ptr_ne(NULL, array);
245
   eina_value_array_get(array, 0, &child);
246
   ck_assert_ptr_ne(NULL, child);
247
   eina_value_array_get(array, 1, &child);
248
   ck_assert_ptr_eq(first_child, child);
249
   eina_value_free(array);
250

251
   // Test slice last child
252
   future = efl_model_children_slice_get(efl_model, count - 1, 1);
253
   array = efl_model_future_then(future);
254
   ck_assert_ptr_ne(NULL, array);
255
   eina_value_array_get(array, 0, &child);
256
   ck_assert_ptr_ne(NULL, child);
257
   eina_value_array_get(array, 1, &child);
258
   ck_assert_ptr_eq(last_child, child);
259

260
   // Test slice nonexistent element
261
   future = efl_model_children_slice_get(efl_model, count, 1);
262
   ck_assert_ptr_ne(NULL, future);
263
   array = efl_model_future_then(future);
264
   fail_if(eina_value_type_get(array) != EINA_VALUE_TYPE_ERROR);
265
   eina_value_free(array);
266
}
267

268
EFL_START_TEST(smoke)
269
{
270
   Eo *connection = create_connection();
271
   efl_del(connection);
272
}
273
EFL_END_TEST
274

275
EFL_START_TEST(object)
276
{
277
   Eo *root = create_object();
278

279
   efl_del(root);
280

281
}
282
EFL_END_TEST
283

284
static Eina_Value
285
_leave(void *data EINA_UNUSED, const Eina_Value v,
286
       const Eina_Future *dead EINA_UNUSED)
287
{
288
   ecore_main_loop_quit();
289
   return v;
290
}
291
static void
292
_count_changed(void *data EINA_UNUSED, const Efl_Event *ev)
293
{
294
   Eina_Future *f;
295
   f = efl_loop_job(efl_provider_find(ev->object, EFL_LOOP_CLASS));
296
   eina_future_then(f, _leave, NULL, NULL);
297
}
298

299
static Eina_Future *
300
_async_slice_get(Efl_Model *model)
301
{
302
   efl_event_callback_add(model, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, _count_changed, NULL);
303
   if (!efl_model_children_count_get(model))
304
     ecore_main_loop_begin();
305

306
   efl_event_callback_del(model, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, _count_changed, NULL);
307

308
   return efl_model_children_slice_get(model, 0, efl_model_children_count_get(model));
309
}
310

311
EFL_START_TEST(proxy)
312
{
313
   Eina_Future *future = NULL;
314
   Eina_Value *array = NULL;
315
   Eo *proxy = NULL;
316
   Eo *root;
317
   unsigned int i, len;
318

319
   root = create_object();
320

321
   future = _async_slice_get(root);
322
   ck_assert_ptr_ne(NULL, future);
323

324
   array = efl_model_future_then(future);
325
   ck_assert_ptr_ne(NULL, array);
326

327
   EINA_VALUE_ARRAY_FOREACH(array, len, i, proxy)
328
     {
329
        ck_assert_ptr_ne(NULL, proxy);
330
        //efl_model_load_and_wait_for_load_status(proxy, EFL_MODEL_LOAD_STATUS_LOADED);
331
     }
332

333
   eina_value_free(array);
334

335
   efl_del(root);
336

337
}
338
EFL_END_TEST
339

340
void
341
eldbus_test_eldbus_model(TCase *tc)
342
{
343
   tcase_add_test(tc, smoke);
344
   tcase_add_test(tc, object);
345
   tcase_add_test(tc, proxy);
346
}
347

348
Eldbus_Model_Proxy *
349
eldbus_model_proxy_from_object_get(Eldbus_Model_Object *object, const char *interface_name)
350
{
351
   Eina_Future *future = NULL;
352
   Eo *proxy = NULL;
353
   Eina_Value *array;
354
   unsigned int len, i;
355

356
   future = _async_slice_get(object);
357
   array = efl_model_future_then(future);
358
   ck_assert_ptr_ne(NULL, array);
359

360
   EINA_VALUE_ARRAY_FOREACH(array, len, i, proxy)
361
     {
362
        const char *name;
363

364
        name = eldbus_model_proxy_name_get(proxy);
365
        ck_assert_ptr_ne(NULL, name);
366
        if (strcmp(name, interface_name) == 0)
367
          goto end;
368
     }
369
   proxy = NULL;
370

371
end:
372
   eina_value_free(array);
373
   return proxy;
374
}
375

376
static Eldbus_Model_Arguments *
377
_eldbus_model_arguments_from_proxy_get(Eldbus_Model_Proxy *proxy, const char *method_name, const Efl_Class *klass)
378
{
379
   Eina_Future *future = NULL;
380
   Eo *child = NULL;
381
   Eina_Value *array;
382
   unsigned int len, i;
383

384
   future = _async_slice_get(proxy);
385
   ck_assert_ptr_ne(NULL, future);
386
   array = efl_model_future_then(future);
387
   ck_assert_ptr_ne(NULL, array);
388

389
   EINA_VALUE_ARRAY_FOREACH(array, len, i, child)
390
     {
391
        const char *name;
392

393
        if (!efl_isa(child, klass))
394
          continue;
395

396
        name = eldbus_model_arguments_arg_name_get(child);
397
        ck_assert_ptr_ne(NULL, name);
398
        if (strcmp(name, method_name) == 0)
399
          goto end;
400
     }
401
   child = NULL;
402

403
end:
404
   eina_value_free(array);
405
   return child;
406
}
407

408
Eldbus_Model_Method *
409
eldbus_model_method_from_proxy_get(Eldbus_Model_Proxy *proxy, const char *method_name)
410
{
411
   return _eldbus_model_arguments_from_proxy_get(proxy, method_name, ELDBUS_MODEL_METHOD_CLASS);
412
}
413

414
Eldbus_Model_Signal *
415
eldbus_model_signal_from_proxy_get(Eldbus_Model_Proxy *proxy, const char *signal_name)
416
{
417
   return _eldbus_model_arguments_from_proxy_get(proxy, signal_name, ELDBUS_MODEL_SIGNAL_CLASS);
418
}
419

420
void
421
check_efl_model_property_int_eq(Efl_Model *efl_model, const char *property, int expected_value)
422
{
423
   const Eina_Value_Type *property_type;
424
   Eina_Value *property_value;
425
   int actual_value = 0;
426

427
   property_value = efl_model_property_get(efl_model, property);
428
   property_type = eina_value_type_get(property_value);
429
   ck_assert_ptr_eq(EINA_VALUE_TYPE_INT, property_type);
430

431
   eina_value_get(property_value, &actual_value);
432
   ck_assert_int_eq(expected_value, actual_value);
433
   eina_value_free(property_value);
434
}
435

436
void
437
check_efl_model_property_int_set(Efl_Model *efl_model, const char *property, int value)
438
{
439
   Eina_Value eina_value = EINA_VALUE_EMPTY, value_ret = EINA_VALUE_EMPTY;
440
   Eina_Future *future;
441
   const Eina_Value_Type *property_type;
442

443
   eina_value_setup(&eina_value, EINA_VALUE_TYPE_INT);
444
   eina_value_set(&eina_value, value);
445
   future = efl_model_property_set(efl_model, property, &eina_value);
446

447
   eina_future_then(future, &_future_then_cp, &value_ret, NULL);
448
   ecore_main_loop_begin();
449

450
   property_type = eina_value_type_get(&value_ret);
451
   ck_assert_ptr_eq(EINA_VALUE_TYPE_INT, property_type);
452

453
   int actual_value;
454
   eina_value_get(&value_ret, &actual_value);
455
   ck_assert_int_eq(value, actual_value);
456
   eina_value_flush(&eina_value);
457
   eina_value_flush(&value_ret);
458
}
459