efl

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

5
#include <stdbool.h>
6

7
#include <Eina.h>
8
#include <Ecore.h>
9
#include <Eldbus_Model.h>
10

11
#include "eldbus_test_eldbus_model.h"
12
#include "eldbus_suite.h"
13

14
static Eo *dbus_object1 = NULL;
15
static Eo *dbus_proxy = NULL;
16

17
static Eina_Value
18
_leave(void *data EINA_UNUSED, const Eina_Value v,
19
       const Eina_Future *dead EINA_UNUSED)
20
{
21
   ecore_main_loop_quit();
22

23
   return v;
24
}
25

26
static void
27
_count_changed(void *data EINA_UNUSED, const Efl_Event *ev)
28
{
29
   Eina_Future *f;
30

31
   f = efl_loop_job(efl_provider_find(ev->object, EFL_LOOP_CLASS));
32
   eina_future_then(f, _leave, NULL, NULL);
33
}
34

35
static void
36
_setup(void)
37
{
38
   dbus_object1 = create_object();
39

40
   efl_event_callback_add(dbus_object1, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, _count_changed, NULL);
41
   efl_model_children_count_get(dbus_object1);
42

43
   ecore_main_loop_begin();
44

45
   dbus_proxy = eldbus_model_proxy_from_object_get(dbus_object1, ELDBUS_FDO_INTERFACE);
46
   ck_assert_ptr_ne(NULL, dbus_proxy);
47
}
48

49
static void
50
_teardown(void)
51
{
52
   efl_del(dbus_object1);
53
}
54

55
EFL_START_TEST(properties_get)
56
{
57
   Eina_Iterator *properties = NULL;
58
   // ELDBUS_FDO_INTERFACE have no properties
59
   properties = efl_model_properties_get(dbus_proxy);
60
   ck_assert_ptr_ne(NULL, properties);
61

62
   // FIXME: This test is failing since 2017/11/17. It doesn't seem to be
63
   // due to an EFL change, but a change in the DBus interface:
64
   // properties contains 2 properties, "Interfaces" and "Features".
65
   //ck_assert_int_eq(0, eina_array_count(properties));
66
   eina_iterator_free(properties);
67
}
68
EFL_END_TEST
69

70
EFL_START_TEST(property_get)
71
{
72
   // Nonexistent property must return ERROR
73
   Eina_Value *value;
74
   Eina_Error err = 0;
75

76
   value = efl_model_property_get(dbus_proxy, "nonexistent");
77

78
   fail_if(eina_value_type_get(value) != EINA_VALUE_TYPE_ERROR);
79
   eina_value_error_get(value, &err);
80
   fail_if(err != EFL_MODEL_ERROR_NOT_FOUND);
81

82
   eina_value_free(value);
83
}
84
EFL_END_TEST
85

86
EFL_START_TEST(property_set)
87
{
88
   Eina_Value value;
89
   Eina_Future *future;
90

91
   // Nonexistent property must return ERROR
92
   eina_value_setup(&value, EINA_VALUE_TYPE_INT);
93
   eina_value_set(&value, 1);
94
   future = efl_model_property_set(dbus_proxy, "nonexistent", &value);
95
   check_efl_model_future_error(future, &EFL_MODEL_ERROR_NOT_FOUND);
96
   eina_value_flush(&value);
97
}
98
EFL_END_TEST
99

100
static void
101
_test_dbus_proxy_children_count(Eo *efl_model)
102
{
103
   efl_event_callback_add(efl_model, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, _count_changed, NULL);
104
   efl_model_children_count_get(efl_model);
105

106
   ecore_main_loop_begin();
107

108
   // 'org.freedesktop.DBus::AddMatch' and 'org.freedesktop.DBus::ListNames' at least
109
   check_efl_model_children_count_ge(efl_model, 2);
110
}
111

112
EFL_START_TEST(children_count)
113
{
114
   _test_dbus_proxy_children_count(dbus_proxy);
115
}
116
EFL_END_TEST
117

118
EFL_START_TEST(children_slice_get)
119
{
120
   efl_event_callback_add(dbus_proxy, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, _count_changed, NULL);
121
   efl_model_children_count_get(dbus_proxy);
122

123
   ecore_main_loop_begin();
124

125
   check_efl_model_children_slice_get(dbus_proxy);
126
}
127
EFL_END_TEST
128

129
EFL_START_TEST(child_add)
130
{
131
   Eo *child;
132
   child = efl_model_child_add(dbus_proxy);
133
   ck_assert_ptr_eq(NULL, child);
134
}
135
EFL_END_TEST
136

137
#if 0
138
EFL_START_TEST(child_del)
139
{
140
   Eina_Future *future;
141
   Eo *child;
142
   unsigned int expected_children_count = 0;
143
   unsigned int actual_children_count = 0;
144

145
   expected_children_count = efl_model_children_count_get(dbus_proxy);
146
   ck_assert_ptr_ne(NULL, future);
147

148
   child = efl_model_first_child_get(dbus_proxy);
149
   efl_model_child_del(dbus_proxy, child);
150

151
   actual_children_count = efl_model_children_count_get(dbus_proxy);
152

153
   ck_assert_int_le(expected_children_count, actual_children_count);
154
}
155
EFL_END_TEST
156
#endif
157

158
void eldbus_test_eldbus_model_proxy(TCase *tc)
159
{
160
   tcase_add_checked_fixture(tc, _setup, _teardown);
161
   tcase_add_test(tc, properties_get);
162
   tcase_add_test(tc, property_get);
163
   tcase_add_test(tc, property_set);
164
   tcase_add_test(tc, children_count);
165
   tcase_add_test(tc, children_slice_get);
166
   tcase_add_test(tc, child_add);
167
   /* tcase_add_test(tc, child_del); */
168
}
169