efl

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

5
#include <Ecore.h>
6
#include <Ecore_File.h>
7
#include <Eio.h>
8

9
#include "eio_suite.h"
10
#include "eio_test_common.h"
11

12
#ifndef O_BINARY
13
# define O_BINARY 0
14
#endif
15

16
static uint64_t test_count = 0;
17
static Eina_Bool direct = EINA_FALSE;
18

19
#define DONE_CALLED 0xdeadbeef
20

21
static void
22
_access_cb(void *data, Eina_Array *paths)
23
{
24
   uint64_t *number_of_listed_files = data;
25

26
   *number_of_listed_files += eina_array_count(paths);
27
}
28

29
static void
30
_progress_cb(void *data, Eina_Array *entries)
31
{
32
   uint64_t *number_of_listed_files = data;
33

34
   (*number_of_listed_files) += eina_array_count(entries);
35
}
36

37
static Eina_Value
38
_future_cb(void *data,
39
           const Eina_Value file,
40
           const Eina_Future *dead EINA_UNUSED)
41
{
42
   if (file.type == EINA_VALUE_TYPE_ERROR)
43
     {
44
        Eina_Error err;
45

46
        eina_value_get(&file, &err);
47
        fprintf(stderr, "Something has gone wrong: %s\n", eina_error_msg_get(err));
48
        abort();
49
     }
50
   if (file.type == EINA_VALUE_TYPE_UINT64)
51
     {
52
        uint64_t *number_of_listed_files = data;
53
        uint64_t value;
54

55
        eina_value_get(&file, &value);
56

57
        fail_if((*number_of_listed_files) != test_count);
58
        fail_if(value != test_count);
59
        *number_of_listed_files = DONE_CALLED;
60
     }
61

62
   ecore_main_loop_quit();
63

64
   return file;
65
}
66

67
static Eina_Value
68
_done_cb(void *data,
69
         const Eina_Value file,
70
         const Eina_Future *dead EINA_UNUSED)
71
{
72
   uint64_t *number_of_listed_files = data;
73

74
   if (eina_value_type_get(&file) == EINA_VALUE_TYPE_ERROR)
75
     {
76
        Eina_Error err = 0;
77
        const char *msg;
78

79
        eina_value_error_get(&file, &err);
80
        msg = eina_error_msg_get(err);
81

82
        EINA_LOG_ERR("error: %s", msg);
83
        abort();
84
     }
85
   else
86
     {
87
        Eina_Value convert = EINA_VALUE_EMPTY;
88
        unsigned long files_count = 0;
89

90
        eina_value_setup(&convert, EINA_VALUE_TYPE_ULONG);
91
        fail_if(eina_value_convert(&file, &convert) != EINA_TRUE);
92
        fail_unless(eina_value_ulong_get(&convert, &files_count));
93

94
        fail_if((*number_of_listed_files) != test_count);
95
        fail_if(files_count != test_count);
96

97
        *number_of_listed_files = DONE_CALLED;
98
     }
99

100
   ecore_main_loop_quit();
101

102
   return file;
103
}
104

105
static Eina_Value
106
_open_done_cb(void *data,
107
              const Eina_Value file,
108
              const Eina_Future *dead EINA_UNUSED)
109
{
110
   if (file.type == EINA_VALUE_TYPE_ERROR)
111
     {
112
        Eina_Error err;
113

114
        eina_value_get(&file, &err);
115
        fprintf(stderr, "Something has gone wrong: %s\n", eina_error_msg_get(err));
116
        abort();
117
     }
118
   if (file.type == EINA_VALUE_TYPE_FILE)
119
     {
120
        Eina_Bool *opened = (Eina_Bool *)data;
121

122
        *opened = EINA_TRUE;
123
     }
124
   ecore_main_loop_quit();
125

126
   return file;
127
}
128

129
static Eina_Value
130
_stat_done_cb(void *data,
131
              const Eina_Value st,
132
              const Eina_Future *dead EINA_UNUSED)
133
{
134
   Eina_Bool *is_dir = data;
135
   unsigned int rights;
136

137
   if (st.type == EINA_VALUE_TYPE_ERROR)
138
     {
139
        Eina_Error err;
140
        eina_value_get(&st, &err);
141
        fprintf(stderr, "Something has gone wrong: %s\n", eina_error_msg_get(err));
142
        abort();
143
     }
144

145
   if (st.type == EINA_VALUE_TYPE_STRUCT)
146
     {
147
        unsigned int mode = 0;
148

149
        fail_if(!eina_value_struct_get(&st, "mode", &mode));
150
        fail_if(S_ISDIR(mode) != *is_dir);
151
        /* no symbolic link on Windows */
152
#ifndef _WIN32
153
        fail_if(S_ISLNK(mode));
154
#endif
155

156
        rights = mode & (S_IRWXU | S_IRWXG | S_IRWXO);
157
        fail_if(rights != default_rights);
158
     }
159

160
   ecore_main_loop_quit();
161

162
   return st;
163
}
164

165
static void
166
_test_ls(Eina_Future *(*func)(const Eo *obj, const char *path, Eina_Bool recursive,
167
                              void *info_data, EflIoDirectInfo info, Eina_Free_Cb info_free_cb),
168
         uint64_t expected_test_count,
169
         const char* test_dirname)
170
{
171
   Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
172
   Eina_Future *f = NULL;
173
   uint64_t main_files = 0;
174

175
   fail_if(!job);
176

177
   f = func(job, test_dirname, EINA_FALSE, &main_files, _progress_cb, NULL);
178
   fail_if(!f);
179
   test_count = expected_test_count;
180
   eina_future_then(f, &_done_cb, &main_files, NULL);
181

182
   ecore_main_loop_begin();
183

184
   fail_if(main_files != DONE_CALLED);
185
   main_files = 0;
186

187
   f = func(job, test_dirname, EINA_TRUE, &main_files, _progress_cb, NULL);
188
   test_count = expected_test_count + 4;
189
   eina_future_then(f, &_done_cb, &main_files, NULL);
190

191
   ecore_main_loop_begin();
192

193
   fail_if(main_files != DONE_CALLED);
194

195
   efl_del(job);
196
}
197

198
EFL_START_TEST(efl_io_manager_test_stat)
199
{
200
   Eina_Tmpstr *test_dirname;
201
   Eina_Tmpstr *nested_dirname;
202
   Eina_Tmpstr *nested_filename;
203
   Efl_Io_Manager *job;
204
   Eina_Future *f;
205
   Eina_Bool is_dir = EINA_TRUE;
206
   int ret;
207

208
   ret = ecore_file_init();
209
   fail_if(ret < 1);
210

211
   test_dirname = get_eio_test_file_tmp_dir();
212
   nested_dirname = create_test_dirs(test_dirname);
213
   nested_filename = get_full_path(test_dirname, files[3]);
214

215
   job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
216
   fail_if(!job);
217

218
   // Start testing
219
   f = efl_io_manager_stat(job, nested_dirname);
220
   eina_future_then(f, _stat_done_cb, &is_dir, NULL);
221
   ecore_main_loop_begin();
222

223
   is_dir = EINA_FALSE;
224
   f = efl_io_manager_stat(job, nested_filename);
225
   eina_future_then(f, _stat_done_cb, &is_dir, NULL);
226
   ecore_main_loop_begin();
227

228
   // Cleanup
229
   efl_del(job);
230
   fail_if(!ecore_file_recursive_rm(test_dirname));
231

232
   eina_tmpstr_del(nested_dirname);
233
   eina_tmpstr_del(test_dirname);
234
   eina_tmpstr_del(nested_filename);
235
   ecore_file_shutdown();
236
}
237
EFL_END_TEST
238

239
EFL_START_TEST(efl_io_manager_test_ls)
240
{
241
   Eina_Tmpstr *test_dirname;
242
   Eina_Tmpstr *nested_dirname;
243
   Eina_Tmpstr *nested_filename;
244
   Efl_Io_Manager *job;
245
   Eina_Future *f;
246
   uint64_t main_files = 0;
247
   int ret;
248

249
   ret = ecore_file_init();
250
   fail_if(ret < 1);
251

252
   test_dirname = get_eio_test_file_tmp_dir();
253
   nested_dirname = create_test_dirs(test_dirname);
254
   nested_filename = get_full_path(test_dirname, files[3]);
255

256
   // Start testing
257
   job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
258
   fail_if(!job);
259

260
   f = efl_io_manager_ls(job, test_dirname, &main_files, _access_cb, NULL);
261
   test_count = 6;
262
   eina_future_then(f, _future_cb, &main_files, NULL);
263

264
   ecore_main_loop_begin();
265

266
   fail_if(main_files != DONE_CALLED);
267

268
   // No recursion for efl_io_manager_ls, should I fix that ?
269
   /* _test_ls(&efl_io_manager_ls, 5, test_dirname); */
270
   direct = EINA_TRUE;
271
   _test_ls(&efl_io_manager_stat_ls, 6, test_dirname);
272
   _test_ls(&efl_io_manager_direct_ls, 6, test_dirname);
273

274
   // Cleanup
275
   efl_del(job);
276
   fail_if(!ecore_file_recursive_rm(test_dirname));
277

278
   eina_tmpstr_del(nested_dirname);
279
   eina_tmpstr_del(test_dirname);
280
   eina_tmpstr_del(nested_filename);
281
   ecore_file_shutdown();
282
}
283
EFL_END_TEST
284

285
EFL_START_TEST(efl_io_manager_test_open)
286
{
287
   Eina_Tmpstr *test_dirname;
288
   Eina_Tmpstr *nested_dirname;
289
   Eina_Tmpstr *nested_filename;
290
   Efl_Io_Manager *job;
291
   Eina_Future *f;
292
   Eina_Bool opened_file = EINA_FALSE;
293
   int ret;
294

295
   ret = ecore_file_init();
296
   fail_if(ret < 1);
297

298
   test_dirname = get_eio_test_file_tmp_dir();
299
   nested_dirname = create_test_dirs(test_dirname);
300
   nested_filename = get_full_path(test_dirname, files[3]);
301

302
   job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
303

304
   f = efl_io_manager_open(job, nested_filename, EINA_FALSE);
305
   eina_future_then(f, _open_done_cb, &opened_file, NULL);
306
   ecore_main_loop_begin();
307

308
   fail_if(!opened_file);
309

310
   // Cleanup
311
   efl_del(job);
312
   fail_if(!ecore_file_recursive_rm(test_dirname));
313

314
   eina_tmpstr_del(nested_dirname);
315
   eina_tmpstr_del(test_dirname);
316

317
   eina_tmpstr_del(nested_filename);
318
   ecore_file_shutdown();
319
}
320
EFL_END_TEST
321

322
EFL_START_TEST(efl_io_test_instantiated)
323
{
324
   Efl_Io_Manager *manager;
325

326
   efl_object_init();
327

328
   ck_assert_int_eq(eio_shutdown(), 0);
329
   ecore_init();
330
   fail_if(efl_provider_find(efl_main_loop_get(), EFL_IO_MANAGER_CLASS) != NULL);
331
   ecore_shutdown();
332
   ck_assert_int_eq(eio_init(), 1);
333

334
   manager = efl_provider_find(efl_main_loop_get(), EFL_IO_MANAGER_CLASS);
335
   fail_if(manager == NULL);
336
   fail_if(!efl_isa(manager, EFL_IO_MANAGER_CLASS));
337

338
   efl_object_shutdown();
339
}
340
EFL_END_TEST
341

342
void
343
eio_test_job(TCase *tc)
344
{
345
    tcase_add_test(tc, efl_io_manager_test_ls);
346
    tcase_add_test(tc, efl_io_manager_test_stat);
347
    tcase_add_test(tc, efl_io_manager_test_open);
348
    tcase_add_test(tc, efl_io_test_instantiated);
349
}
350