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 <fcntl.h>
9

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

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

17

18
#ifdef XATTR_TEST_DIR
19

20
static char *str_attr = "user.name";
21
static char *str_data = "Vivek Ellur";
22
static char *int_attr = "user.id";
23
static int  int_data = 1234;
24
static char *double_attr = "user.size";
25
static double double_data = 123.456;
26

27
static const char *attribute[] =
28
  {
29
     "user.comment1",
30
     "user.comment2",
31
     "user.comment3"
32
  };
33
static const char *attr_data[] =
34
  {
35
     "This is a test file",
36
     "This line is a comment",
37
     "This file has extra attributes"
38
  };
39

40
static Eina_Bool
41
_filter_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, const char *attr EINA_UNUSED)
42
{
43
   return EINA_TRUE;
44
}
45

46
static void
47
_main_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, const char *attr)
48
{
49
   int *num_of_attr = (int *)data;
50
   unsigned int i;
51

52
   for (i = 0; i < sizeof (attribute) / sizeof (attribute[0]); ++i)
53
     if (strcmp(attr, attribute[i]) == 0)
54
       {
55
          (*num_of_attr)++;
56
          break;
57
       }
58
}
59

60
static void
61
_done_cb(void *data, Eio_File *handler EINA_UNUSED)
62

63
{
64
   int *num_of_attr = (int *)data;
65

66
   (*num_of_attr)++;
67

68
   if (((*num_of_attr) + 1) == (sizeof (attribute) / sizeof (attribute[0])))
69
     ecore_main_loop_quit();
70
}
71

72
static void
73
_done_once_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED)
74
{
75
   ecore_main_loop_quit();
76
}
77

78
static void
79
_done_file_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED)
80
{
81
   int *num_of_attr = (int *)data;
82

83
   fail_if( (*num_of_attr) != (sizeof (attribute) / sizeof (attribute[0])));
84
   ecore_main_loop_quit();
85
}
86

87
static void
88
_done_get_cb(void *data, Eio_File *handler EINA_UNUSED, const char *name, unsigned int len EINA_UNUSED)
89

90
{
91
   int i = (int)(uintptr_t)data;
92

93
   fail_if(strcmp(name, attr_data[i]) != 0);
94

95
   if ((i + 1) == (sizeof (attribute) / sizeof (attribute[0])))
96
     ecore_main_loop_quit();
97
}
98

99
static void
100
_done_string_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, const char *xattr_string)
101
{
102
   fail_if(strcmp(xattr_string, str_data) != 0);
103

104
   ecore_main_loop_quit();
105
}
106

107
static void
108
_done_int_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int xattr_int)
109
{
110
   fail_if(xattr_int != int_data);
111

112
   ecore_main_loop_quit();
113
}
114

115
static void
116
_done_double_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, double xattr_double)
117
{
118
   fail_if(!EINA_DBL_EQ(xattr_double, double_data));
119

120
   ecore_main_loop_quit();
121
}
122

123
static void
124
_error_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int error)
125

126
{
127
   fprintf(stderr, "Something has gone wrong:%s\n", strerror(error));
128
   abort();
129

130
   ecore_main_loop_quit();
131
}
132

133
EFL_START_TEST(eio_test_xattr_set)
134
{
135
   char *filename = "eio-tmpfile";
136
   Eina_Tmpstr *test_file_path;
137
   Eio_File *fp;
138
   int num_of_attr = 0, fd;
139
   unsigned int i;
140

141
   test_file_path = get_full_path(XATTR_TEST_DIR, filename);
142
   fd = open(test_file_path,
143
             O_WRONLY | O_CREAT | O_TRUNC,
144
             S_IRWXU | S_IRWXG | S_IRWXO);
145
   fail_if(fd == 0);
146

147
   for (i = 0; i < sizeof(attribute) / sizeof(attribute[0]); ++i)
148
     {
149
        fp = eio_file_xattr_set(test_file_path, attribute[i],
150
                                attr_data[i], strlen(attr_data[i]),
151
                                EINA_XATTR_INSERT,
152
                                _done_cb, _error_cb, &num_of_attr);
153

154
        fail_if(num_of_attr != 0); // test asynchronous
155
        fail_if(!fp);
156
     }
157

158
   ecore_main_loop_begin();
159

160
   for (i = 0; i < sizeof(attribute) / sizeof(attribute[0]); ++i)
161
     {
162
        fp = eio_file_xattr_get(test_file_path, attribute[i],
163
                                _done_get_cb, _error_cb, (void*)(uintptr_t) i);
164
        fail_if(!fp);
165
     }
166

167
   ecore_main_loop_begin();
168

169
   num_of_attr = 0;
170
   fp = eio_file_xattr(test_file_path,
171
                       _filter_cb, _main_cb, _done_file_cb, _error_cb,
172
                       &num_of_attr);
173
   fail_if(num_of_attr != 0);
174
   fail_if(!fp);
175

176
   ecore_main_loop_begin();
177

178
   close(fd);
179
   unlink(test_file_path);
180
   eina_tmpstr_del(test_file_path);
181
}
182
EFL_END_TEST
183

184
EFL_START_TEST(eio_test_xattr_types_set)
185
{
186
   char *filename = "eio-tmpfile";
187

188
   Eina_Tmpstr *test_file_path;
189
   int  fd, num_of_attr=0;
190
   Eio_File *fp;
191

192
   test_file_path = get_full_path(XATTR_TEST_DIR, filename);
193
   fd = open(test_file_path,
194
             O_WRONLY | O_CREAT | O_TRUNC,
195
             S_IRWXU | S_IRWXG | S_IRWXO);
196
   fail_if(fd == 0);
197
   fp = eio_file_xattr_string_set(test_file_path, str_attr,
198
                                str_data, EINA_XATTR_INSERT,
199
                                _done_once_cb, _error_cb, &num_of_attr);
200

201
   fail_if(num_of_attr != 0); // test asynchronous
202
   fail_if(!fp);
203

204
   ecore_main_loop_begin();
205

206
   fp = eio_file_xattr_string_get(test_file_path, str_attr,
207
                                  _done_string_cb, _error_cb, NULL);
208
   fail_if(!fp);
209

210
   ecore_main_loop_begin();
211

212
   fp = eio_file_xattr_int_set(test_file_path, int_attr,
213
                                int_data, EINA_XATTR_INSERT,
214
                                _done_once_cb, _error_cb, &num_of_attr);
215

216
   fail_if(num_of_attr != 0); // test asynchronous
217
   fail_if(!fp);
218

219
   ecore_main_loop_begin();
220

221
   fp = eio_file_xattr_int_get(test_file_path, int_attr,
222
                                  _done_int_cb, _error_cb, NULL);
223
   fail_if(!fp);
224

225
   ecore_main_loop_begin();
226

227
   fp = eio_file_xattr_double_set(test_file_path, double_attr,
228
                                double_data, EINA_XATTR_INSERT,
229
                                _done_once_cb, _error_cb, &num_of_attr);
230

231
   fail_if(num_of_attr != 0); // test asynchronous
232
   fail_if(!fp);
233

234
   ecore_main_loop_begin();
235

236
   fp = eio_file_xattr_double_get(test_file_path, double_attr,
237
                                  _done_double_cb, _error_cb, NULL);
238
   fail_if(!fp);
239

240
   ecore_main_loop_begin();
241

242
   close(fd);
243
   unlink(test_file_path);
244
   eina_tmpstr_del(test_file_path);
245
}
246
EFL_END_TEST
247
#endif
248

249
void eio_test_xattr(TCase *tc)
250
{
251
#ifdef XATTR_TEST_DIR
252
   tcase_add_test(tc, eio_test_xattr_set);
253
   tcase_add_test(tc, eio_test_xattr_types_set);
254
#else
255
   (void)tc;
256
#endif
257
}
258