efl

eldbus_test_fake_server_eldbus_model_proxy.c
227 строк · 7.1 Кб
Перенос по словам
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
static Eo *fake_server_object = NULL;
17
static Eo *fake_server_proxy = NULL;
18
static Eldbus_Service_Interface *fake_server = NULL;
19
static Fake_Server_Data fake_server_data = {0};
20

21
#define FAKE_SERVER_READONLY_PROPERTY_VALUE 1111
22
#define FAKE_SERVER_WRITEONLY_PROPERTY_VALUE 2222
23
#define FAKE_SERVER_READWRITE_PROPERTY_VALUE 3333
24

25
static void
26
_setup(void)
27
{
28
   fake_server_data = (Fake_Server_Data){
29
     .readonly_property = FAKE_SERVER_READONLY_PROPERTY_VALUE,
30
     .writeonly_property = FAKE_SERVER_WRITEONLY_PROPERTY_VALUE,
31
     .readwrite_property = FAKE_SERVER_READWRITE_PROPERTY_VALUE
32
   };
33
   char buf[1024];
34
   snprintf(buf, sizeof(buf), FAKE_SERVER_BUS ".%s", basename(__FILE__));
35
   fake_server = fake_server_start(&fake_server_data, buf);
36

37
   fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(),
38
                                eldbus_model_connect(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE),
39
                                eldbus_model_object_bus_set(efl_added, buf),
40
                                eldbus_model_object_path_set(efl_added, FAKE_SERVER_PATH));
41
   ck_assert_ptr_ne(NULL, fake_server_object);
42

43
   fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);
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 = efl_model_properties_get(fake_server_proxy);
57
   ck_assert_ptr_ne(NULL, properties);
58

59
   // FAKE_SERVER_READONLY_PROPERTY, FAKE_SERVER_WRITEONLY_PROPERTY and FAKE_SERVER_READWRITE_PROPERTY properties
60
   const unsigned int expected_properties_count = 3;
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
   _teardown();
70
}
71
EFL_END_TEST
72

73
static Eina_Future *f = NULL;
74

75
static Eina_Value
76
_leave(void *data EINA_UNUSED, const Eina_Value v,
77
       const Eina_Future *dead EINA_UNUSED)
78
{
79
   ecore_main_loop_quit();
80
   f = NULL;
81
   return v;
82
}
83

84
static void
85
_property_ready(void *data EINA_UNUSED, const Efl_Event *ev)
86
{
87
   if (f) return ;
88
   f = efl_loop_job(efl_provider_find(ev->object, EFL_LOOP_CLASS));
89
   eina_future_then(f, _leave, NULL, NULL);
90
}
91

92
EFL_START_TEST(property_get)
93
{
94
   Eina_Value *value;
95

96
   efl_event_callback_add(fake_server_proxy, EFL_MODEL_EVENT_PROPERTIES_CHANGED, _property_ready, NULL);
97
   value = efl_model_property_get(fake_server_proxy, FAKE_SERVER_READONLY_PROPERTY);
98
   eina_value_free(value);
99
   value = efl_model_property_get(fake_server_proxy, FAKE_SERVER_READWRITE_PROPERTY);
100
   eina_value_free(value);
101

102
   ecore_main_loop_begin();
103

104
   check_efl_model_property_int_eq(fake_server_proxy, FAKE_SERVER_READONLY_PROPERTY, FAKE_SERVER_READONLY_PROPERTY_VALUE);
105
   check_efl_model_property_int_eq(fake_server_proxy, FAKE_SERVER_READWRITE_PROPERTY, FAKE_SERVER_READWRITE_PROPERTY_VALUE);
106

107
   // Write-only property returns error
108
   value = efl_model_property_get(fake_server_proxy, FAKE_SERVER_WRITEONLY_PROPERTY);
109
   eina_value_free(value);
110
   //ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
111

112
   _teardown();
113
}
114
EFL_END_TEST
115

116
static void
117
_check_property_set(const char *property_name, int expected_property_value, int *actual_property_value)
118
{
119
   Eina_Value value;
120
   eina_value_setup(&value, EINA_VALUE_TYPE_INT);
121
   eina_value_set(&value, expected_property_value);
122
   efl_model_property_set(fake_server_proxy, property_name, &value);
123
   eina_value_flush(&value);
124

125
   efl_model_wait_for_event(fake_server_proxy, EFL_MODEL_EVENT_PROPERTIES_CHANGED);
126

127
   ck_assert_int_eq(expected_property_value, *actual_property_value);
128
}
129

130
EFL_START_TEST(property_set)
131
{
132
   Eina_Future *future;
133
   Eina_Value dummy = EINA_VALUE_EMPTY;
134

135
   _check_property_set(FAKE_SERVER_WRITEONLY_PROPERTY, 0x12345678, &fake_server_data.writeonly_property);
136
   _check_property_set(FAKE_SERVER_READWRITE_PROPERTY, 0x76543210, &fake_server_data.readwrite_property);
137

138
   // Read-only property returns error
139
   future = efl_model_property_set(fake_server_proxy, FAKE_SERVER_READONLY_PROPERTY, &dummy);
140
   check_efl_model_future_error(future, &EFL_MODEL_ERROR_READ_ONLY);
141

142
   _teardown();
143
}
144
EFL_END_TEST
145

146
static void
147
_test_fake_server_proxy_children_count(Eo *efl_model)
148
{
149
   // 'Sum' and 'Ping' methods and 'Pong' signal
150
   check_efl_model_children_count_eq(efl_model, 3);
151
}
152

153
EFL_START_TEST(children_count)
154
{
155
   _test_fake_server_proxy_children_count(fake_server_proxy);
156

157
   _teardown();
158
}
159
EFL_END_TEST
160

161
EFL_START_TEST(children_slice_get)
162
{
163
   Eldbus_Model_Arguments *method1 = efl_model_nth_child_get(fake_server_proxy, 0);
164
   Eldbus_Model_Arguments *method2 = efl_model_nth_child_get(fake_server_proxy, 1);
165
   Eldbus_Model_Arguments *signal1 = efl_model_nth_child_get(fake_server_proxy, 2);
166

167
   const char *actual_method1_name = eldbus_model_arguments_arg_name_get(method1);
168
   const char *actual_method2_name = eldbus_model_arguments_arg_name_get(method2);
169
   const char *actual_signal1_name = eldbus_model_arguments_arg_name_get(signal1);
170

171
   ck_assert_ptr_ne(NULL, actual_method1_name);
172
   ck_assert_ptr_ne(NULL, actual_method2_name);
173
   ck_assert_ptr_ne(NULL, actual_signal1_name);
174

175
   // Eldbus doesn't have order for method names. Methods order are determined by Eina_Hash
176
   if (strcmp(FAKE_SERVER_SUM_METHOD_NAME, actual_method1_name) == 0)
177
     ck_assert(strcmp(FAKE_SERVER_PING_METHOD_NAME, actual_method2_name) == 0);
178
   else
179
     ck_assert(strcmp(FAKE_SERVER_SUM_METHOD_NAME, actual_method2_name) == 0);
180

181
   ck_assert(strcmp(FAKE_SERVER_PONG_SIGNAL_NAME, actual_signal1_name) == 0);
182

183
   _teardown();
184
}
185
EFL_END_TEST
186

187
EFL_START_TEST(child_add)
188
{
189
   Eo *child = efl_model_child_add(fake_server_proxy);
190
   ck_assert_ptr_eq(NULL, child);
191

192
   _teardown();
193
}
194
EFL_END_TEST
195

196
EFL_START_TEST(child_del)
197
{
198
   // Tests that it is not possible to delete children
199
   Eo *child;
200
   unsigned int expected_children_count = 0;
201
   unsigned int actual_children_count = 0;
202

203
   expected_children_count = efl_model_children_count_get(fake_server_proxy);
204
   ck_assert_msg(expected_children_count, "There must be at least 1 child to test");
205

206
   // efl_model_child_del always returns ERROR
207
   child = efl_model_first_child_get(fake_server_proxy);
208
   efl_model_child_del(fake_server_proxy, child);
209

210
   actual_children_count = efl_model_children_count_get(fake_server_proxy);
211
   ck_assert_int_le(expected_children_count, actual_children_count);
212

213
   _teardown();
214
}
215
EFL_END_TEST
216

217
void eldbus_test_fake_server_eldbus_model_proxy(TCase *tc)
218
{
219
   tcase_add_checked_fixture(tc, _setup, NULL);
220
   tcase_add_test(tc, properties_get);
221
   tcase_add_test(tc, property_get);
222
   tcase_add_test(tc, property_set);
223
   tcase_add_test(tc, children_count);
224
   tcase_add_test(tc, children_slice_get);
225
   tcase_add_test(tc, child_add);
226
   tcase_add_test(tc, child_del);
227
}
228
efl

Использование cookies
