efl

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

5
#include <stdio.h>
6
#include <unistd.h>
7
#include <string.h>
8
#include <sys/stat.h>
9
#include <fcntl.h>
10

11
#include <Ecore.h>
12
#include <Ecore_File.h>
13
#include <Eio.h>
14

15
#include "eio_suite.h"
16
#include "eio_test_common.h"
17

18
#ifndef O_BINARY
19
# define O_BINARY 0
20
#endif
21

22
static int test_count = 0;
23

24
static Eina_Bool
25
_filter_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, const char *file)
26
{
27
   char *last_slash = strrchr(file, '/');
28

29
   //Check if it is a hidden file
30
   if (last_slash != NULL && strlen(last_slash) > 1 && last_slash[1] == '.')
31
     return EINA_FALSE;
32

33
   return EINA_TRUE;
34
}
35

36
static Eina_Bool
37
_delete_filter_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED,
38
                  const Eina_File_Direct_Info *info EINA_UNUSED)
39
{
40
   return EINA_TRUE;
41
}
42

43
static void
44
_main_cb(void *data, Eio_File *handler EINA_UNUSED, const char *file EINA_UNUSED)
45
{
46
   int *number_of_listed_files = (int *)data;
47

48
   (*number_of_listed_files)++;
49
}
50

51
static Eina_Bool
52
_direct_filter_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED,
53
                  const Eina_File_Direct_Info *info)
54
{
55
   char *last_slash = strrchr(info->path, '/');
56

57
   //Check if it is a hidden file
58
   if (last_slash != NULL && strlen(last_slash) > 1 && last_slash[1] == '.')
59
     return EINA_FALSE;
60

61
   return EINA_TRUE;
62
}
63

64
static void
65
_direct_main_cb(void *data, Eio_File *handler EINA_UNUSED, const Eina_File_Direct_Info *info EINA_UNUSED)
66
{
67
   int *number_of_listed_files = (int *)data;
68

69
   (*number_of_listed_files)++;
70
}
71

72
static void
73
_progress_cb(void *data, Eio_File *handler EINA_UNUSED, const Eio_Progress *info EINA_UNUSED)
74
{
75
   int *number_of_listed_files = (int *)data;
76

77
   (*number_of_listed_files)++;
78
}
79

80
static void
81
_stat_done_cb(void *data, Eio_File *handler EINA_UNUSED, const Eina_Stat *stat)
82
{
83
   unsigned int rights;
84
   Eina_Bool *is_dir = (Eina_Bool *)data;
85
   fail_if(eio_file_is_dir(stat) != *is_dir);
86
   fail_if(eio_file_is_lnk(stat));
87
   rights = stat->mode & (S_IRWXU | S_IRWXG | S_IRWXO);
88
   fail_if(rights != default_rights);
89
   ecore_main_loop_quit();
90
}
91

92
static void
93
_done_cb(void *data, Eio_File *handler EINA_UNUSED)
94
{
95
   int *number_of_listed_files = (int *)data;
96
   fail_if((*number_of_listed_files) != test_count);
97
   ecore_main_loop_quit();
98
}
99

100
static void
101
_error_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int error)
102
{
103
   fprintf(stderr, "Something has gone wrong:%s\n", strerror(error));
104
   ecore_main_loop_quit();
105
}
106

107
static void
108
_open_done_cb(void *data, Eio_File *handler EINA_UNUSED, Eina_File *file)
109
{
110
   Eina_Bool *opened = (Eina_Bool *)data;
111
   *opened = EINA_TRUE;
112
   eina_file_close(file);
113
   ecore_main_loop_quit();
114
}
115

116
EFL_START_TEST(eio_file_test_ls)
117
{
118
   int number_of_listed_files = 0;
119
   const char *new_dir = "new_dir";
120

121
   Eina_Tmpstr *test_dirname = get_eio_test_file_tmp_dir();
122
   Eina_Tmpstr *nested_dirname = create_test_dirs(test_dirname);
123
   Eina_Tmpstr *nested_filename = get_full_path(test_dirname, files[3]);
124
   Eina_Tmpstr *new_dirname = get_full_path(test_dirname, new_dir);
125

126
   eio_file_ls(test_dirname, _filter_cb, _main_cb, _done_cb, _error_cb,
127
               &number_of_listed_files);
128
   test_count = 5;
129
   fail_if(number_of_listed_files != 0); //check asynchronous
130
   ecore_main_loop_begin();
131

132
   number_of_listed_files = 0;
133
#ifdef _WIN32
134
   eio_file_direct_ls(test_dirname, _direct_filter_cb, _direct_main_cb, _done_cb,
135
                   _error_cb, &number_of_listed_files);
136
#else
137
   eio_file_stat_ls(test_dirname, _direct_filter_cb, _direct_main_cb, _done_cb,
138
                   _error_cb, &number_of_listed_files);
139
#endif
140
   test_count = 5;
141
   fail_if(number_of_listed_files != 0); //check asynchronous
142
   ecore_main_loop_begin();
143

144
   number_of_listed_files = 0;
145
#ifdef _WIN32
146
   eio_dir_direct_ls(test_dirname, _direct_filter_cb, _direct_main_cb, _done_cb,
147
                   _error_cb, &number_of_listed_files);
148
#else
149
   eio_dir_stat_ls(test_dirname, _direct_filter_cb, _direct_main_cb, _done_cb,
150
                   _error_cb, &number_of_listed_files);
151
#endif
152
   test_count = 8;
153
   fail_if(number_of_listed_files != 0); //check asynchronous
154
   ecore_main_loop_begin();
155

156
   test_count = 1;
157
   eio_file_unlink(nested_filename, _done_cb, _error_cb, &test_count);
158
   ecore_main_loop_begin();
159

160
   test_count = 1;
161
   eio_file_mkdir(new_dirname, default_rights, _done_cb, _error_cb, &test_count);
162
   ecore_main_loop_begin();
163

164
   number_of_listed_files = 0;
165
   eio_dir_unlink(nested_dirname, _delete_filter_cb, _progress_cb, _done_cb,
166
                   _error_cb, &number_of_listed_files);
167
   test_count = 5; // 4 internal files + 1 nested_dir
168
   fail_if(number_of_listed_files != 0); // check asynchronous
169
   ecore_main_loop_begin();
170

171
   number_of_listed_files = 0;
172
   eio_dir_unlink(test_dirname, _delete_filter_cb, _progress_cb, _done_cb,
173
                   _error_cb, &number_of_listed_files);
174
   test_count = 6; // 3 internal files + 2 dir + 1 test_dir
175
   fail_if(number_of_listed_files != 0); // check asynchronous
176
   ecore_main_loop_begin();
177

178
   eina_tmpstr_del(nested_dirname);
179
   eina_tmpstr_del(test_dirname);
180
   eina_tmpstr_del(nested_filename);
181
   eina_tmpstr_del(new_dirname);
182
}
183
EFL_END_TEST
184

185
EFL_START_TEST(eio_file_test_file)
186
{
187
   int number_of_listed_files = 0, ret;
188
   Eina_Bool is_dir;
189
   const char * new_file = "new_file";
190

191
   ret = ecore_file_init();
192
   fail_if(ret < 1);
193

194

195
   Eina_Tmpstr *test_dirname = get_eio_test_file_tmp_dir();
196
   Eina_Tmpstr *nested_dirname = create_test_dirs(test_dirname);
197
   Eina_Tmpstr *nested_filename = get_full_path(test_dirname, files[3]);
198
   Eina_Tmpstr *new_filename = get_full_path(nested_dirname, new_file);
199
   Eina_Tmpstr *new_dirname = get_full_path(test_dirname, new_file);
200

201
   is_dir = EINA_TRUE;
202
   eio_file_direct_stat(nested_dirname, _stat_done_cb, _error_cb, &is_dir);
203
   ecore_main_loop_begin();
204

205
   test_count = 1;
206
   default_rights = 0766;
207
   eio_file_chmod(nested_filename, default_rights, _done_cb, _error_cb, &test_count);
208
   ecore_main_loop_begin();
209

210
   is_dir = EINA_FALSE;
211
   eio_file_direct_stat(nested_filename, _stat_done_cb, _error_cb, &is_dir);
212
   ecore_main_loop_begin();
213
   default_rights = DEFAULT_RIGHTS;
214

215
   test_count = 1;
216
   eio_file_move(nested_filename, new_filename, _progress_cb, _done_cb,
217
                 _error_cb, &test_count);
218
   ecore_main_loop_begin();
219

220
   fail_if(ecore_file_exists(nested_filename));
221
   eio_file_ls(nested_dirname, _filter_cb, _main_cb, _done_cb, _error_cb,
222
               &number_of_listed_files);
223
   test_count = 4;
224
   fail_if(number_of_listed_files != 0); //check asynchronous
225
   ecore_main_loop_begin();
226

227
   number_of_listed_files = 0;
228
   eio_file_ls(test_dirname, _filter_cb, _main_cb, _done_cb, _error_cb,
229
               &number_of_listed_files);
230
   test_count = 4; //2 dirs + 2 normal files
231
   fail_if(number_of_listed_files != 0); //check asynchronous
232
   ecore_main_loop_begin();
233

234
   test_count = 1;
235
   eio_file_copy(new_filename, nested_filename, _progress_cb, _done_cb,
236
                 _error_cb, &test_count);
237
   ecore_main_loop_begin();
238

239
   number_of_listed_files = 0;
240
   eio_file_ls(nested_dirname, _filter_cb, _main_cb, _done_cb, _error_cb,
241
               &number_of_listed_files);
242
   test_count = 4; // 3 normal files + 1 new file
243
   fail_if(number_of_listed_files != 0); //check asynchronous
244
   ecore_main_loop_begin();
245

246
   number_of_listed_files = 0;
247
   eio_file_ls(test_dirname, _filter_cb, _main_cb, _done_cb, _error_cb,
248
               &number_of_listed_files);
249
   test_count = 5;
250
   fail_if(number_of_listed_files != 0); //check asynchronous
251
   ecore_main_loop_begin();
252

253
   number_of_listed_files = 0;
254
   eio_dir_move(nested_dirname, new_dirname, _direct_filter_cb, _progress_cb,
255
                _done_cb, _error_cb,  &number_of_listed_files);
256
   test_count = 1;
257
   fail_if(number_of_listed_files != 0); //check asynchronous
258
   ecore_main_loop_begin();
259
   fail_if(ecore_file_is_dir(nested_dirname));
260
   fail_if(!ecore_file_is_dir(new_dirname));
261

262
   number_of_listed_files = 0;
263
   eio_dir_copy(new_dirname, nested_dirname, _direct_filter_cb, _progress_cb,
264
                _done_cb, _error_cb,  &number_of_listed_files);
265
   test_count = 6;
266
   fail_if(number_of_listed_files != 0); //check asynchronous
267
   ecore_main_loop_begin();
268
   fail_if(!ecore_file_is_dir(nested_dirname));
269
   fail_if(!ecore_file_is_dir(new_dirname));
270

271
   number_of_listed_files = 0;
272
   eio_dir_unlink(nested_dirname, _delete_filter_cb, _progress_cb, _done_cb,
273
                   _error_cb, &number_of_listed_files);
274
   test_count = 5; // 4 internal files + 1 nested_dir
275
   fail_if(number_of_listed_files != 0); // check asynchronous
276
   ecore_main_loop_begin();
277
   fail_if(ecore_file_is_dir(nested_dirname));
278

279
   fail_if(!ecore_file_recursive_rm(test_dirname));
280
   fail_if(ecore_file_is_dir(new_dirname));
281

282
   eina_tmpstr_del(nested_dirname);
283
   eina_tmpstr_del(test_dirname);
284
   eina_tmpstr_del(nested_filename);
285
   eina_tmpstr_del(new_filename);
286
   eina_tmpstr_del(new_dirname);
287
   ecore_file_shutdown();
288
}
289
EFL_END_TEST
290

291
EFL_START_TEST(eio_file_test_open)
292
{
293
   Eina_Bool opened_file;
294
   int ret;
295

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

299

300
   Eina_Tmpstr *test_dirname = get_eio_test_file_tmp_dir();
301
   Eina_Tmpstr *nested_dirname = create_test_dirs(test_dirname);
302
   Eina_Tmpstr *nested_filename = get_full_path(test_dirname, files[3]);
303

304
   opened_file = EINA_FALSE;
305
   eio_file_open(nested_filename, EINA_FALSE, _open_done_cb, _error_cb, &opened_file);
306
   ecore_main_loop_begin();
307
   fail_if(!opened_file);
308

309
   // Cleanup
310
   fail_if(!ecore_file_recursive_rm(test_dirname));
311

312
   eina_tmpstr_del(nested_dirname);
313
   eina_tmpstr_del(test_dirname);
314
   eina_tmpstr_del(nested_filename);
315
   ecore_file_shutdown();
316
}
317
EFL_END_TEST
318

319
void
320
eio_test_file(TCase *tc)
321
{
322
    tcase_add_test(tc, eio_file_test_ls);
323
    tcase_add_test(tc, eio_file_test_file);
324
    tcase_add_test(tc, eio_file_test_open);
325
}
326