efl

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

5
#include <stdbool.h>
6
#include <libgen.h> /* basename() */
7

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

12
#include "eldbus_fake_server.h"
13
#include "eldbus_test_eldbus_model.h"
14
#include "eldbus_suite.h"
15

16
#define ARGUMENT_A "arg0"
17
#define ARGUMENT_B "arg1"
18
#define ARGUMENT_RESULT "arg2"
19

20
static Eo *fake_server_object = NULL;
21
static Eo *fake_server_proxy = NULL;
22
static Eldbus_Service_Interface *fake_server = NULL;
23
static Fake_Server_Data fake_server_data = {0};
24
static Eo *method = NULL;
25

26
static void
27
_setup(void)
28
{
29
   char buf[1024];
30
   snprintf(buf, sizeof(buf), FAKE_SERVER_BUS ".%s", basename(__FILE__));
31
   fake_server = fake_server_start(&fake_server_data, buf);
32

33
   fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(),
34
                                eldbus_model_connect(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE),
35
                                eldbus_model_object_bus_set(efl_added, buf),
36
                                eldbus_model_object_path_set(efl_added, FAKE_SERVER_PATH));
37
   ck_assert_ptr_ne(NULL, fake_server_object);
38

39
   fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);
40
   ck_assert_ptr_ne(NULL, fake_server_proxy);
41

42
   method = eldbus_model_method_from_proxy_get(fake_server_proxy, FAKE_SERVER_SUM_METHOD_NAME);
43
   ck_assert_ptr_ne(NULL, method);
44
}
45

46
static void
47
_teardown(void)
48
{
49
   efl_del(fake_server_object);
50

51
   fake_server_stop(fake_server);
52
}
53

54
EFL_START_TEST(properties_get)
55
{
56
   Eina_Iterator *properties = NULL;
57
   properties = efl_model_properties_get(method);
58
   ck_assert_ptr_ne(NULL, properties);
59

60
   const unsigned int expected_properties_count = 3; // a, b and result arguments of 'sum' method
61
   unsigned int actual_properties_count = 0;
62
   const char *prop;
63

64
   EINA_ITERATOR_FOREACH(properties, prop)
65
     actual_properties_count++;
66
   eina_iterator_free(properties);
67
   ck_assert_int_eq(expected_properties_count, actual_properties_count);
68
}
69
EFL_END_TEST
70

71
EFL_START_TEST(property_get)
72
{
73
   // Input only property returns error
74
   Eina_Value *v;
75
   Eina_Value i = EINA_VALUE_EMPTY;
76
   int iv = -1;
77

78
   v = efl_model_property_get(method, ARGUMENT_A);
79
   fail_if(eina_value_type_get(v) != EINA_VALUE_TYPE_ERROR);
80
   eina_value_free(v);
81

82
   v = efl_model_property_get(method, ARGUMENT_RESULT);
83
   eina_value_setup(&i, EINA_VALUE_TYPE_INT);
84
   fail_if(eina_value_convert(v, &i) != EINA_TRUE);
85
   fail_if(eina_value_int_get(&i, &iv) != EINA_TRUE);
86
   fail_if(iv != 0);
87
   eina_value_flush(&i);
88
   eina_value_free(v);
89

90
   // Nonexistent property returns error
91
   v = efl_model_property_get(method, "nonexistent");
92
   fail_if(eina_value_type_get(v) != EINA_VALUE_TYPE_ERROR);
93
   eina_value_free(v);
94
}
95
EFL_END_TEST
96

97
static Eina_Value
98
_expected_error(void *data,
99
                const Eina_Value v,
100
                const Eina_Future *dead_future EINA_UNUSED)
101
{
102
   fail_if(eina_value_type_get(&v) != EINA_VALUE_TYPE_ERROR);
103

104
   if (data)
105
     {
106
        Eina_Error *expected = data;
107
        Eina_Error error;
108

109
        eina_value_error_get(&v, &error);
110

111
        fail_if(*expected != error);
112
     }
113

114
   ecore_main_loop_quit();
115

116
   return v;
117
}
118

119
EFL_START_TEST(property_set)
120
{
121
   // Output argument returns error
122
   Eina_Future *future;
123
   Eina_Value dummy = EINA_VALUE_EMPTY;
124

125
   future = efl_model_property_set(method, ARGUMENT_RESULT, &dummy);
126
   eina_future_then(future, _expected_error, NULL, NULL);
127
}
128
EFL_END_TEST
129

130
static void
131
_test_method_children_count(Eo *efl_model)
132
{
133
   check_efl_model_children_count_eq(efl_model, 0);
134
}
135

136
EFL_START_TEST(children_count)
137
{
138
   _test_method_children_count(method);
139
}
140
EFL_END_TEST
141

142
EFL_START_TEST(children_slice_get)
143
{
144
   Eina_Future *future;
145

146
   future = efl_model_children_slice_get(method, 1, 1);
147
   eina_future_then(future, _expected_error, &EFL_MODEL_ERROR_NOT_SUPPORTED, NULL);
148

149
   ecore_main_loop_begin();
150
}
151
EFL_END_TEST
152

153
EFL_START_TEST(child_add)
154
{
155
   Eo *child;
156
   child = efl_model_child_add(method);
157
   ck_assert_ptr_eq(NULL, child);
158
}
159
EFL_END_TEST
160

161
EFL_START_TEST(child_del)
162
{
163
   // efl_model_child_del always returns ERROR
164
   Eo *child = NULL;
165
   efl_model_child_del(method, child);
166
   //ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
167
}
168
EFL_END_TEST
169

170
EFL_START_TEST(call)
171
{
172
   check_efl_model_property_int_set(method, ARGUMENT_A, 12345678);
173
   check_efl_model_property_int_set(method, ARGUMENT_B, 87654321);
174

175
   eldbus_model_method_call(method);
176

177
   efl_model_wait_for_event(method, ELDBUS_MODEL_METHOD_EVENT_SUCCESSFUL_CALL);
178
   check_efl_model_property_int_eq(method, ARGUMENT_RESULT, 99999999);
179
}
180
EFL_END_TEST
181

182
void eldbus_test_eldbus_model_method(TCase *tc)
183
{
184
   tcase_add_checked_fixture(tc, _setup, _teardown);
185
   tcase_add_test(tc, properties_get);
186
   tcase_add_test(tc, property_get);
187
   tcase_add_test(tc, property_set);
188
   tcase_add_test(tc, children_count);
189
   tcase_add_test(tc, children_slice_get);
190
   tcase_add_test(tc, child_add);
191
   tcase_add_test(tc, child_del);
192
   tcase_add_test(tc, call);
193
}
194