efl

1
#ifdef HAVE_CONFIG_H
2
# include "elementary_config.h"
3
#endif
4

5

6
#define EFL_ACCESS_OBJECT_BETA
7
#define EFL_ACCESS_OBJECT_PROTECTED
8

9
#include <Efl_Ui.h>
10
#include <Elementary.h>
11
#include "elm_priv.h"
12
#include "efl_ui_suite.h"
13

14
static Evas_Object *g_win, *g_btn, *g_bg;
15

16
void generate_app(void)
17
{
18
   g_win = win_add(NULL, "Title", ELM_WIN_BASIC);
19
   efl_gfx_entity_position_set(g_win, EINA_POSITION2D(100, 100));
20
   efl_gfx_entity_size_set(g_win, EINA_SIZE2D(100, 100));
21

22
   g_bg = efl_add(EFL_UI_BG_CLASS, g_win);
23

24
   g_btn = efl_add(EFL_UI_BUTTON_CLASS, g_win);
25

26
   efl_gfx_entity_visible_set(g_btn, EINA_TRUE);
27
   efl_gfx_entity_visible_set(g_bg, EINA_TRUE);
28
   efl_gfx_entity_visible_set(g_win, EINA_TRUE);
29
}
30

31
EFL_START_TEST(test_efl_access_app_obj_name_get)
32
{
33
   Eo* root = efl_add_ref(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
34

35
   ck_assert(root != NULL);
36

37
   const char *ret = NULL;
38

39
   elm_app_name_set("Test name");
40

41
   ret = efl_access_object_i18n_name_get(root);
42

43
   ck_assert_str_eq(ret, "Test name");
44

45
   efl_unref(root);
46
}
47
EFL_END_TEST
48

49
EFL_START_TEST(test_efl_access_object_i18n_name_get)
50
{
51
   generate_app();
52

53
   const char *name;
54

55
   name = efl_access_object_i18n_name_get(g_btn);
56

57
   if (name && name[0]) {
58
      ck_assert(0);
59
   }
60

61
   // Set name with additional text tags
62
   efl_text_set(g_btn, "Some<br>text");
63

64
   name = efl_access_object_i18n_name_get(g_btn);
65

66
   // Accessible name should have cleared tags
67
   ck_assert(name != NULL);
68
   ck_assert_str_eq(name, "Some\ntext");
69

70
}
71
EFL_END_TEST
72

73
EFL_START_TEST(test_efl_access_object_i18n_name_set)
74
{
75
   generate_app();
76

77
   const char *name;
78

79
   efl_text_set(g_btn, "Other text");
80
   efl_access_object_i18n_name_set(g_btn, "Test name");
81

82
   name = efl_access_object_i18n_name_get(g_btn);
83

84
   ck_assert(name != NULL);
85
   ck_assert_str_eq(name, "Test name");
86

87
   efl_access_object_i18n_name_set(g_btn, NULL);
88
   name = efl_access_object_i18n_name_get(g_btn);
89

90
   ck_assert(name != NULL);
91
   ck_assert_str_eq(name, "Other text");
92

93
}
94
EFL_END_TEST
95

96
EFL_START_TEST(test_efl_access_object_role_get)
97
{
98
   Eo* root = efl_add_ref(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
99

100
   Efl_Access_Role role;
101

102
   role = efl_access_object_role_get(root);
103

104
   ck_assert(role == EFL_ACCESS_ROLE_APPLICATION);
105

106
   efl_unref(root);
107
}
108
EFL_END_TEST
109

110
EFL_START_TEST(test_efl_access_object_role_set)
111
{
112
   generate_app();
113
   Efl_Access_Role role;
114

115
   efl_access_object_role_set(g_btn, EFL_ACCESS_ROLE_ACCELERATOR_LABEL);
116
   role = efl_access_object_role_get(g_btn);
117

118
   if (role != EFL_ACCESS_ROLE_ACCELERATOR_LABEL)
119
      ck_assert(0);
120

121
   efl_access_object_role_set(g_btn, EFL_ACCESS_ROLE_ENTRY);
122
   role = efl_access_object_role_get(g_btn);
123

124
   if (role != EFL_ACCESS_ROLE_ENTRY)
125
      ck_assert(0);
126

127
}
128
EFL_END_TEST
129

130
EFL_START_TEST(test_efl_access_object_role_name_get)
131
{
132
   Eo* root = efl_add_ref(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
133

134
   const char *ret = NULL;
135

136
   ret = efl_access_object_role_name_get(root);
137

138
   ck_assert(ret != NULL);
139

140
   efl_unref(root);
141
}
142
EFL_END_TEST
143

144
EFL_START_TEST(test_efl_access_object_localized_role_name_get)
145
{
146
   Eo* root = efl_add_ref(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
147

148
   const char *ret = NULL;
149

150
   ret = efl_access_object_localized_role_name_get(root);
151

152
   ck_assert(ret != NULL);
153

154
   efl_unref(root);
155
}
156
EFL_END_TEST
157

158
EFL_START_TEST(test_efl_access_object_description_set)
159
{
160
   Eo* root = efl_add_ref(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
161

162
   const char *ret = NULL;
163

164
   const char *desc = "Test description";
165

166
   ret = efl_access_object_description_get(root);
167

168
   ck_assert(ret == NULL);
169

170
   efl_access_object_description_set(root, desc);
171
   ret = efl_access_object_description_get(root);
172

173
   ck_assert(ret != NULL);
174
   ck_assert_str_eq(ret, "Test description");
175

176
   efl_access_object_description_set(root, NULL);
177
   ret = efl_access_object_description_get(root);
178

179
   ck_assert(ret == NULL);
180

181
   efl_unref(root);
182
}
183
EFL_END_TEST
184

185
/* Test if initial description value is NULL */
186
EFL_START_TEST(test_efl_access_object_description_get)
187
{
188
   generate_app();
189

190
   const char *descr;
191
   descr = efl_access_object_description_get(g_bg);
192

193
   ck_assert(descr == NULL);
194

195
}
196
EFL_END_TEST
197

198
EFL_START_TEST(test_efl_access_children_and_parent)
199
{
200
   generate_app();
201
   Eo* root = efl_add_ref(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
202

203
   Eina_List *child_list = NULL;
204

205
   child_list = efl_access_object_access_children_get(root);
206

207
   //bg_child_list = efl_access_object_access_children_get(eina_list_nth(child_list, 0));
208

209
   ck_assert_int_eq(eina_list_count(child_list), 1);
210

211
   Eo *win = NULL;
212

213
   win = eina_list_nth(child_list, 0);
214

215
   ck_assert_ptr_ne(win, NULL);
216
   ck_assert_ptr_eq(win, g_win);
217

218
   efl_unref(root);
219
}
220
EFL_END_TEST
221

222
EFL_START_TEST(test_efl_access_children_and_parent2)
223
{
224
   generate_app();
225
   Eo* root = efl_add_ref(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
226

227
   Eo *win = NULL;
228

229
   Eina_List *root_children;
230
   root_children = efl_access_object_access_children_get(root);
231
   win = eina_list_nth(root_children, 0);
232

233
   Eina_List *win_children;
234
   win_children = efl_access_object_access_children_get(win);
235

236
   ck_assert(eina_list_count(win_children) == 1);
237

238
   Eo *btn = NULL;
239

240
   btn = eina_list_nth(win_children, 0);
241
   ck_assert(btn != NULL);
242
   ck_assert(btn == g_btn);
243

244
   efl_unref(root);
245
}
246
EFL_END_TEST
247

248
/* Initial value of translation domain should be NULL */
249
EFL_START_TEST(test_efl_access_object_translation_domain_get)
250
{
251
   generate_app();
252

253
   const char *domain;
254

255
   domain = efl_access_object_translation_domain_get(g_btn);
256

257
   ck_assert(domain == NULL);
258

259
}
260
EFL_END_TEST
261

262
EFL_START_TEST(test_efl_access_object_translation_domain_set)
263
{
264
   generate_app();
265

266
   const char *domain;
267

268
   efl_access_object_translation_domain_set(g_btn, "Test translation_domain");
269
   domain = efl_access_object_translation_domain_get(g_btn);
270

271
   ck_assert(domain != NULL);
272
   ck_assert_str_eq(domain, "Test translation_domain");
273

274
   efl_access_object_translation_domain_set(g_btn, NULL);
275
   domain = efl_access_object_translation_domain_get(g_btn);
276

277
   ck_assert(domain == NULL);
278

279
}
280
EFL_END_TEST
281

282
EFL_START_TEST(test_efl_access_object_relationship_append)
283
{
284
   generate_app();
285

286
   Efl_Access_Relation *rel, *rel_to, *rel_from;
287
   Eina_Iterator *it;
288
   unsigned int i = 0;
289

290
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_bg);
291
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_FROM, g_win);
292
   it = efl_access_object_relations_get(g_btn);
293

294
   ck_assert(it != NULL);
295

296
   rel_to = rel_from = NULL;
297
   EINA_ITERATOR_FOREACH(it, rel)
298
   {
299
      i++;
300

301
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_TO)
302
        rel_to = rel;
303
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_FROM)
304
        rel_from = rel;
305
   }
306

307
   ck_assert(i >= 2);
308
   ck_assert(rel_to != NULL);
309
   ck_assert(eina_list_data_find(rel_to->objects, g_bg) != NULL);
310

311
   ck_assert(rel_from != NULL);
312
   ck_assert(eina_list_data_find(rel_from->objects, g_win) != NULL);
313

314
   eina_iterator_free(it);
315

316
   /* Check if append do not procude duplicated relations */
317
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_bg);
318
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_FROM, g_win);
319
   it = efl_access_object_relations_get(g_btn); i = 0;
320

321
   rel_to = rel_from = NULL;
322
   EINA_ITERATOR_FOREACH(it, rel)
323
   {
324
      i++;
325

326
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_TO)
327
        rel_to = rel;
328
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_FROM)
329
        rel_from = rel;
330
   }
331

332
   ck_assert(rel_to != NULL);
333
   ck_assert(rel_to->objects != NULL);
334
   rel_to->objects = eina_list_remove(rel_to->objects, g_bg);
335
   ck_assert(eina_list_data_find(rel_to->objects, g_bg) == NULL);
336

337
   ck_assert(rel_from != NULL);
338
   ck_assert(rel_from->objects != NULL);
339
   rel_from->objects = eina_list_remove(rel_from->objects, g_win);
340
   ck_assert(eina_list_data_find(rel_from->objects, g_win) == NULL);
341

342
   eina_iterator_free(it);
343
}
344
EFL_END_TEST
345

346
EFL_START_TEST(test_efl_access_object_relationship_remove)
347
{
348
   generate_app();
349

350
   Efl_Access_Relation *rel, *rel_to, *rel_from;
351
   Eina_Iterator *it;
352
   unsigned int i = 0;
353

354
   /* Test if removal of single relationship works */
355
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_bg);
356
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_FROM, g_win);
357
   efl_access_object_relationship_remove(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_bg);
358
   it = efl_access_object_relations_get(g_btn);
359

360
   ck_assert(it != NULL);
361

362
   rel_to = rel_from = NULL;
363
   EINA_ITERATOR_FOREACH(it, rel)
364
   {
365
      i++;
366

367
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_TO)
368
        rel_to = rel;
369
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_FROM)
370
        rel_from = rel;
371
   }
372

373
   ck_assert(i >= 1);
374

375
   if (rel_to) ck_assert(eina_list_data_find(rel_to->objects, g_bg) == NULL);
376
   ck_assert(rel_from != NULL);
377
   ck_assert(eina_list_data_find(rel_from->objects, g_win) != NULL);
378

379
   eina_iterator_free(it);
380

381
   /* Test if removal of type relationship works */
382
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_bg);
383
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_win);
384
   efl_access_object_relationship_remove(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, NULL);
385
   it = efl_access_object_relations_get(g_btn); i = 0;
386

387
   rel_to = rel_from = NULL;
388
   EINA_ITERATOR_FOREACH(it, rel)
389
   {
390
      i++;
391

392
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_TO)
393
        rel_to = rel;
394
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_FROM)
395
        rel_from = rel;
396
   }
397

398
   ck_assert(rel_to == NULL);
399
   ck_assert(rel_from != NULL);
400
   ck_assert(eina_list_data_find(rel_from->objects, g_win) != NULL);
401

402
   eina_iterator_free(it);
403

404
   /* Test if relationship is implicity removed when object is deleted */
405
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_bg);
406
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_FROM, g_bg);
407
   efl_del(g_bg);
408
   it = efl_access_object_relations_get(g_btn); i = 0;
409

410
   rel_to = rel_from = NULL;
411
   EINA_ITERATOR_FOREACH(it, rel)
412
   {
413
      i++;
414

415
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_TO)
416
        rel_to = rel;
417
      if (rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_FROM)
418
        rel_from = rel;
419
   }
420

421
   if (rel_to) ck_assert(eina_list_data_find(rel_to->objects, g_bg) == NULL);
422
   if (rel_from) ck_assert(eina_list_data_find(rel_from->objects, g_bg) == NULL);
423

424
   eina_iterator_free(it);
425
}
426
EFL_END_TEST
427

428
EFL_START_TEST(test_efl_access_object_relationships_clear)
429
{
430
   Efl_Access_Relation *rel;
431
   Eina_Iterator *it;
432

433
   generate_app();
434

435
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_bg);
436
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_FROM, g_bg);
437
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_TO, g_win);
438
   efl_access_object_relationship_append(g_btn, EFL_ACCESS_RELATION_TYPE_FLOWS_FROM, g_win);
439

440
   efl_access_object_relationships_clear(g_btn);
441

442
   it = efl_access_object_relations_get(g_btn);
443
   EINA_ITERATOR_FOREACH(it, rel)
444
   {
445
      ck_assert(!((rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_TO) && eina_list_data_find(rel->objects, g_bg)));
446
      ck_assert(!((rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_FROM) && eina_list_data_find(rel->objects, g_bg)));
447
      ck_assert(!((rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_TO) && eina_list_data_find(rel->objects, g_win)));
448
      ck_assert(!((rel->type == EFL_ACCESS_RELATION_TYPE_FLOWS_FROM) && eina_list_data_find(rel->objects, g_win)));
449
   }
450
   eina_iterator_free(it);
451
}
452
EFL_END_TEST
453

454
EFL_START_TEST(test_efl_access_object_attribute_append)
455
{
456
   Eina_List *attr_list = NULL, *l = NULL;
457
   Efl_Access_Attribute *attr = NULL;
458
   generate_app();
459
   efl_access_object_attribute_append(g_btn, "color1", "red");
460
   efl_access_object_attribute_append(g_btn, "color2", "blue");
461
   efl_access_object_attribute_append(g_btn, "color3", "green");
462
   attr_list = efl_access_object_attributes_get(g_btn);
463

464
   ck_assert(attr_list != NULL);
465
   EINA_LIST_FOREACH(attr_list, l, attr)
466
     {
467
        if (!strcmp(attr->key, "color1"))
468
          ck_assert_str_eq(attr->value, "red");
469
        else if (!strcmp(attr->key, "color2"))
470
          ck_assert_str_eq(attr->value, "blue");
471
        else if (!strcmp(attr->key, "color3"))
472
          ck_assert_str_eq(attr->value, "green");
473
     }
474
   EINA_LIST_FREE(attr_list, attr)
475
     {
476
        eina_stringshare_del(attr->key);
477
        eina_stringshare_del(attr->value);
478
        free(attr);
479
     }
480
}
481
EFL_END_TEST
482

483
EFL_START_TEST(test_efl_access_object_attributes_get)
484
{
485
   Eina_List *attr_list = NULL, *l = NULL;
486
   Efl_Access_Attribute *attr = NULL;
487
   generate_app();
488
   efl_access_object_attribute_append(g_btn, "color1", "red");
489
   efl_access_object_attribute_append(g_btn, "color2", "blue");
490
   efl_access_object_attribute_append(g_btn, "color3", "green");
491
   attr_list = efl_access_object_attributes_get(g_btn);
492

493
   ck_assert(attr_list != NULL);
494
   EINA_LIST_FOREACH(attr_list, l, attr)
495
     {
496
        if (!strcmp(attr->key, "color1"))
497
          ck_assert_str_eq(attr->value, "red");
498
        else if (!strcmp(attr->key, "color2"))
499
          ck_assert_str_eq(attr->value, "blue");
500
        else if (!strcmp(attr->key, "color3"))
501
          ck_assert_str_eq(attr->value, "green");
502
     }
503
   EINA_LIST_FREE(attr_list, attr)
504
     {
505
        eina_stringshare_del(attr->key);
506
        eina_stringshare_del(attr->value);
507
        free(attr);
508
     }
509
}
510
EFL_END_TEST
511

512
EFL_START_TEST(test_efl_access_object_attribute_del)
513
{
514
   Eina_List *attr_list = NULL;
515
   Efl_Access_Attribute *attr = NULL;
516
   int count1 = 0;
517
   int count2 = 0;
518
   generate_app();
519
   efl_access_object_attribute_append(g_btn, "color1", "red");
520
   efl_access_object_attribute_append(g_btn, "color2", "blue");
521
   efl_access_object_attribute_append(g_btn, "color3", "green");
522
   attr_list = efl_access_object_attributes_get(g_btn);//default attributes are added again
523
   ck_assert(attr_list != NULL);
524
   count1 = eina_list_count(attr_list);
525
   EINA_LIST_FREE(attr_list, attr)
526
     {
527
        eina_stringshare_del(attr->key);
528
        eina_stringshare_del(attr->value);
529
        free(attr);
530
     }
531
   attr_list = NULL;
532
   efl_access_object_attribute_del(g_btn, "color4");//non existent key deletion
533
   efl_access_object_attribute_del(g_btn, "color3");//existing key deletion
534
   attr_list = efl_access_object_attributes_get(g_btn);
535
   ck_assert(attr_list != NULL);
536
   count2 = eina_list_count(attr_list);
537
   ck_assert(count1 == (count2+1));
538
   EINA_LIST_FREE(attr_list, attr)
539
     {
540
        eina_stringshare_del(attr->key);
541
        eina_stringshare_del(attr->value);
542
        free(attr);
543
     }
544
}
545
EFL_END_TEST
546

547
EFL_START_TEST(test_efl_access_object_attributes_clear)
548
{
549
   Eina_List *attr_list = NULL;
550
   Efl_Access_Attribute *attr = NULL;
551
   generate_app();
552
   efl_access_object_attribute_append(g_btn, "color1", "red");
553
   efl_access_object_attribute_append(g_btn, "color2", "blue");
554
   efl_access_object_attribute_append(g_btn, "color3", "green");
555
   efl_access_object_attributes_clear(g_btn);
556
   attr_list = efl_access_object_attributes_get(g_btn);//default attributes are added again
557
   ck_assert(attr_list != NULL);
558
   ck_assert(eina_list_count(attr_list) <= 2);
559
   EINA_LIST_FREE(attr_list, attr)
560
     {
561
        eina_stringshare_del(attr->key);
562
        eina_stringshare_del(attr->value);
563
        free(attr);
564
     }
565
}
566
EFL_END_TEST
567

568
EFL_START_TEST(test_efl_access_object_reading_info_type_set)
569
{
570
   Efl_Access_Reading_Info_Type reading_info;
571
   generate_app();
572
   efl_access_object_reading_info_type_set(g_btn, EFL_ACCESS_READING_INFO_TYPE_NAME|
573
                                           EFL_ACCESS_READING_INFO_TYPE_ROLE);
574
   reading_info = efl_access_object_reading_info_type_get(g_btn);
575
   ck_assert(reading_info & EFL_ACCESS_READING_INFO_TYPE_NAME);
576
   ck_assert(reading_info & EFL_ACCESS_READING_INFO_TYPE_ROLE);
577
}
578
EFL_END_TEST
579

580
EFL_START_TEST(test_efl_access_object_reading_info_type_get)
581
{
582
   Efl_Access_Reading_Info_Type reading_info;
583
   generate_app();
584
   reading_info = efl_access_object_reading_info_type_get(g_btn);
585
   ck_assert(reading_info == 0);
586
}
587
EFL_END_TEST
588

589
void efl_ui_test_atspi(TCase *tc)
590
{
591
   tcase_add_test(tc, test_efl_access_app_obj_name_get);
592
   tcase_add_test(tc, test_efl_access_object_i18n_name_get);
593
   tcase_add_test(tc, test_efl_access_object_i18n_name_set);
594
   tcase_add_test(tc, test_efl_access_object_role_get);
595
   tcase_add_test(tc, test_efl_access_object_role_set);
596
   tcase_add_test(tc, test_efl_access_object_role_name_get);
597
   tcase_add_test(tc, test_efl_access_object_localized_role_name_get);
598
   tcase_add_test(tc, test_efl_access_object_description_set);
599
   tcase_add_test(tc, test_efl_access_object_description_get);
600
   tcase_add_test(tc, test_efl_access_children_and_parent);
601
   tcase_add_test(tc, test_efl_access_children_and_parent2);
602
   tcase_add_test(tc, test_efl_access_object_translation_domain_get);
603
   tcase_add_test(tc, test_efl_access_object_translation_domain_set);
604
   tcase_add_test(tc, test_efl_access_object_relationship_append);
605
   tcase_add_test(tc, test_efl_access_object_relationship_remove);
606
   tcase_add_test(tc, test_efl_access_object_relationships_clear);
607
   tcase_add_test(tc, test_efl_access_object_attribute_append);
608
   tcase_add_test(tc, test_efl_access_object_attributes_get);
609
   tcase_add_test(tc, test_efl_access_object_attribute_del);
610
   tcase_add_test(tc, test_efl_access_object_attributes_clear);
611
   tcase_add_test(tc, test_efl_access_object_reading_info_type_set);
612
   tcase_add_test(tc, test_efl_access_object_reading_info_type_get);
613
}
614