|
160
|
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
|
|
2 *
|
|
|
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
4 * of this software and associated documentation files (the "Software"), to
|
|
|
5 * deal in the Software without restriction, including without limitation the
|
|
|
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
7 * sell copies of the Software, and to permit persons to whom the Software is
|
|
|
8 * furnished to do so, subject to the following conditions:
|
|
|
9 *
|
|
|
10 * The above copyright notice and this permission notice shall be included in
|
|
|
11 * all copies or substantial portions of the Software.
|
|
|
12 *
|
|
|
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
19 * IN THE SOFTWARE.
|
|
|
20 */
|
|
|
21
|
|
|
22 #include "uv.h"
|
|
|
23 #include "task.h"
|
|
|
24
|
|
|
25 #include <errno.h>
|
|
|
26 #include <string.h> /* memset */
|
|
|
27 #include <fcntl.h>
|
|
|
28 #include <sys/stat.h>
|
|
|
29 #include <limits.h> /* INT_MAX, PATH_MAX, IOV_MAX */
|
|
|
30
|
|
|
31 #ifndef _WIN32
|
|
|
32 # include <unistd.h> /* unlink, rmdir, etc. */
|
|
|
33 #else
|
|
|
34 # include <winioctl.h>
|
|
|
35 # include <direct.h>
|
|
|
36 # include <io.h>
|
|
|
37 # ifndef ERROR_SYMLINK_NOT_SUPPORTED
|
|
|
38 # define ERROR_SYMLINK_NOT_SUPPORTED 1464
|
|
|
39 # endif
|
|
|
40 # ifndef S_IFIFO
|
|
|
41 # define S_IFIFO _S_IFIFO
|
|
|
42 # endif
|
|
|
43 # define unlink _unlink
|
|
|
44 # define rmdir _rmdir
|
|
|
45 # define open _open
|
|
|
46 # define write _write
|
|
|
47 # define close _close
|
|
|
48 # ifndef stat
|
|
|
49 # define stat _stati64
|
|
|
50 # endif
|
|
|
51 # ifndef lseek
|
|
|
52 # define lseek _lseek
|
|
|
53 # endif
|
|
|
54 # define S_IFDIR _S_IFDIR
|
|
|
55 # define S_IFCHR _S_IFCHR
|
|
|
56 # define S_IFREG _S_IFREG
|
|
|
57 #endif
|
|
|
58
|
|
|
59 #define TOO_LONG_NAME_LENGTH 65536
|
|
|
60 #define PATHMAX 4096
|
|
|
61
|
|
|
62 #ifdef _WIN32
|
|
|
63 static const int is_win32 = 1;
|
|
|
64 #else
|
|
|
65 static const int is_win32 = 0;
|
|
|
66 #endif
|
|
|
67
|
|
|
68 #if defined(__APPLE__) || defined(__SUNPRO_C)
|
|
|
69 static const int is_apple_or_sunpro_c = 1;
|
|
|
70 #else
|
|
|
71 static const int is_apple_or_sunpro_c = 0;
|
|
|
72 #endif
|
|
|
73
|
|
|
74 typedef struct {
|
|
|
75 const char* path;
|
|
|
76 double atime;
|
|
|
77 double mtime;
|
|
|
78 } utime_check_t;
|
|
|
79
|
|
|
80
|
|
|
81 static int dummy_cb_count;
|
|
|
82 static int close_cb_count;
|
|
|
83 static int create_cb_count;
|
|
|
84 static int open_cb_count;
|
|
|
85 static int read_cb_count;
|
|
|
86 static int write_cb_count;
|
|
|
87 static int unlink_cb_count;
|
|
|
88 static int mkdir_cb_count;
|
|
|
89 static int mkdtemp_cb_count;
|
|
|
90 static int mkstemp_cb_count;
|
|
|
91 static int rmdir_cb_count;
|
|
|
92 static int scandir_cb_count;
|
|
|
93 static int stat_cb_count;
|
|
|
94 static int rename_cb_count;
|
|
|
95 static int fsync_cb_count;
|
|
|
96 static int fdatasync_cb_count;
|
|
|
97 static int ftruncate_cb_count;
|
|
|
98 static int sendfile_cb_count;
|
|
|
99 static int fstat_cb_count;
|
|
|
100 static int access_cb_count;
|
|
|
101 static int chmod_cb_count;
|
|
|
102 static int fchmod_cb_count;
|
|
|
103 static int chown_cb_count;
|
|
|
104 static int fchown_cb_count;
|
|
|
105 static int lchown_cb_count;
|
|
|
106 static int link_cb_count;
|
|
|
107 static int symlink_cb_count;
|
|
|
108 static int readlink_cb_count;
|
|
|
109 static int realpath_cb_count;
|
|
|
110 static int utime_cb_count;
|
|
|
111 static int futime_cb_count;
|
|
|
112 static int lutime_cb_count;
|
|
|
113 static int statfs_cb_count;
|
|
|
114
|
|
|
115 static uv_loop_t* loop;
|
|
|
116
|
|
|
117 static uv_fs_t open_req1;
|
|
|
118 static uv_fs_t open_req2;
|
|
|
119 static uv_fs_t open_req_noclose;
|
|
|
120 static uv_fs_t read_req;
|
|
|
121 static uv_fs_t write_req;
|
|
|
122 static uv_fs_t unlink_req;
|
|
|
123 static uv_fs_t close_req;
|
|
|
124 static uv_fs_t mkdir_req;
|
|
|
125 static uv_fs_t mkdtemp_req1;
|
|
|
126 static uv_fs_t mkdtemp_req2;
|
|
|
127 static uv_fs_t mkstemp_req1;
|
|
|
128 static uv_fs_t mkstemp_req2;
|
|
|
129 static uv_fs_t mkstemp_req3;
|
|
|
130 static uv_fs_t rmdir_req;
|
|
|
131 static uv_fs_t scandir_req;
|
|
|
132 static uv_fs_t stat_req;
|
|
|
133 static uv_fs_t rename_req;
|
|
|
134 static uv_fs_t fsync_req;
|
|
|
135 static uv_fs_t fdatasync_req;
|
|
|
136 static uv_fs_t ftruncate_req;
|
|
|
137 static uv_fs_t sendfile_req;
|
|
|
138 static uv_fs_t utime_req;
|
|
|
139 static uv_fs_t futime_req;
|
|
|
140
|
|
|
141 static char buf[32];
|
|
|
142 static char buf2[32];
|
|
|
143 static char test_buf[] = "test-buffer\n";
|
|
|
144 static char test_buf2[] = "second-buffer\n";
|
|
|
145 static uv_buf_t iov;
|
|
|
146
|
|
|
147 #ifdef _WIN32
|
|
|
148 int uv_test_getiovmax(void) {
|
|
|
149 return INT32_MAX; /* Emulated by libuv, so no real limit. */
|
|
|
150 }
|
|
|
151 #else
|
|
|
152 int uv_test_getiovmax(void) {
|
|
|
153 #if defined(IOV_MAX)
|
|
|
154 return IOV_MAX;
|
|
|
155 #elif defined(_SC_IOV_MAX)
|
|
|
156 static int iovmax = -1;
|
|
|
157 if (iovmax == -1) {
|
|
|
158 iovmax = sysconf(_SC_IOV_MAX);
|
|
|
159 /* On some embedded devices (arm-linux-uclibc based ip camera),
|
|
|
160 * sysconf(_SC_IOV_MAX) can not get the correct value. The return
|
|
|
161 * value is -1 and the errno is EINPROGRESS. Degrade the value to 1.
|
|
|
162 */
|
|
|
163 if (iovmax == -1) iovmax = 1;
|
|
|
164 }
|
|
|
165 return iovmax;
|
|
|
166 #else
|
|
|
167 return 1024;
|
|
|
168 #endif
|
|
|
169 }
|
|
|
170 #endif
|
|
|
171
|
|
|
172 #ifdef _WIN32
|
|
|
173 /*
|
|
|
174 * This tag and guid have no special meaning, and don't conflict with
|
|
|
175 * reserved ids.
|
|
|
176 */
|
|
|
177 static unsigned REPARSE_TAG = 0x9913;
|
|
|
178 static GUID REPARSE_GUID = {
|
|
|
179 0x1bf6205f, 0x46ae, 0x4527,
|
|
|
180 { 0xb1, 0x0c, 0xc5, 0x09, 0xb7, 0x55, 0x22, 0x80 }};
|
|
|
181 #endif
|
|
|
182
|
|
|
183 static void check_permission(const char* filename, unsigned int mode) {
|
|
|
184 int r;
|
|
|
185 uv_fs_t req;
|
|
|
186 uv_stat_t* s;
|
|
|
187
|
|
|
188 r = uv_fs_stat(NULL, &req, filename, NULL);
|
|
|
189 ASSERT_OK(r);
|
|
|
190 ASSERT_OK(req.result);
|
|
|
191
|
|
|
192 s = &req.statbuf;
|
|
|
193 #if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
|
|
|
194 /*
|
|
|
195 * On Windows, chmod can only modify S_IWUSR (_S_IWRITE) bit,
|
|
|
196 * so only testing for the specified flags.
|
|
|
197 */
|
|
|
198 ASSERT((s->st_mode & 0777) & mode);
|
|
|
199 #else
|
|
|
200 ASSERT((s->st_mode & 0777) == mode);
|
|
|
201 #endif
|
|
|
202
|
|
|
203 uv_fs_req_cleanup(&req);
|
|
|
204 }
|
|
|
205
|
|
|
206
|
|
|
207 static void dummy_cb(uv_fs_t* req) {
|
|
|
208 (void) req;
|
|
|
209 dummy_cb_count++;
|
|
|
210 }
|
|
|
211
|
|
|
212
|
|
|
213 static void link_cb(uv_fs_t* req) {
|
|
|
214 ASSERT_EQ(req->fs_type, UV_FS_LINK);
|
|
|
215 ASSERT_OK(req->result);
|
|
|
216 link_cb_count++;
|
|
|
217 uv_fs_req_cleanup(req);
|
|
|
218 }
|
|
|
219
|
|
|
220
|
|
|
221 static void symlink_cb(uv_fs_t* req) {
|
|
|
222 ASSERT_EQ(req->fs_type, UV_FS_SYMLINK);
|
|
|
223 ASSERT_OK(req->result);
|
|
|
224 symlink_cb_count++;
|
|
|
225 uv_fs_req_cleanup(req);
|
|
|
226 }
|
|
|
227
|
|
|
228 static void readlink_cb(uv_fs_t* req) {
|
|
|
229 ASSERT_EQ(req->fs_type, UV_FS_READLINK);
|
|
|
230 ASSERT_OK(req->result);
|
|
|
231 ASSERT_OK(strcmp(req->ptr, "test_file_symlink2"));
|
|
|
232 readlink_cb_count++;
|
|
|
233 uv_fs_req_cleanup(req);
|
|
|
234 }
|
|
|
235
|
|
|
236
|
|
|
237 static void realpath_cb(uv_fs_t* req) {
|
|
|
238 char test_file_abs_buf[PATHMAX];
|
|
|
239 size_t test_file_abs_size = sizeof(test_file_abs_buf);
|
|
|
240 ASSERT_EQ(req->fs_type, UV_FS_REALPATH);
|
|
|
241 ASSERT_OK(req->result);
|
|
|
242
|
|
|
243 uv_cwd(test_file_abs_buf, &test_file_abs_size);
|
|
|
244 #ifdef _WIN32
|
|
|
245 strcat(test_file_abs_buf, "\\test_file");
|
|
|
246 ASSERT_OK(_stricmp(req->ptr, test_file_abs_buf));
|
|
|
247 #else
|
|
|
248 strcat(test_file_abs_buf, "/test_file");
|
|
|
249 ASSERT_OK(strcmp(req->ptr, test_file_abs_buf));
|
|
|
250 #endif
|
|
|
251 realpath_cb_count++;
|
|
|
252 uv_fs_req_cleanup(req);
|
|
|
253 }
|
|
|
254
|
|
|
255
|
|
|
256 static void access_cb(uv_fs_t* req) {
|
|
|
257 ASSERT_EQ(req->fs_type, UV_FS_ACCESS);
|
|
|
258 access_cb_count++;
|
|
|
259 uv_fs_req_cleanup(req);
|
|
|
260 }
|
|
|
261
|
|
|
262
|
|
|
263 static void fchmod_cb(uv_fs_t* req) {
|
|
|
264 ASSERT_EQ(req->fs_type, UV_FS_FCHMOD);
|
|
|
265 ASSERT_OK(req->result);
|
|
|
266 fchmod_cb_count++;
|
|
|
267 uv_fs_req_cleanup(req);
|
|
|
268 check_permission("test_file", *(int*)req->data);
|
|
|
269 }
|
|
|
270
|
|
|
271
|
|
|
272 static void chmod_cb(uv_fs_t* req) {
|
|
|
273 ASSERT_EQ(req->fs_type, UV_FS_CHMOD);
|
|
|
274 ASSERT_OK(req->result);
|
|
|
275 chmod_cb_count++;
|
|
|
276 uv_fs_req_cleanup(req);
|
|
|
277 check_permission("test_file", *(int*)req->data);
|
|
|
278 }
|
|
|
279
|
|
|
280
|
|
|
281 static void fchown_cb(uv_fs_t* req) {
|
|
|
282 ASSERT_EQ(req->fs_type, UV_FS_FCHOWN);
|
|
|
283 ASSERT_OK(req->result);
|
|
|
284 fchown_cb_count++;
|
|
|
285 uv_fs_req_cleanup(req);
|
|
|
286 }
|
|
|
287
|
|
|
288
|
|
|
289 static void chown_cb(uv_fs_t* req) {
|
|
|
290 ASSERT_EQ(req->fs_type, UV_FS_CHOWN);
|
|
|
291 ASSERT_OK(req->result);
|
|
|
292 chown_cb_count++;
|
|
|
293 uv_fs_req_cleanup(req);
|
|
|
294 }
|
|
|
295
|
|
|
296 static void lchown_cb(uv_fs_t* req) {
|
|
|
297 ASSERT_EQ(req->fs_type, UV_FS_LCHOWN);
|
|
|
298 ASSERT_OK(req->result);
|
|
|
299 lchown_cb_count++;
|
|
|
300 uv_fs_req_cleanup(req);
|
|
|
301 }
|
|
|
302
|
|
|
303 static void chown_root_cb(uv_fs_t* req) {
|
|
|
304 ASSERT_EQ(req->fs_type, UV_FS_CHOWN);
|
|
|
305 #if defined(_WIN32) || defined(__MSYS__)
|
|
|
306 /* On windows, chown is a no-op and always succeeds. */
|
|
|
307 ASSERT_OK(req->result);
|
|
|
308 #else
|
|
|
309 /* On unix, chown'ing the root directory is not allowed -
|
|
|
310 * unless you're root, of course.
|
|
|
311 */
|
|
|
312 if (geteuid() == 0)
|
|
|
313 ASSERT_OK(req->result);
|
|
|
314 else
|
|
|
315 # if defined(__CYGWIN__)
|
|
|
316 /* On Cygwin, uid 0 is invalid (no root). */
|
|
|
317 ASSERT_EQ(req->result, UV_EINVAL);
|
|
|
318 # elif defined(__PASE__)
|
|
|
319 /* On IBMi PASE, there is no root user. uid 0 is user qsecofr.
|
|
|
320 * User may grant qsecofr's privileges, including changing
|
|
|
321 * the file's ownership to uid 0.
|
|
|
322 */
|
|
|
323 ASSERT(req->result == 0 || req->result == UV_EPERM);
|
|
|
324 # else
|
|
|
325 ASSERT_EQ(req->result, UV_EPERM);
|
|
|
326 # endif
|
|
|
327 #endif
|
|
|
328 chown_cb_count++;
|
|
|
329 uv_fs_req_cleanup(req);
|
|
|
330 }
|
|
|
331
|
|
|
332 static void unlink_cb(uv_fs_t* req) {
|
|
|
333 ASSERT_PTR_EQ(req, &unlink_req);
|
|
|
334 ASSERT_EQ(req->fs_type, UV_FS_UNLINK);
|
|
|
335 ASSERT_OK(req->result);
|
|
|
336 unlink_cb_count++;
|
|
|
337 uv_fs_req_cleanup(req);
|
|
|
338 }
|
|
|
339
|
|
|
340 static void fstat_cb(uv_fs_t* req) {
|
|
|
341 uv_stat_t* s = req->ptr;
|
|
|
342 ASSERT_EQ(req->fs_type, UV_FS_FSTAT);
|
|
|
343 ASSERT_OK(req->result);
|
|
|
344 ASSERT_EQ(s->st_size, sizeof(test_buf));
|
|
|
345 uv_fs_req_cleanup(req);
|
|
|
346 fstat_cb_count++;
|
|
|
347 }
|
|
|
348
|
|
|
349
|
|
|
350 static void statfs_cb(uv_fs_t* req) {
|
|
|
351 uv_statfs_t* stats;
|
|
|
352
|
|
|
353 ASSERT_EQ(req->fs_type, UV_FS_STATFS);
|
|
|
354 ASSERT_OK(req->result);
|
|
|
355 ASSERT_NOT_NULL(req->ptr);
|
|
|
356 stats = req->ptr;
|
|
|
357
|
|
|
358 #if defined(_WIN32) || defined(__sun) || defined(_AIX) || defined(__MVS__) || \
|
|
|
359 defined(__OpenBSD__) || defined(__NetBSD__)
|
|
|
360 ASSERT_OK(stats->f_type);
|
|
|
361 #else
|
|
|
362 ASSERT_UINT64_GT(stats->f_type, 0);
|
|
|
363 #endif
|
|
|
364
|
|
|
365 ASSERT_GT(stats->f_bsize, 0);
|
|
|
366 ASSERT_GT(stats->f_blocks, 0);
|
|
|
367 ASSERT_LE(stats->f_bfree, stats->f_blocks);
|
|
|
368 ASSERT_LE(stats->f_bavail, stats->f_bfree);
|
|
|
369
|
|
|
370 #ifdef _WIN32
|
|
|
371 ASSERT_OK(stats->f_files);
|
|
|
372 ASSERT_OK(stats->f_ffree);
|
|
|
373 #else
|
|
|
374 /* There is no assertion for stats->f_files that makes sense, so ignore it. */
|
|
|
375 ASSERT_LE(stats->f_ffree, stats->f_files);
|
|
|
376 #endif
|
|
|
377 uv_fs_req_cleanup(req);
|
|
|
378 ASSERT_NULL(req->ptr);
|
|
|
379 statfs_cb_count++;
|
|
|
380 }
|
|
|
381
|
|
|
382
|
|
|
383 static void close_cb(uv_fs_t* req) {
|
|
|
384 int r;
|
|
|
385 ASSERT_PTR_EQ(req, &close_req);
|
|
|
386 ASSERT_EQ(req->fs_type, UV_FS_CLOSE);
|
|
|
387 ASSERT_OK(req->result);
|
|
|
388 close_cb_count++;
|
|
|
389 uv_fs_req_cleanup(req);
|
|
|
390 if (close_cb_count == 3) {
|
|
|
391 r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb);
|
|
|
392 ASSERT_OK(r);
|
|
|
393 }
|
|
|
394 }
|
|
|
395
|
|
|
396
|
|
|
397 static void ftruncate_cb(uv_fs_t* req) {
|
|
|
398 int r;
|
|
|
399 ASSERT_PTR_EQ(req, &ftruncate_req);
|
|
|
400 ASSERT_EQ(req->fs_type, UV_FS_FTRUNCATE);
|
|
|
401 ASSERT_OK(req->result);
|
|
|
402 ftruncate_cb_count++;
|
|
|
403 uv_fs_req_cleanup(req);
|
|
|
404 r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
|
|
|
405 ASSERT_OK(r);
|
|
|
406 }
|
|
|
407
|
|
|
408 static void fail_cb(uv_fs_t* req) {
|
|
|
409 FATAL("fail_cb should not have been called");
|
|
|
410 }
|
|
|
411
|
|
|
412 static void read_cb(uv_fs_t* req) {
|
|
|
413 int r;
|
|
|
414 ASSERT_PTR_EQ(req, &read_req);
|
|
|
415 ASSERT_EQ(req->fs_type, UV_FS_READ);
|
|
|
416 ASSERT_GE(req->result, 0); /* FIXME(bnoordhuis) Check if requested size? */
|
|
|
417 read_cb_count++;
|
|
|
418 uv_fs_req_cleanup(req);
|
|
|
419 if (read_cb_count == 1) {
|
|
|
420 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
421 r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7,
|
|
|
422 ftruncate_cb);
|
|
|
423 } else {
|
|
|
424 ASSERT_OK(strcmp(buf, "test-bu"));
|
|
|
425 r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
|
|
|
426 }
|
|
|
427 ASSERT_OK(r);
|
|
|
428 }
|
|
|
429
|
|
|
430
|
|
|
431 static void open_cb(uv_fs_t* req) {
|
|
|
432 int r;
|
|
|
433 ASSERT_PTR_EQ(req, &open_req1);
|
|
|
434 ASSERT_EQ(req->fs_type, UV_FS_OPEN);
|
|
|
435 if (req->result < 0) {
|
|
|
436 fprintf(stderr, "async open error: %d\n", (int) req->result);
|
|
|
437 ASSERT(0);
|
|
|
438 }
|
|
|
439 open_cb_count++;
|
|
|
440 ASSERT(req->path);
|
|
|
441 ASSERT_OK(memcmp(req->path, "test_file2\0", 11));
|
|
|
442 uv_fs_req_cleanup(req);
|
|
|
443 memset(buf, 0, sizeof(buf));
|
|
|
444 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
445 r = uv_fs_read(loop, &read_req, open_req1.result, &iov, 1, -1,
|
|
|
446 read_cb);
|
|
|
447 ASSERT_OK(r);
|
|
|
448 }
|
|
|
449
|
|
|
450
|
|
|
451 static void open_cb_simple(uv_fs_t* req) {
|
|
|
452 ASSERT_EQ(req->fs_type, UV_FS_OPEN);
|
|
|
453 if (req->result < 0) {
|
|
|
454 fprintf(stderr, "async open error: %d\n", (int) req->result);
|
|
|
455 ASSERT(0);
|
|
|
456 }
|
|
|
457 open_cb_count++;
|
|
|
458 ASSERT(req->path);
|
|
|
459 uv_fs_req_cleanup(req);
|
|
|
460 }
|
|
|
461
|
|
|
462
|
|
|
463 static void fsync_cb(uv_fs_t* req) {
|
|
|
464 int r;
|
|
|
465 ASSERT_PTR_EQ(req, &fsync_req);
|
|
|
466 ASSERT_EQ(req->fs_type, UV_FS_FSYNC);
|
|
|
467 ASSERT_OK(req->result);
|
|
|
468 fsync_cb_count++;
|
|
|
469 uv_fs_req_cleanup(req);
|
|
|
470 r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
|
|
|
471 ASSERT_OK(r);
|
|
|
472 }
|
|
|
473
|
|
|
474
|
|
|
475 static void fdatasync_cb(uv_fs_t* req) {
|
|
|
476 int r;
|
|
|
477 ASSERT_PTR_EQ(req, &fdatasync_req);
|
|
|
478 ASSERT_EQ(req->fs_type, UV_FS_FDATASYNC);
|
|
|
479 ASSERT_OK(req->result);
|
|
|
480 fdatasync_cb_count++;
|
|
|
481 uv_fs_req_cleanup(req);
|
|
|
482 r = uv_fs_fsync(loop, &fsync_req, open_req1.result, fsync_cb);
|
|
|
483 ASSERT_OK(r);
|
|
|
484 }
|
|
|
485
|
|
|
486
|
|
|
487 static void write_cb(uv_fs_t* req) {
|
|
|
488 int r;
|
|
|
489 ASSERT_PTR_EQ(req, &write_req);
|
|
|
490 ASSERT_EQ(req->fs_type, UV_FS_WRITE);
|
|
|
491 ASSERT_GE(req->result, 0); /* FIXME(bnoordhuis) Check if requested size? */
|
|
|
492 write_cb_count++;
|
|
|
493 uv_fs_req_cleanup(req);
|
|
|
494 r = uv_fs_fdatasync(loop, &fdatasync_req, open_req1.result, fdatasync_cb);
|
|
|
495 ASSERT_OK(r);
|
|
|
496 }
|
|
|
497
|
|
|
498
|
|
|
499 static void create_cb(uv_fs_t* req) {
|
|
|
500 int r;
|
|
|
501 ASSERT_PTR_EQ(req, &open_req1);
|
|
|
502 ASSERT_EQ(req->fs_type, UV_FS_OPEN);
|
|
|
503 ASSERT_GE(req->result, 0);
|
|
|
504 create_cb_count++;
|
|
|
505 uv_fs_req_cleanup(req);
|
|
|
506 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
507 r = uv_fs_write(loop, &write_req, req->result, &iov, 1, -1, write_cb);
|
|
|
508 ASSERT_OK(r);
|
|
|
509 }
|
|
|
510
|
|
|
511
|
|
|
512 static void rename_cb(uv_fs_t* req) {
|
|
|
513 ASSERT_PTR_EQ(req, &rename_req);
|
|
|
514 ASSERT_EQ(req->fs_type, UV_FS_RENAME);
|
|
|
515 ASSERT_OK(req->result);
|
|
|
516 rename_cb_count++;
|
|
|
517 uv_fs_req_cleanup(req);
|
|
|
518 }
|
|
|
519
|
|
|
520
|
|
|
521 static void mkdir_cb(uv_fs_t* req) {
|
|
|
522 ASSERT_PTR_EQ(req, &mkdir_req);
|
|
|
523 ASSERT_EQ(req->fs_type, UV_FS_MKDIR);
|
|
|
524 ASSERT_OK(req->result);
|
|
|
525 mkdir_cb_count++;
|
|
|
526 ASSERT(req->path);
|
|
|
527 ASSERT_OK(memcmp(req->path, "test_dir\0", 9));
|
|
|
528 uv_fs_req_cleanup(req);
|
|
|
529 }
|
|
|
530
|
|
|
531
|
|
|
532 static void check_mkdtemp_result(uv_fs_t* req) {
|
|
|
533 int r;
|
|
|
534
|
|
|
535 ASSERT_EQ(req->fs_type, UV_FS_MKDTEMP);
|
|
|
536 ASSERT_OK(req->result);
|
|
|
537 ASSERT(req->path);
|
|
|
538 ASSERT_EQ(15, strlen(req->path));
|
|
|
539 ASSERT_OK(memcmp(req->path, "test_dir_", 9));
|
|
|
540 ASSERT_NE(0, memcmp(req->path + 9, "XXXXXX", 6));
|
|
|
541 check_permission(req->path, 0700);
|
|
|
542
|
|
|
543 /* Check if req->path is actually a directory */
|
|
|
544 r = uv_fs_stat(NULL, &stat_req, req->path, NULL);
|
|
|
545 ASSERT_OK(r);
|
|
|
546 ASSERT(((uv_stat_t*)stat_req.ptr)->st_mode & S_IFDIR);
|
|
|
547 uv_fs_req_cleanup(&stat_req);
|
|
|
548 }
|
|
|
549
|
|
|
550
|
|
|
551 static void mkdtemp_cb(uv_fs_t* req) {
|
|
|
552 ASSERT_PTR_EQ(req, &mkdtemp_req1);
|
|
|
553 check_mkdtemp_result(req);
|
|
|
554 mkdtemp_cb_count++;
|
|
|
555 }
|
|
|
556
|
|
|
557
|
|
|
558 static void check_mkstemp_result(uv_fs_t* req) {
|
|
|
559 int r;
|
|
|
560
|
|
|
561 ASSERT_EQ(req->fs_type, UV_FS_MKSTEMP);
|
|
|
562 ASSERT_GE(req->result, 0);
|
|
|
563 ASSERT(req->path);
|
|
|
564 ASSERT_EQ(16, strlen(req->path));
|
|
|
565 ASSERT_OK(memcmp(req->path, "test_file_", 10));
|
|
|
566 ASSERT_NE(0, memcmp(req->path + 10, "XXXXXX", 6));
|
|
|
567 check_permission(req->path, 0600);
|
|
|
568
|
|
|
569 /* Check if req->path is actually a file */
|
|
|
570 r = uv_fs_stat(NULL, &stat_req, req->path, NULL);
|
|
|
571 ASSERT_OK(r);
|
|
|
572 ASSERT(stat_req.statbuf.st_mode & S_IFREG);
|
|
|
573 uv_fs_req_cleanup(&stat_req);
|
|
|
574 }
|
|
|
575
|
|
|
576
|
|
|
577 static void mkstemp_cb(uv_fs_t* req) {
|
|
|
578 ASSERT_PTR_EQ(req, &mkstemp_req1);
|
|
|
579 check_mkstemp_result(req);
|
|
|
580 mkstemp_cb_count++;
|
|
|
581 }
|
|
|
582
|
|
|
583
|
|
|
584 static void rmdir_cb(uv_fs_t* req) {
|
|
|
585 ASSERT_PTR_EQ(req, &rmdir_req);
|
|
|
586 ASSERT_EQ(req->fs_type, UV_FS_RMDIR);
|
|
|
587 ASSERT_OK(req->result);
|
|
|
588 rmdir_cb_count++;
|
|
|
589 ASSERT(req->path);
|
|
|
590 ASSERT_OK(memcmp(req->path, "test_dir\0", 9));
|
|
|
591 uv_fs_req_cleanup(req);
|
|
|
592 }
|
|
|
593
|
|
|
594
|
|
|
595 static void assert_is_file_type(uv_dirent_t dent) {
|
|
|
596 #ifdef HAVE_DIRENT_TYPES
|
|
|
597 /*
|
|
|
598 * For Apple and Windows, we know getdents is expected to work but for other
|
|
|
599 * environments, the filesystem dictates whether or not getdents supports
|
|
|
600 * returning the file type.
|
|
|
601 *
|
|
|
602 * See:
|
|
|
603 * http://man7.org/linux/man-pages/man2/getdents.2.html
|
|
|
604 * https://github.com/libuv/libuv/issues/501
|
|
|
605 */
|
|
|
606 #if defined(__APPLE__) || defined(_WIN32)
|
|
|
607 ASSERT_EQ(dent.type, UV_DIRENT_FILE);
|
|
|
608 #else
|
|
|
609 ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);
|
|
|
610 #endif
|
|
|
611 #else
|
|
|
612 ASSERT_EQ(dent.type, UV_DIRENT_UNKNOWN);
|
|
|
613 #endif
|
|
|
614 }
|
|
|
615
|
|
|
616
|
|
|
617 static void scandir_cb(uv_fs_t* req) {
|
|
|
618 uv_dirent_t dent;
|
|
|
619 ASSERT_PTR_EQ(req, &scandir_req);
|
|
|
620 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR);
|
|
|
621 ASSERT_EQ(2, req->result);
|
|
|
622 ASSERT(req->ptr);
|
|
|
623
|
|
|
624 while (UV_EOF != uv_fs_scandir_next(req, &dent)) {
|
|
|
625 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
|
|
|
626 assert_is_file_type(dent);
|
|
|
627 }
|
|
|
628 scandir_cb_count++;
|
|
|
629 ASSERT(req->path);
|
|
|
630 ASSERT_OK(memcmp(req->path, "test_dir\0", 9));
|
|
|
631 uv_fs_req_cleanup(req);
|
|
|
632 ASSERT(!req->ptr);
|
|
|
633 }
|
|
|
634
|
|
|
635
|
|
|
636 static void empty_scandir_cb(uv_fs_t* req) {
|
|
|
637 uv_dirent_t dent;
|
|
|
638
|
|
|
639 ASSERT_PTR_EQ(req, &scandir_req);
|
|
|
640 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR);
|
|
|
641 ASSERT_OK(req->result);
|
|
|
642 ASSERT_NULL(req->ptr);
|
|
|
643 ASSERT_EQ(UV_EOF, uv_fs_scandir_next(req, &dent));
|
|
|
644 uv_fs_req_cleanup(req);
|
|
|
645 scandir_cb_count++;
|
|
|
646 }
|
|
|
647
|
|
|
648 static void non_existent_scandir_cb(uv_fs_t* req) {
|
|
|
649 uv_dirent_t dent;
|
|
|
650
|
|
|
651 ASSERT_PTR_EQ(req, &scandir_req);
|
|
|
652 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR);
|
|
|
653 ASSERT_EQ(req->result, UV_ENOENT);
|
|
|
654 ASSERT_NULL(req->ptr);
|
|
|
655 ASSERT_EQ(UV_ENOENT, uv_fs_scandir_next(req, &dent));
|
|
|
656 uv_fs_req_cleanup(req);
|
|
|
657 scandir_cb_count++;
|
|
|
658 }
|
|
|
659
|
|
|
660
|
|
|
661 static void file_scandir_cb(uv_fs_t* req) {
|
|
|
662 ASSERT_PTR_EQ(req, &scandir_req);
|
|
|
663 ASSERT_EQ(req->fs_type, UV_FS_SCANDIR);
|
|
|
664 ASSERT_EQ(req->result, UV_ENOTDIR);
|
|
|
665 ASSERT_NULL(req->ptr);
|
|
|
666 uv_fs_req_cleanup(req);
|
|
|
667 scandir_cb_count++;
|
|
|
668 }
|
|
|
669
|
|
|
670
|
|
|
671 static void stat_cb(uv_fs_t* req) {
|
|
|
672 ASSERT_PTR_EQ(req, &stat_req);
|
|
|
673 ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT);
|
|
|
674 ASSERT_OK(req->result);
|
|
|
675 ASSERT(req->ptr);
|
|
|
676 stat_cb_count++;
|
|
|
677 uv_fs_req_cleanup(req);
|
|
|
678 ASSERT(!req->ptr);
|
|
|
679 }
|
|
|
680
|
|
|
681 static void stat_batch_cb(uv_fs_t* req) {
|
|
|
682 ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT);
|
|
|
683 ASSERT_OK(req->result);
|
|
|
684 ASSERT(req->ptr);
|
|
|
685 stat_cb_count++;
|
|
|
686 uv_fs_req_cleanup(req);
|
|
|
687 ASSERT(!req->ptr);
|
|
|
688 }
|
|
|
689
|
|
|
690
|
|
|
691 static void sendfile_cb(uv_fs_t* req) {
|
|
|
692 ASSERT_PTR_EQ(req, &sendfile_req);
|
|
|
693 ASSERT_EQ(req->fs_type, UV_FS_SENDFILE);
|
|
|
694 ASSERT_EQ(65545, req->result);
|
|
|
695 sendfile_cb_count++;
|
|
|
696 uv_fs_req_cleanup(req);
|
|
|
697 }
|
|
|
698
|
|
|
699
|
|
|
700 static void sendfile_nodata_cb(uv_fs_t* req) {
|
|
|
701 ASSERT_PTR_EQ(req, &sendfile_req);
|
|
|
702 ASSERT_EQ(req->fs_type, UV_FS_SENDFILE);
|
|
|
703 ASSERT_OK(req->result);
|
|
|
704 sendfile_cb_count++;
|
|
|
705 uv_fs_req_cleanup(req);
|
|
|
706 }
|
|
|
707
|
|
|
708
|
|
|
709 static void open_noent_cb(uv_fs_t* req) {
|
|
|
710 ASSERT_EQ(req->fs_type, UV_FS_OPEN);
|
|
|
711 ASSERT_EQ(req->result, UV_ENOENT);
|
|
|
712 open_cb_count++;
|
|
|
713 uv_fs_req_cleanup(req);
|
|
|
714 }
|
|
|
715
|
|
|
716 static void open_nametoolong_cb(uv_fs_t* req) {
|
|
|
717 ASSERT_EQ(req->fs_type, UV_FS_OPEN);
|
|
|
718 ASSERT_EQ(req->result, UV_ENAMETOOLONG);
|
|
|
719 open_cb_count++;
|
|
|
720 uv_fs_req_cleanup(req);
|
|
|
721 }
|
|
|
722
|
|
|
723 static void open_loop_cb(uv_fs_t* req) {
|
|
|
724 ASSERT_EQ(req->fs_type, UV_FS_OPEN);
|
|
|
725 ASSERT_EQ(req->result, UV_ELOOP);
|
|
|
726 open_cb_count++;
|
|
|
727 uv_fs_req_cleanup(req);
|
|
|
728 }
|
|
|
729
|
|
|
730
|
|
|
731 TEST_IMPL(fs_file_noent) {
|
|
|
732 uv_fs_t req;
|
|
|
733 int r;
|
|
|
734
|
|
|
735 loop = uv_default_loop();
|
|
|
736
|
|
|
737 r = uv_fs_open(NULL, &req, "does_not_exist", UV_FS_O_RDONLY, 0, NULL);
|
|
|
738 ASSERT_EQ(r, UV_ENOENT);
|
|
|
739 ASSERT_EQ(req.result, UV_ENOENT);
|
|
|
740 uv_fs_req_cleanup(&req);
|
|
|
741
|
|
|
742 r = uv_fs_open(loop, &req, "does_not_exist", UV_FS_O_RDONLY, 0,
|
|
|
743 open_noent_cb);
|
|
|
744 ASSERT_OK(r);
|
|
|
745
|
|
|
746 ASSERT_OK(open_cb_count);
|
|
|
747 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
748 ASSERT_EQ(1, open_cb_count);
|
|
|
749
|
|
|
750 /* TODO add EACCES test */
|
|
|
751
|
|
|
752 MAKE_VALGRIND_HAPPY(loop);
|
|
|
753 return 0;
|
|
|
754 }
|
|
|
755
|
|
|
756 TEST_IMPL(fs_file_nametoolong) {
|
|
|
757 uv_fs_t req;
|
|
|
758 int r;
|
|
|
759 char name[TOO_LONG_NAME_LENGTH + 1];
|
|
|
760
|
|
|
761 loop = uv_default_loop();
|
|
|
762
|
|
|
763 memset(name, 'a', TOO_LONG_NAME_LENGTH);
|
|
|
764 name[TOO_LONG_NAME_LENGTH] = 0;
|
|
|
765
|
|
|
766 r = uv_fs_open(NULL, &req, name, UV_FS_O_RDONLY, 0, NULL);
|
|
|
767 ASSERT_EQ(r, UV_ENAMETOOLONG);
|
|
|
768 ASSERT_EQ(req.result, UV_ENAMETOOLONG);
|
|
|
769 uv_fs_req_cleanup(&req);
|
|
|
770
|
|
|
771 r = uv_fs_open(loop, &req, name, UV_FS_O_RDONLY, 0, open_nametoolong_cb);
|
|
|
772 ASSERT_OK(r);
|
|
|
773
|
|
|
774 ASSERT_OK(open_cb_count);
|
|
|
775 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
776 ASSERT_EQ(1, open_cb_count);
|
|
|
777
|
|
|
778 MAKE_VALGRIND_HAPPY(loop);
|
|
|
779 return 0;
|
|
|
780 }
|
|
|
781
|
|
|
782 TEST_IMPL(fs_file_loop) {
|
|
|
783 uv_fs_t req;
|
|
|
784 int r;
|
|
|
785
|
|
|
786 loop = uv_default_loop();
|
|
|
787
|
|
|
788 unlink("test_symlink");
|
|
|
789 r = uv_fs_symlink(NULL, &req, "test_symlink", "test_symlink", 0, NULL);
|
|
|
790 #ifdef _WIN32
|
|
|
791 /*
|
|
|
792 * Symlinks are only suported but only when elevated, otherwise
|
|
|
793 * we'll see UV_EPERM.
|
|
|
794 */
|
|
|
795 if (r == UV_EPERM)
|
|
|
796 return 0;
|
|
|
797 #elif defined(__MSYS__)
|
|
|
798 /* MSYS2's approximation of symlinks with copies does not work for broken
|
|
|
799 links. */
|
|
|
800 if (r == UV_ENOENT)
|
|
|
801 return 0;
|
|
|
802 #endif
|
|
|
803 ASSERT_OK(r);
|
|
|
804 uv_fs_req_cleanup(&req);
|
|
|
805
|
|
|
806 r = uv_fs_open(NULL, &req, "test_symlink", UV_FS_O_RDONLY, 0, NULL);
|
|
|
807 ASSERT_EQ(r, UV_ELOOP);
|
|
|
808 ASSERT_EQ(req.result, UV_ELOOP);
|
|
|
809 uv_fs_req_cleanup(&req);
|
|
|
810
|
|
|
811 r = uv_fs_open(loop, &req, "test_symlink", UV_FS_O_RDONLY, 0, open_loop_cb);
|
|
|
812 ASSERT_OK(r);
|
|
|
813
|
|
|
814 ASSERT_OK(open_cb_count);
|
|
|
815 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
816 ASSERT_EQ(1, open_cb_count);
|
|
|
817
|
|
|
818 unlink("test_symlink");
|
|
|
819
|
|
|
820 MAKE_VALGRIND_HAPPY(loop);
|
|
|
821 return 0;
|
|
|
822 }
|
|
|
823
|
|
|
824 static void check_utime(const char* path,
|
|
|
825 double atime,
|
|
|
826 double mtime,
|
|
|
827 int test_lutime) {
|
|
|
828 uv_stat_t* s;
|
|
|
829 uv_fs_t req;
|
|
|
830 int r;
|
|
|
831
|
|
|
832 if (test_lutime)
|
|
|
833 r = uv_fs_lstat(loop, &req, path, NULL);
|
|
|
834 else
|
|
|
835 r = uv_fs_stat(loop, &req, path, NULL);
|
|
|
836
|
|
|
837 ASSERT_OK(r);
|
|
|
838
|
|
|
839 ASSERT_OK(req.result);
|
|
|
840 s = &req.statbuf;
|
|
|
841
|
|
|
842 if (isfinite(atime)) {
|
|
|
843 /* Test sub-second timestamps only when supported (such as Windows with
|
|
|
844 * NTFS). Some other platforms support sub-second timestamps, but that
|
|
|
845 * support is filesystem-dependent. Notably OS X (HFS Plus) does NOT
|
|
|
846 * support sub-second timestamps. But kernels may round or truncate in
|
|
|
847 * either direction, so we may accept either possible answer.
|
|
|
848 */
|
|
|
849 if (s->st_atim.tv_nsec == 0) {
|
|
|
850 if (is_win32)
|
|
|
851 ASSERT_DOUBLE_EQ(atime, (long) atime);
|
|
|
852 if (atime > 0 || (long) atime == atime)
|
|
|
853 ASSERT_EQ(s->st_atim.tv_sec, (long) atime);
|
|
|
854 ASSERT_GE(s->st_atim.tv_sec, (long) atime - 1);
|
|
|
855 ASSERT_LE(s->st_atim.tv_sec, (long) atime);
|
|
|
856 } else {
|
|
|
857 double st_atim;
|
|
|
858 /* TODO(vtjnash): would it be better to normalize this? */
|
|
|
859 if (!is_apple_or_sunpro_c)
|
|
|
860 ASSERT_DOUBLE_GE(s->st_atim.tv_nsec, 0);
|
|
|
861 st_atim = s->st_atim.tv_sec + s->st_atim.tv_nsec / 1e9;
|
|
|
862 /* Linux does not allow reading reliably the atime of a symlink
|
|
|
863 * since readlink() can update it
|
|
|
864 */
|
|
|
865 if (!test_lutime)
|
|
|
866 ASSERT_DOUBLE_EQ(st_atim, atime);
|
|
|
867 }
|
|
|
868 } else if (isinf(atime)) {
|
|
|
869 /* We test with timestamps that are in the distant past
|
|
|
870 * (if you're a Gen Z-er) so check it's more recent than that.
|
|
|
871 */
|
|
|
872 ASSERT_GT(s->st_atim.tv_sec, 1739710000);
|
|
|
873 } else {
|
|
|
874 ASSERT_OK(0);
|
|
|
875 }
|
|
|
876
|
|
|
877 if (isfinite(mtime)) {
|
|
|
878 /* Test sub-second timestamps only when supported (such as Windows with
|
|
|
879 * NTFS). Some other platforms support sub-second timestamps, but that
|
|
|
880 * support is filesystem-dependent. Notably OS X (HFS Plus) does NOT
|
|
|
881 * support sub-second timestamps. But kernels may round or truncate in
|
|
|
882 * either direction, so we may accept either possible answer.
|
|
|
883 */
|
|
|
884 if (s->st_mtim.tv_nsec == 0) {
|
|
|
885 if (is_win32)
|
|
|
886 ASSERT_DOUBLE_EQ(mtime, (long) atime);
|
|
|
887 if (mtime > 0 || (long) mtime == mtime)
|
|
|
888 ASSERT_EQ(s->st_mtim.tv_sec, (long) mtime);
|
|
|
889 ASSERT_GE(s->st_mtim.tv_sec, (long) mtime - 1);
|
|
|
890 ASSERT_LE(s->st_mtim.tv_sec, (long) mtime);
|
|
|
891 } else {
|
|
|
892 double st_mtim;
|
|
|
893 /* TODO(vtjnash): would it be better to normalize this? */
|
|
|
894 if (!is_apple_or_sunpro_c)
|
|
|
895 ASSERT_DOUBLE_GE(s->st_mtim.tv_nsec, 0);
|
|
|
896 st_mtim = s->st_mtim.tv_sec + s->st_mtim.tv_nsec / 1e9;
|
|
|
897 ASSERT_DOUBLE_EQ(st_mtim, mtime);
|
|
|
898 }
|
|
|
899 } else if (isinf(mtime)) {
|
|
|
900 /* We test with timestamps that are in the distant past
|
|
|
901 * (if you're a Gen Z-er) so check it's more recent than that.
|
|
|
902 */
|
|
|
903 ASSERT_GT(s->st_mtim.tv_sec, 1739710000);
|
|
|
904 } else {
|
|
|
905 ASSERT_OK(0);
|
|
|
906 }
|
|
|
907
|
|
|
908 uv_fs_req_cleanup(&req);
|
|
|
909 }
|
|
|
910
|
|
|
911
|
|
|
912 static void utime_cb(uv_fs_t* req) {
|
|
|
913 utime_check_t* c;
|
|
|
914
|
|
|
915 ASSERT_PTR_EQ(req, &utime_req);
|
|
|
916 ASSERT_OK(req->result);
|
|
|
917 ASSERT_EQ(req->fs_type, UV_FS_UTIME);
|
|
|
918
|
|
|
919 c = req->data;
|
|
|
920 check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0);
|
|
|
921
|
|
|
922 uv_fs_req_cleanup(req);
|
|
|
923 utime_cb_count++;
|
|
|
924 }
|
|
|
925
|
|
|
926
|
|
|
927 static void futime_cb(uv_fs_t* req) {
|
|
|
928 utime_check_t* c;
|
|
|
929
|
|
|
930 ASSERT_PTR_EQ(req, &futime_req);
|
|
|
931 ASSERT_OK(req->result);
|
|
|
932 ASSERT_EQ(req->fs_type, UV_FS_FUTIME);
|
|
|
933
|
|
|
934 c = req->data;
|
|
|
935 check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0);
|
|
|
936
|
|
|
937 uv_fs_req_cleanup(req);
|
|
|
938 futime_cb_count++;
|
|
|
939 }
|
|
|
940
|
|
|
941
|
|
|
942 static void lutime_cb(uv_fs_t* req) {
|
|
|
943 utime_check_t* c;
|
|
|
944
|
|
|
945 ASSERT_OK(req->result);
|
|
|
946 ASSERT_EQ(req->fs_type, UV_FS_LUTIME);
|
|
|
947
|
|
|
948 c = req->data;
|
|
|
949 check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 1);
|
|
|
950
|
|
|
951 uv_fs_req_cleanup(req);
|
|
|
952 lutime_cb_count++;
|
|
|
953 }
|
|
|
954
|
|
|
955
|
|
|
956 TEST_IMPL(fs_file_async) {
|
|
|
957 int r;
|
|
|
958
|
|
|
959 /* Setup. */
|
|
|
960 unlink("test_file");
|
|
|
961 unlink("test_file2");
|
|
|
962
|
|
|
963 loop = uv_default_loop();
|
|
|
964
|
|
|
965 r = uv_fs_open(loop, &open_req1, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
966 S_IRUSR | S_IWUSR, create_cb);
|
|
|
967 ASSERT_OK(r);
|
|
|
968 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
969
|
|
|
970 ASSERT_EQ(1, create_cb_count);
|
|
|
971 ASSERT_EQ(1, write_cb_count);
|
|
|
972 ASSERT_EQ(1, fsync_cb_count);
|
|
|
973 ASSERT_EQ(1, fdatasync_cb_count);
|
|
|
974 ASSERT_EQ(1, close_cb_count);
|
|
|
975
|
|
|
976 r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", rename_cb);
|
|
|
977 ASSERT_OK(r);
|
|
|
978
|
|
|
979 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
980 ASSERT_EQ(1, create_cb_count);
|
|
|
981 ASSERT_EQ(1, write_cb_count);
|
|
|
982 ASSERT_EQ(1, close_cb_count);
|
|
|
983 ASSERT_EQ(1, rename_cb_count);
|
|
|
984
|
|
|
985 r = uv_fs_open(loop, &open_req1, "test_file2", UV_FS_O_RDWR, 0, open_cb);
|
|
|
986 ASSERT_OK(r);
|
|
|
987
|
|
|
988 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
989 ASSERT_EQ(1, open_cb_count);
|
|
|
990 ASSERT_EQ(1, read_cb_count);
|
|
|
991 ASSERT_EQ(2, close_cb_count);
|
|
|
992 ASSERT_EQ(1, rename_cb_count);
|
|
|
993 ASSERT_EQ(1, create_cb_count);
|
|
|
994 ASSERT_EQ(1, write_cb_count);
|
|
|
995 ASSERT_EQ(1, ftruncate_cb_count);
|
|
|
996
|
|
|
997 r = uv_fs_open(loop, &open_req1, "test_file2", UV_FS_O_RDONLY, 0, open_cb);
|
|
|
998 ASSERT_OK(r);
|
|
|
999
|
|
|
1000 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1001 ASSERT_EQ(2, open_cb_count);
|
|
|
1002 ASSERT_EQ(2, read_cb_count);
|
|
|
1003 ASSERT_EQ(3, close_cb_count);
|
|
|
1004 ASSERT_EQ(1, rename_cb_count);
|
|
|
1005 ASSERT_EQ(1, unlink_cb_count);
|
|
|
1006 ASSERT_EQ(1, create_cb_count);
|
|
|
1007 ASSERT_EQ(1, write_cb_count);
|
|
|
1008 ASSERT_EQ(1, ftruncate_cb_count);
|
|
|
1009
|
|
|
1010 /* Cleanup. */
|
|
|
1011 unlink("test_file");
|
|
|
1012 unlink("test_file2");
|
|
|
1013
|
|
|
1014 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1015 return 0;
|
|
|
1016 }
|
|
|
1017
|
|
|
1018
|
|
|
1019 static void fs_file_sync(int add_flags) {
|
|
|
1020 int r;
|
|
|
1021
|
|
|
1022 /* Setup. */
|
|
|
1023 unlink("test_file");
|
|
|
1024 unlink("test_file2");
|
|
|
1025
|
|
|
1026 loop = uv_default_loop();
|
|
|
1027
|
|
|
1028 r = uv_fs_open(loop, &open_req1, "test_file",
|
|
|
1029 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR,
|
|
|
1030 NULL);
|
|
|
1031 ASSERT_GE(r, 0);
|
|
|
1032 ASSERT_GE(open_req1.result, 0);
|
|
|
1033 uv_fs_req_cleanup(&open_req1);
|
|
|
1034
|
|
|
1035 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
1036 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
1037 ASSERT_GE(r, 0);
|
|
|
1038 ASSERT_GE(write_req.result, 0);
|
|
|
1039 uv_fs_req_cleanup(&write_req);
|
|
|
1040
|
|
|
1041 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
1042 ASSERT_OK(r);
|
|
|
1043 ASSERT_OK(close_req.result);
|
|
|
1044 uv_fs_req_cleanup(&close_req);
|
|
|
1045
|
|
|
1046 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDWR | add_flags, 0,
|
|
|
1047 NULL);
|
|
|
1048 ASSERT_GE(r, 0);
|
|
|
1049 ASSERT_GE(open_req1.result, 0);
|
|
|
1050 uv_fs_req_cleanup(&open_req1);
|
|
|
1051
|
|
|
1052 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
1053 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
1054 ASSERT_GE(r, 0);
|
|
|
1055 ASSERT_GE(read_req.result, 0);
|
|
|
1056 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
1057 uv_fs_req_cleanup(&read_req);
|
|
|
1058
|
|
|
1059 r = uv_fs_ftruncate(NULL, &ftruncate_req, open_req1.result, 7, NULL);
|
|
|
1060 ASSERT_OK(r);
|
|
|
1061 ASSERT_OK(ftruncate_req.result);
|
|
|
1062 uv_fs_req_cleanup(&ftruncate_req);
|
|
|
1063
|
|
|
1064 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
1065 ASSERT_OK(r);
|
|
|
1066 ASSERT_OK(close_req.result);
|
|
|
1067 uv_fs_req_cleanup(&close_req);
|
|
|
1068
|
|
|
1069 r = uv_fs_rename(NULL, &rename_req, "test_file", "test_file2", NULL);
|
|
|
1070 ASSERT_OK(r);
|
|
|
1071 ASSERT_OK(rename_req.result);
|
|
|
1072 uv_fs_req_cleanup(&rename_req);
|
|
|
1073
|
|
|
1074 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDONLY | add_flags, 0,
|
|
|
1075 NULL);
|
|
|
1076 ASSERT_GE(r, 0);
|
|
|
1077 ASSERT_GE(open_req1.result, 0);
|
|
|
1078 uv_fs_req_cleanup(&open_req1);
|
|
|
1079
|
|
|
1080 memset(buf, 0, sizeof(buf));
|
|
|
1081 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
1082 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
1083 ASSERT_GE(r, 0);
|
|
|
1084 ASSERT_GE(read_req.result, 0);
|
|
|
1085 ASSERT_OK(strcmp(buf, "test-bu"));
|
|
|
1086 uv_fs_req_cleanup(&read_req);
|
|
|
1087
|
|
|
1088 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
1089 ASSERT_OK(r);
|
|
|
1090 ASSERT_OK(close_req.result);
|
|
|
1091 uv_fs_req_cleanup(&close_req);
|
|
|
1092
|
|
|
1093 r = uv_fs_unlink(NULL, &unlink_req, "test_file2", NULL);
|
|
|
1094 ASSERT_OK(r);
|
|
|
1095 ASSERT_OK(unlink_req.result);
|
|
|
1096 uv_fs_req_cleanup(&unlink_req);
|
|
|
1097
|
|
|
1098 /* Cleanup */
|
|
|
1099 unlink("test_file");
|
|
|
1100 unlink("test_file2");
|
|
|
1101 }
|
|
|
1102 TEST_IMPL(fs_file_sync) {
|
|
|
1103 fs_file_sync(0);
|
|
|
1104 fs_file_sync(UV_FS_O_FILEMAP);
|
|
|
1105
|
|
|
1106 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1107 return 0;
|
|
|
1108 }
|
|
|
1109
|
|
|
1110 TEST_IMPL(fs_posix_delete) {
|
|
|
1111 int r;
|
|
|
1112
|
|
|
1113 /* Setup. */
|
|
|
1114 unlink("test_dir/file");
|
|
|
1115 rmdir("test_dir");
|
|
|
1116
|
|
|
1117 r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0755, NULL);
|
|
|
1118 ASSERT_OK(r);
|
|
|
1119
|
|
|
1120 r = uv_fs_open(NULL, &open_req_noclose, "test_dir/file", UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IWUSR | S_IRUSR, NULL);
|
|
|
1121 ASSERT_GE(r, 0);
|
|
|
1122 uv_fs_req_cleanup(&open_req_noclose);
|
|
|
1123
|
|
|
1124 /* should not be possible to delete the non-empty dir */
|
|
|
1125 r = uv_fs_rmdir(NULL, &rmdir_req, "test_dir", NULL);
|
|
|
1126 ASSERT((r == UV_ENOTEMPTY) || (r == UV_EEXIST));
|
|
|
1127 ASSERT_EQ(r, rmdir_req.result);
|
|
|
1128 uv_fs_req_cleanup(&rmdir_req);
|
|
|
1129
|
|
|
1130 r = uv_fs_rmdir(NULL, &rmdir_req, "test_dir/file", NULL);
|
|
|
1131 ASSERT((r == UV_ENOTDIR) || (r == UV_ENOENT));
|
|
|
1132 ASSERT_EQ(r, rmdir_req.result);
|
|
|
1133 uv_fs_req_cleanup(&rmdir_req);
|
|
|
1134
|
|
|
1135 r = uv_fs_unlink(NULL, &unlink_req, "test_dir/file", NULL);
|
|
|
1136 ASSERT_OK(r);
|
|
|
1137 ASSERT_OK(unlink_req.result);
|
|
|
1138 uv_fs_req_cleanup(&unlink_req);
|
|
|
1139
|
|
|
1140 /* delete the dir while the file is still open, which should succeed on posix */
|
|
|
1141 r = uv_fs_rmdir(NULL, &rmdir_req, "test_dir", NULL);
|
|
|
1142 ASSERT_OK(r);
|
|
|
1143 ASSERT_OK(rmdir_req.result);
|
|
|
1144 uv_fs_req_cleanup(&rmdir_req);
|
|
|
1145
|
|
|
1146 /* Cleanup */
|
|
|
1147 r = uv_fs_close(NULL, &close_req, open_req_noclose.result, NULL);
|
|
|
1148 ASSERT_OK(r);
|
|
|
1149 uv_fs_req_cleanup(&close_req);
|
|
|
1150
|
|
|
1151 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1152 return 0;
|
|
|
1153 }
|
|
|
1154
|
|
|
1155 static void fs_file_write_null_buffer(int add_flags) {
|
|
|
1156 int r;
|
|
|
1157
|
|
|
1158 /* Setup. */
|
|
|
1159 unlink("test_file");
|
|
|
1160
|
|
|
1161 loop = uv_default_loop();
|
|
|
1162
|
|
|
1163 r = uv_fs_open(NULL, &open_req1, "test_file",
|
|
|
1164 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR,
|
|
|
1165 NULL);
|
|
|
1166 ASSERT_GE(r, 0);
|
|
|
1167 ASSERT_GE(open_req1.result, 0);
|
|
|
1168 uv_fs_req_cleanup(&open_req1);
|
|
|
1169
|
|
|
1170 iov = uv_buf_init(NULL, 0);
|
|
|
1171 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
1172 ASSERT_OK(r);
|
|
|
1173 ASSERT_OK(write_req.result);
|
|
|
1174 uv_fs_req_cleanup(&write_req);
|
|
|
1175
|
|
|
1176 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
1177 ASSERT_OK(r);
|
|
|
1178 ASSERT_OK(close_req.result);
|
|
|
1179 uv_fs_req_cleanup(&close_req);
|
|
|
1180
|
|
|
1181 unlink("test_file");
|
|
|
1182 }
|
|
|
1183 TEST_IMPL(fs_file_write_null_buffer) {
|
|
|
1184 fs_file_write_null_buffer(0);
|
|
|
1185 fs_file_write_null_buffer(UV_FS_O_FILEMAP);
|
|
|
1186
|
|
|
1187 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1188 return 0;
|
|
|
1189 }
|
|
|
1190
|
|
|
1191
|
|
|
1192 TEST_IMPL(fs_async_dir) {
|
|
|
1193 int r;
|
|
|
1194 uv_dirent_t dent;
|
|
|
1195
|
|
|
1196 /* Setup */
|
|
|
1197 unlink("test_dir/file1");
|
|
|
1198 unlink("test_dir/file2");
|
|
|
1199 rmdir("test_dir");
|
|
|
1200
|
|
|
1201 loop = uv_default_loop();
|
|
|
1202
|
|
|
1203 r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb);
|
|
|
1204 ASSERT_OK(r);
|
|
|
1205
|
|
|
1206 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1207 ASSERT_EQ(1, mkdir_cb_count);
|
|
|
1208
|
|
|
1209 /* Create 2 files synchronously. */
|
|
|
1210 r = uv_fs_open(NULL, &open_req1, "test_dir/file1",
|
|
|
1211 UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
1212 S_IWUSR | S_IRUSR, NULL);
|
|
|
1213 ASSERT_GE(r, 0);
|
|
|
1214 uv_fs_req_cleanup(&open_req1);
|
|
|
1215 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
1216 ASSERT_OK(r);
|
|
|
1217 uv_fs_req_cleanup(&close_req);
|
|
|
1218
|
|
|
1219 r = uv_fs_open(NULL, &open_req1, "test_dir/file2",
|
|
|
1220 UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
1221 S_IWUSR | S_IRUSR, NULL);
|
|
|
1222 ASSERT_GE(r, 0);
|
|
|
1223 uv_fs_req_cleanup(&open_req1);
|
|
|
1224 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
1225 ASSERT_OK(r);
|
|
|
1226 uv_fs_req_cleanup(&close_req);
|
|
|
1227
|
|
|
1228 r = uv_fs_scandir(loop, &scandir_req, "test_dir", 0, scandir_cb);
|
|
|
1229 ASSERT_OK(r);
|
|
|
1230
|
|
|
1231 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1232 ASSERT_EQ(1, scandir_cb_count);
|
|
|
1233
|
|
|
1234 /* sync uv_fs_scandir */
|
|
|
1235 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL);
|
|
|
1236 ASSERT_EQ(2, r);
|
|
|
1237 ASSERT_EQ(2, scandir_req.result);
|
|
|
1238 ASSERT(scandir_req.ptr);
|
|
|
1239 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
|
|
|
1240 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
|
|
|
1241 assert_is_file_type(dent);
|
|
|
1242 }
|
|
|
1243 uv_fs_req_cleanup(&scandir_req);
|
|
|
1244 ASSERT(!scandir_req.ptr);
|
|
|
1245
|
|
|
1246 r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb);
|
|
|
1247 ASSERT_OK(r);
|
|
|
1248 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1249
|
|
|
1250 r = uv_fs_stat(loop, &stat_req, "test_dir/", stat_cb);
|
|
|
1251 ASSERT_OK(r);
|
|
|
1252 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1253
|
|
|
1254 r = uv_fs_lstat(loop, &stat_req, "test_dir", stat_cb);
|
|
|
1255 ASSERT_OK(r);
|
|
|
1256 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1257
|
|
|
1258 r = uv_fs_lstat(loop, &stat_req, "test_dir/", stat_cb);
|
|
|
1259 ASSERT_OK(r);
|
|
|
1260 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1261
|
|
|
1262 ASSERT_EQ(4, stat_cb_count);
|
|
|
1263
|
|
|
1264 r = uv_fs_unlink(loop, &unlink_req, "test_dir/file1", unlink_cb);
|
|
|
1265 ASSERT_OK(r);
|
|
|
1266 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1267 ASSERT_EQ(1, unlink_cb_count);
|
|
|
1268
|
|
|
1269 r = uv_fs_unlink(loop, &unlink_req, "test_dir/file2", unlink_cb);
|
|
|
1270 ASSERT_OK(r);
|
|
|
1271 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1272 ASSERT_EQ(2, unlink_cb_count);
|
|
|
1273
|
|
|
1274 r = uv_fs_rmdir(loop, &rmdir_req, "test_dir", rmdir_cb);
|
|
|
1275 ASSERT_OK(r);
|
|
|
1276 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1277 ASSERT_EQ(1, rmdir_cb_count);
|
|
|
1278
|
|
|
1279 /* Cleanup */
|
|
|
1280 unlink("test_dir/file1");
|
|
|
1281 unlink("test_dir/file2");
|
|
|
1282 rmdir("test_dir");
|
|
|
1283
|
|
|
1284 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1285 return 0;
|
|
|
1286 }
|
|
|
1287
|
|
|
1288
|
|
|
1289 static int test_sendfile(void (*setup)(int), uv_fs_cb cb, size_t expected_size) {
|
|
|
1290 int f, r;
|
|
|
1291 struct stat s1, s2;
|
|
|
1292 uv_fs_t req;
|
|
|
1293 char buf1[1];
|
|
|
1294
|
|
|
1295 loop = uv_default_loop();
|
|
|
1296
|
|
|
1297 /* Setup. */
|
|
|
1298 unlink("test_file");
|
|
|
1299 unlink("test_file2");
|
|
|
1300
|
|
|
1301 f = open("test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IWUSR | S_IRUSR);
|
|
|
1302 ASSERT_NE(f, -1);
|
|
|
1303
|
|
|
1304 if (setup != NULL)
|
|
|
1305 setup(f);
|
|
|
1306
|
|
|
1307 r = close(f);
|
|
|
1308 ASSERT_OK(r);
|
|
|
1309
|
|
|
1310 /* Test starts here. */
|
|
|
1311 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDWR, 0, NULL);
|
|
|
1312 ASSERT_GE(r, 0);
|
|
|
1313 ASSERT_GE(open_req1.result, 0);
|
|
|
1314 uv_fs_req_cleanup(&open_req1);
|
|
|
1315
|
|
|
1316 r = uv_fs_open(NULL, &open_req2, "test_file2", UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
1317 S_IWUSR | S_IRUSR, NULL);
|
|
|
1318 ASSERT_GE(r, 0);
|
|
|
1319 ASSERT_GE(open_req2.result, 0);
|
|
|
1320 uv_fs_req_cleanup(&open_req2);
|
|
|
1321
|
|
|
1322 r = uv_fs_sendfile(loop, &sendfile_req, open_req2.result, open_req1.result,
|
|
|
1323 1, 131072, cb);
|
|
|
1324 ASSERT_OK(r);
|
|
|
1325 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1326
|
|
|
1327 ASSERT_EQ(1, sendfile_cb_count);
|
|
|
1328
|
|
|
1329 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
1330 ASSERT_OK(r);
|
|
|
1331 uv_fs_req_cleanup(&close_req);
|
|
|
1332 r = uv_fs_close(NULL, &close_req, open_req2.result, NULL);
|
|
|
1333 ASSERT_OK(r);
|
|
|
1334 uv_fs_req_cleanup(&close_req);
|
|
|
1335
|
|
|
1336 memset(&s1, 0, sizeof(s1));
|
|
|
1337 memset(&s2, 0, sizeof(s2));
|
|
|
1338 ASSERT_OK(stat("test_file", &s1));
|
|
|
1339 ASSERT_OK(stat("test_file2", &s2));
|
|
|
1340 ASSERT_EQ(s2.st_size, expected_size);
|
|
|
1341
|
|
|
1342 if (expected_size > 0) {
|
|
|
1343 ASSERT_UINT64_EQ(s1.st_size, s2.st_size + 1);
|
|
|
1344 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDWR, 0, NULL);
|
|
|
1345 ASSERT_GE(r, 0);
|
|
|
1346 ASSERT_GE(open_req1.result, 0);
|
|
|
1347 uv_fs_req_cleanup(&open_req1);
|
|
|
1348
|
|
|
1349 memset(buf1, 0, sizeof(buf1));
|
|
|
1350 iov = uv_buf_init(buf1, sizeof(buf1));
|
|
|
1351 r = uv_fs_read(NULL, &req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
1352 ASSERT_GE(r, 0);
|
|
|
1353 ASSERT_GE(req.result, 0);
|
|
|
1354 ASSERT_EQ(buf1[0], 'e'); /* 'e' from begin */
|
|
|
1355 uv_fs_req_cleanup(&req);
|
|
|
1356 } else {
|
|
|
1357 ASSERT_UINT64_EQ(s1.st_size, s2.st_size);
|
|
|
1358 }
|
|
|
1359
|
|
|
1360 /* Cleanup. */
|
|
|
1361 unlink("test_file");
|
|
|
1362 unlink("test_file2");
|
|
|
1363
|
|
|
1364 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1365 return 0;
|
|
|
1366 }
|
|
|
1367
|
|
|
1368
|
|
|
1369 static void sendfile_setup(int f) {
|
|
|
1370 ASSERT_EQ(6, write(f, "begin\n", 6));
|
|
|
1371 ASSERT_EQ(65542, lseek(f, 65536, SEEK_CUR));
|
|
|
1372 ASSERT_EQ(4, write(f, "end\n", 4));
|
|
|
1373 }
|
|
|
1374
|
|
|
1375
|
|
|
1376 TEST_IMPL(fs_async_sendfile) {
|
|
|
1377 return test_sendfile(sendfile_setup, sendfile_cb, 65545);
|
|
|
1378 }
|
|
|
1379
|
|
|
1380
|
|
|
1381 TEST_IMPL(fs_async_sendfile_nodata) {
|
|
|
1382 return test_sendfile(NULL, sendfile_nodata_cb, 0);
|
|
|
1383 }
|
|
|
1384
|
|
|
1385
|
|
|
1386 TEST_IMPL(fs_mkdtemp) {
|
|
|
1387 int r;
|
|
|
1388 const char* path_template = "test_dir_XXXXXX";
|
|
|
1389
|
|
|
1390 loop = uv_default_loop();
|
|
|
1391
|
|
|
1392 r = uv_fs_mkdtemp(loop, &mkdtemp_req1, path_template, mkdtemp_cb);
|
|
|
1393 ASSERT_OK(r);
|
|
|
1394
|
|
|
1395 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1396 ASSERT_EQ(1, mkdtemp_cb_count);
|
|
|
1397
|
|
|
1398 /* sync mkdtemp */
|
|
|
1399 r = uv_fs_mkdtemp(NULL, &mkdtemp_req2, path_template, NULL);
|
|
|
1400 ASSERT_OK(r);
|
|
|
1401 check_mkdtemp_result(&mkdtemp_req2);
|
|
|
1402
|
|
|
1403 /* mkdtemp return different values on subsequent calls */
|
|
|
1404 ASSERT_NE(0, strcmp(mkdtemp_req1.path, mkdtemp_req2.path));
|
|
|
1405
|
|
|
1406 /* Cleanup */
|
|
|
1407 rmdir(mkdtemp_req1.path);
|
|
|
1408 rmdir(mkdtemp_req2.path);
|
|
|
1409 uv_fs_req_cleanup(&mkdtemp_req1);
|
|
|
1410 uv_fs_req_cleanup(&mkdtemp_req2);
|
|
|
1411
|
|
|
1412 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1413 return 0;
|
|
|
1414 }
|
|
|
1415
|
|
|
1416
|
|
|
1417 TEST_IMPL(fs_mkstemp) {
|
|
|
1418 int r;
|
|
|
1419 int fd;
|
|
|
1420 const char path_template[] = "test_file_XXXXXX";
|
|
|
1421 uv_fs_t req;
|
|
|
1422
|
|
|
1423 loop = uv_default_loop();
|
|
|
1424
|
|
|
1425 r = uv_fs_mkstemp(loop, &mkstemp_req1, path_template, mkstemp_cb);
|
|
|
1426 ASSERT_OK(r);
|
|
|
1427
|
|
|
1428 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1429 ASSERT_EQ(1, mkstemp_cb_count);
|
|
|
1430
|
|
|
1431 /* sync mkstemp */
|
|
|
1432 r = uv_fs_mkstemp(NULL, &mkstemp_req2, path_template, NULL);
|
|
|
1433 ASSERT_GE(r, 0);
|
|
|
1434 check_mkstemp_result(&mkstemp_req2);
|
|
|
1435
|
|
|
1436 /* mkstemp return different values on subsequent calls */
|
|
|
1437 ASSERT_NE(0, strcmp(mkstemp_req1.path, mkstemp_req2.path));
|
|
|
1438
|
|
|
1439 /* invalid template returns EINVAL */
|
|
|
1440 ASSERT_EQ(UV_EINVAL, uv_fs_mkstemp(NULL, &mkstemp_req3, "test_file", NULL));
|
|
|
1441
|
|
|
1442 /* Make sure that path is empty string */
|
|
|
1443 ASSERT_OK(strlen(mkstemp_req3.path));
|
|
|
1444
|
|
|
1445 uv_fs_req_cleanup(&mkstemp_req3);
|
|
|
1446
|
|
|
1447 /* We can write to the opened file */
|
|
|
1448 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
1449 r = uv_fs_write(NULL, &req, mkstemp_req1.result, &iov, 1, -1, NULL);
|
|
|
1450 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
1451 ASSERT_EQ(req.result, sizeof(test_buf));
|
|
|
1452 uv_fs_req_cleanup(&req);
|
|
|
1453
|
|
|
1454 /* Cleanup */
|
|
|
1455 uv_fs_close(NULL, &req, mkstemp_req1.result, NULL);
|
|
|
1456 uv_fs_req_cleanup(&req);
|
|
|
1457 uv_fs_close(NULL, &req, mkstemp_req2.result, NULL);
|
|
|
1458 uv_fs_req_cleanup(&req);
|
|
|
1459
|
|
|
1460 fd = uv_fs_open(NULL, &req, mkstemp_req1.path, UV_FS_O_RDONLY, 0, NULL);
|
|
|
1461 ASSERT_GE(fd, 0);
|
|
|
1462 uv_fs_req_cleanup(&req);
|
|
|
1463
|
|
|
1464 memset(buf, 0, sizeof(buf));
|
|
|
1465 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
1466 r = uv_fs_read(NULL, &req, fd, &iov, 1, -1, NULL);
|
|
|
1467 ASSERT_GE(r, 0);
|
|
|
1468 ASSERT_GE(req.result, 0);
|
|
|
1469 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
1470 uv_fs_req_cleanup(&req);
|
|
|
1471
|
|
|
1472 uv_fs_close(NULL, &req, fd, NULL);
|
|
|
1473 uv_fs_req_cleanup(&req);
|
|
|
1474
|
|
|
1475 unlink(mkstemp_req1.path);
|
|
|
1476 unlink(mkstemp_req2.path);
|
|
|
1477 uv_fs_req_cleanup(&mkstemp_req1);
|
|
|
1478 uv_fs_req_cleanup(&mkstemp_req2);
|
|
|
1479
|
|
|
1480 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1481 return 0;
|
|
|
1482 }
|
|
|
1483
|
|
|
1484
|
|
|
1485 TEST_IMPL(fs_fstat) {
|
|
|
1486 int r;
|
|
|
1487 uv_fs_t req;
|
|
|
1488 uv_file file;
|
|
|
1489 uv_stat_t* s;
|
|
|
1490 #ifndef _WIN32
|
|
|
1491 struct stat t;
|
|
|
1492 #endif
|
|
|
1493
|
|
|
1494 #if defined(__s390__) && defined(__QEMU__)
|
|
|
1495 /* qemu-user-s390x has this weird bug where statx() reports nanoseconds
|
|
|
1496 * but plain fstat() does not.
|
|
|
1497 */
|
|
|
1498 RETURN_SKIP("Test does not currently work in QEMU");
|
|
|
1499 #endif
|
|
|
1500
|
|
|
1501 /* Setup. */
|
|
|
1502 unlink("test_file");
|
|
|
1503
|
|
|
1504 loop = uv_default_loop();
|
|
|
1505
|
|
|
1506 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
1507 S_IWUSR | S_IRUSR, NULL);
|
|
|
1508 ASSERT_GE(r, 0);
|
|
|
1509 ASSERT_GE(req.result, 0);
|
|
|
1510 file = req.result;
|
|
|
1511 uv_fs_req_cleanup(&req);
|
|
|
1512
|
|
|
1513 #ifndef _WIN32
|
|
|
1514 memset(&t, 0, sizeof(t));
|
|
|
1515 ASSERT_OK(fstat(file, &t));
|
|
|
1516 ASSERT_OK(uv_fs_fstat(NULL, &req, file, NULL));
|
|
|
1517 ASSERT_OK(req.result);
|
|
|
1518 s = req.ptr;
|
|
|
1519 # if defined(__APPLE__)
|
|
|
1520 ASSERT_EQ(s->st_birthtim.tv_sec, t.st_birthtimespec.tv_sec);
|
|
|
1521 ASSERT_EQ(s->st_birthtim.tv_nsec, t.st_birthtimespec.tv_nsec);
|
|
|
1522 # elif defined(__linux__)
|
|
|
1523 /* If statx() is supported, the birth time should be equal to the change time
|
|
|
1524 * because we just created the file. On older kernels, it's set to zero.
|
|
|
1525 */
|
|
|
1526 ASSERT(s->st_birthtim.tv_sec == 0 ||
|
|
|
1527 s->st_birthtim.tv_sec == t.st_ctim.tv_sec);
|
|
|
1528 ASSERT(s->st_birthtim.tv_nsec == 0 ||
|
|
|
1529 s->st_birthtim.tv_nsec == t.st_ctim.tv_nsec);
|
|
|
1530 # endif
|
|
|
1531 #endif
|
|
|
1532
|
|
|
1533 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
1534 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL);
|
|
|
1535 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
1536 ASSERT_EQ(req.result, sizeof(test_buf));
|
|
|
1537 uv_fs_req_cleanup(&req);
|
|
|
1538
|
|
|
1539 memset(&req.statbuf, 0xaa, sizeof(req.statbuf));
|
|
|
1540 r = uv_fs_fstat(NULL, &req, file, NULL);
|
|
|
1541 ASSERT_OK(r);
|
|
|
1542 ASSERT_OK(req.result);
|
|
|
1543 s = req.ptr;
|
|
|
1544 ASSERT_EQ(s->st_size, sizeof(test_buf));
|
|
|
1545
|
|
|
1546 #ifndef _WIN32
|
|
|
1547 r = fstat(file, &t);
|
|
|
1548 ASSERT_OK(r);
|
|
|
1549
|
|
|
1550 ASSERT_EQ(s->st_dev, (uint64_t) t.st_dev);
|
|
|
1551 ASSERT_EQ(s->st_mode, (uint64_t) t.st_mode);
|
|
|
1552 ASSERT_EQ(s->st_nlink, (uint64_t) t.st_nlink);
|
|
|
1553 ASSERT_EQ(s->st_uid, (uint64_t) t.st_uid);
|
|
|
1554 ASSERT_EQ(s->st_gid, (uint64_t) t.st_gid);
|
|
|
1555 ASSERT_EQ(s->st_rdev, (uint64_t) t.st_rdev);
|
|
|
1556 ASSERT_EQ(s->st_ino, (uint64_t) t.st_ino);
|
|
|
1557 ASSERT_EQ(s->st_size, (uint64_t) t.st_size);
|
|
|
1558 ASSERT_EQ(s->st_blksize, (uint64_t) t.st_blksize);
|
|
|
1559 ASSERT_EQ(s->st_blocks, (uint64_t) t.st_blocks);
|
|
|
1560 #if defined(__APPLE__)
|
|
|
1561 ASSERT_EQ(s->st_atim.tv_sec, t.st_atimespec.tv_sec);
|
|
|
1562 ASSERT_EQ(s->st_atim.tv_nsec, t.st_atimespec.tv_nsec);
|
|
|
1563 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtimespec.tv_sec);
|
|
|
1564 ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtimespec.tv_nsec);
|
|
|
1565 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctimespec.tv_sec);
|
|
|
1566 ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctimespec.tv_nsec);
|
|
|
1567 #elif defined(_AIX) || \
|
|
|
1568 defined(__MVS__)
|
|
|
1569 ASSERT_EQ(s->st_atim.tv_sec, t.st_atime);
|
|
|
1570 ASSERT_OK(s->st_atim.tv_nsec);
|
|
|
1571 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime);
|
|
|
1572 ASSERT_OK(s->st_mtim.tv_nsec);
|
|
|
1573 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime);
|
|
|
1574 ASSERT_OK(s->st_ctim.tv_nsec);
|
|
|
1575 #elif defined(__ANDROID__)
|
|
|
1576 ASSERT_EQ(s->st_atim.tv_sec, t.st_atime);
|
|
|
1577 ASSERT_EQ(s->st_atim.tv_nsec, t.st_atimensec);
|
|
|
1578 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime);
|
|
|
1579 ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtimensec);
|
|
|
1580 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime);
|
|
|
1581 ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctimensec);
|
|
|
1582 #elif defined(__sun) || \
|
|
|
1583 defined(__DragonFly__) || \
|
|
|
1584 defined(__FreeBSD__) || \
|
|
|
1585 defined(__OpenBSD__) || \
|
|
|
1586 defined(__NetBSD__) || \
|
|
|
1587 defined(_GNU_SOURCE) || \
|
|
|
1588 defined(_BSD_SOURCE) || \
|
|
|
1589 defined(_SVID_SOURCE) || \
|
|
|
1590 defined(_XOPEN_SOURCE) || \
|
|
|
1591 defined(_DEFAULT_SOURCE)
|
|
|
1592 ASSERT_EQ(s->st_atim.tv_sec, t.st_atim.tv_sec);
|
|
|
1593 ASSERT_EQ(s->st_atim.tv_nsec, t.st_atim.tv_nsec);
|
|
|
1594 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtim.tv_sec);
|
|
|
1595 ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtim.tv_nsec);
|
|
|
1596 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctim.tv_sec);
|
|
|
1597 ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctim.tv_nsec);
|
|
|
1598 # if defined(__FreeBSD__) || \
|
|
|
1599 defined(__NetBSD__)
|
|
|
1600 ASSERT_EQ(s->st_birthtim.tv_sec, t.st_birthtim.tv_sec);
|
|
|
1601 ASSERT_EQ(s->st_birthtim.tv_nsec, t.st_birthtim.tv_nsec);
|
|
|
1602 # endif
|
|
|
1603 #else
|
|
|
1604 ASSERT_EQ(s->st_atim.tv_sec, t.st_atime);
|
|
|
1605 ASSERT_OK(s->st_atim.tv_nsec);
|
|
|
1606 ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime);
|
|
|
1607 ASSERT_OK(s->st_mtim.tv_nsec);
|
|
|
1608 ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime);
|
|
|
1609 ASSERT_OK(s->st_ctim.tv_nsec);
|
|
|
1610 #endif
|
|
|
1611 #endif
|
|
|
1612
|
|
|
1613 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
|
|
|
1614 ASSERT_EQ(s->st_flags, t.st_flags);
|
|
|
1615 ASSERT_EQ(s->st_gen, t.st_gen);
|
|
|
1616 #else
|
|
|
1617 ASSERT_OK(s->st_flags);
|
|
|
1618 ASSERT_OK(s->st_gen);
|
|
|
1619 #endif
|
|
|
1620
|
|
|
1621 uv_fs_req_cleanup(&req);
|
|
|
1622
|
|
|
1623 /* Now do the uv_fs_fstat call asynchronously */
|
|
|
1624 r = uv_fs_fstat(loop, &req, file, fstat_cb);
|
|
|
1625 ASSERT_OK(r);
|
|
|
1626 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1627 ASSERT_EQ(1, fstat_cb_count);
|
|
|
1628
|
|
|
1629
|
|
|
1630 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
1631 ASSERT_OK(r);
|
|
|
1632 ASSERT_OK(req.result);
|
|
|
1633 uv_fs_req_cleanup(&req);
|
|
|
1634
|
|
|
1635 /*
|
|
|
1636 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
1637 * calls. This should drop out immediately.
|
|
|
1638 */
|
|
|
1639 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1640
|
|
|
1641 /* Cleanup. */
|
|
|
1642 unlink("test_file");
|
|
|
1643
|
|
|
1644 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1645 return 0;
|
|
|
1646 }
|
|
|
1647
|
|
|
1648
|
|
|
1649 TEST_IMPL(fs_fstat_st_dev) {
|
|
|
1650 uv_fs_t req;
|
|
|
1651 uv_fs_t req_link;
|
|
|
1652 uv_loop_t* loop = uv_default_loop();
|
|
|
1653 char* test_file = "tmp_st_dev";
|
|
|
1654 char* symlink_file = "tmp_st_dev_link";
|
|
|
1655
|
|
|
1656 unlink(test_file);
|
|
|
1657 unlink(symlink_file);
|
|
|
1658
|
|
|
1659 // Create file
|
|
|
1660 int r = uv_fs_open(NULL, &req, test_file, UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
1661 S_IWUSR | S_IRUSR, NULL);
|
|
|
1662 ASSERT_GE(r, 0);
|
|
|
1663 ASSERT_GE(req.result, 0);
|
|
|
1664 uv_fs_req_cleanup(&req);
|
|
|
1665
|
|
|
1666 // Create a symlink
|
|
|
1667 r = uv_fs_symlink(loop, &req, test_file, symlink_file, 0, NULL);
|
|
|
1668 ASSERT_EQ(r, 0);
|
|
|
1669 uv_fs_req_cleanup(&req);
|
|
|
1670
|
|
|
1671 // Call uv_fs_fstat for file
|
|
|
1672 r = uv_fs_stat(loop, &req, test_file, NULL);
|
|
|
1673 ASSERT_EQ(r, 0);
|
|
|
1674
|
|
|
1675 // Call uv_fs_fstat for symlink
|
|
|
1676 r = uv_fs_stat(loop, &req_link, symlink_file, NULL);
|
|
|
1677 ASSERT_EQ(r, 0);
|
|
|
1678
|
|
|
1679 // Compare st_dev
|
|
|
1680 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_dev, ((uv_stat_t*)req_link.ptr)->st_dev);
|
|
|
1681
|
|
|
1682 // Cleanup
|
|
|
1683 uv_fs_req_cleanup(&req);
|
|
|
1684 uv_fs_req_cleanup(&req_link);
|
|
|
1685 unlink(test_file);
|
|
|
1686 unlink(symlink_file);
|
|
|
1687
|
|
|
1688 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1689 return 0;
|
|
|
1690 }
|
|
|
1691
|
|
|
1692
|
|
|
1693 TEST_IMPL(fs_fstat_stdio) {
|
|
|
1694 int fd;
|
|
|
1695 int res;
|
|
|
1696 uv_fs_t req;
|
|
|
1697 #ifdef _WIN32
|
|
|
1698 uv_stat_t* st;
|
|
|
1699 DWORD ft;
|
|
|
1700 #endif
|
|
|
1701
|
|
|
1702 for (fd = 0; fd <= 2; ++fd) {
|
|
|
1703 res = uv_fs_fstat(NULL, &req, fd, NULL);
|
|
|
1704 ASSERT_OK(res);
|
|
|
1705 ASSERT_OK(req.result);
|
|
|
1706
|
|
|
1707 #ifdef _WIN32
|
|
|
1708 st = req.ptr;
|
|
|
1709 ft = uv_guess_handle(fd);
|
|
|
1710 switch (ft) {
|
|
|
1711 case UV_TTY:
|
|
|
1712 case UV_NAMED_PIPE:
|
|
|
1713 ASSERT_EQ(st->st_mode, (ft == UV_TTY ? S_IFCHR : S_IFIFO));
|
|
|
1714 ASSERT_EQ(1, st->st_nlink);
|
|
|
1715 ASSERT_EQ(st->st_rdev,
|
|
|
1716 (ft == UV_TTY ? FILE_DEVICE_CONSOLE : FILE_DEVICE_NAMED_PIPE)
|
|
|
1717 << 16);
|
|
|
1718 break;
|
|
|
1719 default:
|
|
|
1720 break;
|
|
|
1721 }
|
|
|
1722 #endif
|
|
|
1723
|
|
|
1724 uv_fs_req_cleanup(&req);
|
|
|
1725 }
|
|
|
1726
|
|
|
1727 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1728 return 0;
|
|
|
1729 }
|
|
|
1730
|
|
|
1731
|
|
|
1732 TEST_IMPL(fs_access) {
|
|
|
1733 int r;
|
|
|
1734 uv_fs_t req;
|
|
|
1735 uv_file file;
|
|
|
1736
|
|
|
1737 /* Setup. */
|
|
|
1738 unlink("test_file");
|
|
|
1739 rmdir("test_dir");
|
|
|
1740
|
|
|
1741 loop = uv_default_loop();
|
|
|
1742
|
|
|
1743 /* File should not exist */
|
|
|
1744 r = uv_fs_access(NULL, &req, "test_file", F_OK, NULL);
|
|
|
1745 ASSERT_LT(r, 0);
|
|
|
1746 ASSERT_LT(req.result, 0);
|
|
|
1747 uv_fs_req_cleanup(&req);
|
|
|
1748
|
|
|
1749 /* File should not exist */
|
|
|
1750 r = uv_fs_access(loop, &req, "test_file", F_OK, access_cb);
|
|
|
1751 ASSERT_OK(r);
|
|
|
1752 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1753 ASSERT_EQ(1, access_cb_count);
|
|
|
1754 access_cb_count = 0; /* reset for the next test */
|
|
|
1755
|
|
|
1756 /* Create file */
|
|
|
1757 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
1758 S_IWUSR | S_IRUSR, NULL);
|
|
|
1759 ASSERT_GE(r, 0);
|
|
|
1760 ASSERT_GE(req.result, 0);
|
|
|
1761 file = req.result;
|
|
|
1762 uv_fs_req_cleanup(&req);
|
|
|
1763
|
|
|
1764 /* File should exist */
|
|
|
1765 r = uv_fs_access(NULL, &req, "test_file", F_OK, NULL);
|
|
|
1766 ASSERT_OK(r);
|
|
|
1767 ASSERT_OK(req.result);
|
|
|
1768 uv_fs_req_cleanup(&req);
|
|
|
1769
|
|
|
1770 /* File should exist */
|
|
|
1771 r = uv_fs_access(loop, &req, "test_file", F_OK, access_cb);
|
|
|
1772 ASSERT_OK(r);
|
|
|
1773 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1774 ASSERT_EQ(1, access_cb_count);
|
|
|
1775 access_cb_count = 0; /* reset for the next test */
|
|
|
1776
|
|
|
1777 /* Close file */
|
|
|
1778 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
1779 ASSERT_OK(r);
|
|
|
1780 ASSERT_OK(req.result);
|
|
|
1781 uv_fs_req_cleanup(&req);
|
|
|
1782
|
|
|
1783 /* Directory access */
|
|
|
1784 r = uv_fs_mkdir(NULL, &req, "test_dir", 0777, NULL);
|
|
|
1785 ASSERT_OK(r);
|
|
|
1786 uv_fs_req_cleanup(&req);
|
|
|
1787
|
|
|
1788 r = uv_fs_access(NULL, &req, "test_dir", W_OK, NULL);
|
|
|
1789 ASSERT_OK(r);
|
|
|
1790 ASSERT_OK(req.result);
|
|
|
1791 uv_fs_req_cleanup(&req);
|
|
|
1792
|
|
|
1793 /*
|
|
|
1794 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
1795 * calls. This should drop out immediately.
|
|
|
1796 */
|
|
|
1797 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1798
|
|
|
1799 /* Cleanup. */
|
|
|
1800 unlink("test_file");
|
|
|
1801 rmdir("test_dir");
|
|
|
1802
|
|
|
1803 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1804 return 0;
|
|
|
1805 }
|
|
|
1806
|
|
|
1807
|
|
|
1808 TEST_IMPL(fs_chmod) {
|
|
|
1809 int r;
|
|
|
1810 uv_fs_t req;
|
|
|
1811 uv_file file;
|
|
|
1812
|
|
|
1813 /* Setup. */
|
|
|
1814 unlink("test_file");
|
|
|
1815
|
|
|
1816 loop = uv_default_loop();
|
|
|
1817
|
|
|
1818 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
1819 S_IWUSR | S_IRUSR, NULL);
|
|
|
1820 ASSERT_GE(r, 0);
|
|
|
1821 ASSERT_GE(req.result, 0);
|
|
|
1822 file = req.result;
|
|
|
1823 uv_fs_req_cleanup(&req);
|
|
|
1824
|
|
|
1825 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
1826 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL);
|
|
|
1827 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
1828 ASSERT_EQ(req.result, sizeof(test_buf));
|
|
|
1829 uv_fs_req_cleanup(&req);
|
|
|
1830
|
|
|
1831 #ifndef _WIN32
|
|
|
1832 /* Make the file write-only */
|
|
|
1833 r = uv_fs_chmod(NULL, &req, "test_file", 0200, NULL);
|
|
|
1834 ASSERT_OK(r);
|
|
|
1835 ASSERT_OK(req.result);
|
|
|
1836 uv_fs_req_cleanup(&req);
|
|
|
1837
|
|
|
1838 check_permission("test_file", 0200);
|
|
|
1839 #endif
|
|
|
1840
|
|
|
1841 /* Make the file read-only */
|
|
|
1842 r = uv_fs_chmod(NULL, &req, "test_file", 0400, NULL);
|
|
|
1843 ASSERT_OK(r);
|
|
|
1844 ASSERT_OK(req.result);
|
|
|
1845 uv_fs_req_cleanup(&req);
|
|
|
1846
|
|
|
1847 check_permission("test_file", 0400);
|
|
|
1848
|
|
|
1849 /* Make the file read+write with sync uv_fs_fchmod */
|
|
|
1850 r = uv_fs_fchmod(NULL, &req, file, 0600, NULL);
|
|
|
1851 ASSERT_OK(r);
|
|
|
1852 ASSERT_OK(req.result);
|
|
|
1853 uv_fs_req_cleanup(&req);
|
|
|
1854
|
|
|
1855 check_permission("test_file", 0600);
|
|
|
1856
|
|
|
1857 #ifndef _WIN32
|
|
|
1858 /* async chmod */
|
|
|
1859 {
|
|
|
1860 static int mode = 0200;
|
|
|
1861 req.data = &mode;
|
|
|
1862 }
|
|
|
1863 r = uv_fs_chmod(loop, &req, "test_file", 0200, chmod_cb);
|
|
|
1864 ASSERT_OK(r);
|
|
|
1865 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1866 ASSERT_EQ(1, chmod_cb_count);
|
|
|
1867 chmod_cb_count = 0; /* reset for the next test */
|
|
|
1868 #endif
|
|
|
1869
|
|
|
1870 /* async chmod */
|
|
|
1871 {
|
|
|
1872 static int mode = 0400;
|
|
|
1873 req.data = &mode;
|
|
|
1874 }
|
|
|
1875 r = uv_fs_chmod(loop, &req, "test_file", 0400, chmod_cb);
|
|
|
1876 ASSERT_OK(r);
|
|
|
1877 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1878 ASSERT_EQ(1, chmod_cb_count);
|
|
|
1879
|
|
|
1880 /* async fchmod */
|
|
|
1881 {
|
|
|
1882 static int mode = 0600;
|
|
|
1883 req.data = &mode;
|
|
|
1884 }
|
|
|
1885 r = uv_fs_fchmod(loop, &req, file, 0600, fchmod_cb);
|
|
|
1886 ASSERT_OK(r);
|
|
|
1887 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1888 ASSERT_EQ(1, fchmod_cb_count);
|
|
|
1889
|
|
|
1890 uv_fs_close(loop, &req, file, NULL);
|
|
|
1891
|
|
|
1892 /*
|
|
|
1893 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
1894 * calls. This should drop out immediately.
|
|
|
1895 */
|
|
|
1896 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1897
|
|
|
1898 /* Cleanup. */
|
|
|
1899 unlink("test_file");
|
|
|
1900
|
|
|
1901 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1902 return 0;
|
|
|
1903 }
|
|
|
1904
|
|
|
1905
|
|
|
1906 TEST_IMPL(fs_unlink_readonly) {
|
|
|
1907 int r;
|
|
|
1908 uv_fs_t req;
|
|
|
1909 uv_file file;
|
|
|
1910
|
|
|
1911 /* Setup. */
|
|
|
1912 unlink("test_file");
|
|
|
1913
|
|
|
1914 loop = uv_default_loop();
|
|
|
1915
|
|
|
1916 r = uv_fs_open(NULL,
|
|
|
1917 &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
1918 S_IWUSR | S_IRUSR,
|
|
|
1919 NULL);
|
|
|
1920 ASSERT_GE(r, 0);
|
|
|
1921 ASSERT_GE(req.result, 0);
|
|
|
1922 file = req.result;
|
|
|
1923 uv_fs_req_cleanup(&req);
|
|
|
1924
|
|
|
1925 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
1926 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL);
|
|
|
1927 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
1928 ASSERT_EQ(req.result, sizeof(test_buf));
|
|
|
1929 uv_fs_req_cleanup(&req);
|
|
|
1930
|
|
|
1931 uv_fs_close(loop, &req, file, NULL);
|
|
|
1932
|
|
|
1933 /* Make the file read-only */
|
|
|
1934 r = uv_fs_chmod(NULL, &req, "test_file", 0400, NULL);
|
|
|
1935 ASSERT_OK(r);
|
|
|
1936 ASSERT_OK(req.result);
|
|
|
1937 uv_fs_req_cleanup(&req);
|
|
|
1938
|
|
|
1939 check_permission("test_file", 0400);
|
|
|
1940
|
|
|
1941 /* Try to unlink the file */
|
|
|
1942 r = uv_fs_unlink(NULL, &req, "test_file", NULL);
|
|
|
1943 ASSERT_OK(r);
|
|
|
1944 ASSERT_OK(req.result);
|
|
|
1945 uv_fs_req_cleanup(&req);
|
|
|
1946
|
|
|
1947 /*
|
|
|
1948 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
1949 * calls. This should drop out immediately.
|
|
|
1950 */
|
|
|
1951 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1952
|
|
|
1953 /* Cleanup. */
|
|
|
1954 uv_fs_chmod(NULL, &req, "test_file", 0600, NULL);
|
|
|
1955 uv_fs_req_cleanup(&req);
|
|
|
1956 unlink("test_file");
|
|
|
1957
|
|
|
1958 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1959 return 0;
|
|
|
1960 }
|
|
|
1961
|
|
|
1962 #ifdef _WIN32
|
|
|
1963 TEST_IMPL(fs_unlink_archive_readonly) {
|
|
|
1964 int r;
|
|
|
1965 uv_fs_t req;
|
|
|
1966 uv_file file;
|
|
|
1967
|
|
|
1968 /* Setup. */
|
|
|
1969 unlink("test_file");
|
|
|
1970
|
|
|
1971 loop = uv_default_loop();
|
|
|
1972
|
|
|
1973 r = uv_fs_open(NULL,
|
|
|
1974 &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
1975 S_IWUSR | S_IRUSR,
|
|
|
1976 NULL);
|
|
|
1977 ASSERT_GE(r, 0);
|
|
|
1978 ASSERT_GE(req.result, 0);
|
|
|
1979 file = req.result;
|
|
|
1980 uv_fs_req_cleanup(&req);
|
|
|
1981
|
|
|
1982 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
1983 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL);
|
|
|
1984 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
1985 ASSERT_EQ(req.result, sizeof(test_buf));
|
|
|
1986 uv_fs_req_cleanup(&req);
|
|
|
1987
|
|
|
1988 uv_fs_close(loop, &req, file, NULL);
|
|
|
1989
|
|
|
1990 /* Make the file read-only and clear archive flag */
|
|
|
1991 r = SetFileAttributes("test_file", FILE_ATTRIBUTE_READONLY);
|
|
|
1992 ASSERT(r);
|
|
|
1993 uv_fs_req_cleanup(&req);
|
|
|
1994
|
|
|
1995 check_permission("test_file", 0400);
|
|
|
1996
|
|
|
1997 /* Try to unlink the file */
|
|
|
1998 r = uv_fs_unlink(NULL, &req, "test_file", NULL);
|
|
|
1999 ASSERT_OK(r);
|
|
|
2000 ASSERT_OK(req.result);
|
|
|
2001 uv_fs_req_cleanup(&req);
|
|
|
2002
|
|
|
2003 /*
|
|
|
2004 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
2005 * calls. This should drop out immediately.
|
|
|
2006 */
|
|
|
2007 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2008
|
|
|
2009 /* Cleanup. */
|
|
|
2010 uv_fs_chmod(NULL, &req, "test_file", 0600, NULL);
|
|
|
2011 uv_fs_req_cleanup(&req);
|
|
|
2012 unlink("test_file");
|
|
|
2013
|
|
|
2014 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2015 return 0;
|
|
|
2016 }
|
|
|
2017 #endif
|
|
|
2018
|
|
|
2019 TEST_IMPL(fs_chown) {
|
|
|
2020 int r;
|
|
|
2021 uv_fs_t req;
|
|
|
2022 uv_file file;
|
|
|
2023
|
|
|
2024 /* Setup. */
|
|
|
2025 unlink("test_file");
|
|
|
2026 unlink("test_file_link");
|
|
|
2027
|
|
|
2028 loop = uv_default_loop();
|
|
|
2029
|
|
|
2030 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
2031 S_IWUSR | S_IRUSR, NULL);
|
|
|
2032 ASSERT_GE(r, 0);
|
|
|
2033 ASSERT_GE(req.result, 0);
|
|
|
2034 file = req.result;
|
|
|
2035 uv_fs_req_cleanup(&req);
|
|
|
2036
|
|
|
2037 /* sync chown */
|
|
|
2038 r = uv_fs_chown(NULL, &req, "test_file", -1, -1, NULL);
|
|
|
2039 ASSERT_OK(r);
|
|
|
2040 ASSERT_OK(req.result);
|
|
|
2041 uv_fs_req_cleanup(&req);
|
|
|
2042
|
|
|
2043 /* sync fchown */
|
|
|
2044 r = uv_fs_fchown(NULL, &req, file, -1, -1, NULL);
|
|
|
2045 ASSERT_OK(r);
|
|
|
2046 ASSERT_OK(req.result);
|
|
|
2047 uv_fs_req_cleanup(&req);
|
|
|
2048
|
|
|
2049 /* async chown */
|
|
|
2050 r = uv_fs_chown(loop, &req, "test_file", -1, -1, chown_cb);
|
|
|
2051 ASSERT_OK(r);
|
|
|
2052 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2053 ASSERT_EQ(1, chown_cb_count);
|
|
|
2054
|
|
|
2055 #ifndef __MVS__
|
|
|
2056 /* chown to root (fail) */
|
|
|
2057 chown_cb_count = 0;
|
|
|
2058 r = uv_fs_chown(loop, &req, "test_file", 0, 0, chown_root_cb);
|
|
|
2059 ASSERT_OK(r);
|
|
|
2060 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2061 ASSERT_EQ(1, chown_cb_count);
|
|
|
2062 #endif
|
|
|
2063
|
|
|
2064 /* async fchown */
|
|
|
2065 r = uv_fs_fchown(loop, &req, file, -1, -1, fchown_cb);
|
|
|
2066 ASSERT_OK(r);
|
|
|
2067 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2068 ASSERT_EQ(1, fchown_cb_count);
|
|
|
2069
|
|
|
2070 #ifndef __HAIKU__
|
|
|
2071 /* Haiku doesn't support hardlink */
|
|
|
2072 /* sync link */
|
|
|
2073 r = uv_fs_link(NULL, &req, "test_file", "test_file_link", NULL);
|
|
|
2074 ASSERT_OK(r);
|
|
|
2075 ASSERT_OK(req.result);
|
|
|
2076 uv_fs_req_cleanup(&req);
|
|
|
2077
|
|
|
2078 /* sync lchown */
|
|
|
2079 r = uv_fs_lchown(NULL, &req, "test_file_link", -1, -1, NULL);
|
|
|
2080 ASSERT_OK(r);
|
|
|
2081 ASSERT_OK(req.result);
|
|
|
2082 uv_fs_req_cleanup(&req);
|
|
|
2083
|
|
|
2084 /* async lchown */
|
|
|
2085 r = uv_fs_lchown(loop, &req, "test_file_link", -1, -1, lchown_cb);
|
|
|
2086 ASSERT_OK(r);
|
|
|
2087 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2088 ASSERT_EQ(1, lchown_cb_count);
|
|
|
2089 #endif
|
|
|
2090
|
|
|
2091 /* Close file */
|
|
|
2092 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
2093 ASSERT_OK(r);
|
|
|
2094 ASSERT_OK(req.result);
|
|
|
2095 uv_fs_req_cleanup(&req);
|
|
|
2096
|
|
|
2097 /*
|
|
|
2098 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
2099 * calls. This should drop out immediately.
|
|
|
2100 */
|
|
|
2101 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2102
|
|
|
2103 /* Cleanup. */
|
|
|
2104 unlink("test_file");
|
|
|
2105 unlink("test_file_link");
|
|
|
2106
|
|
|
2107 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2108 return 0;
|
|
|
2109 }
|
|
|
2110
|
|
|
2111
|
|
|
2112 TEST_IMPL(fs_link) {
|
|
|
2113 int r;
|
|
|
2114 uv_fs_t req;
|
|
|
2115 uv_file file;
|
|
|
2116 uv_file link;
|
|
|
2117
|
|
|
2118 /* Setup. */
|
|
|
2119 unlink("test_file");
|
|
|
2120 unlink("test_file_link");
|
|
|
2121 unlink("test_file_link2");
|
|
|
2122
|
|
|
2123 loop = uv_default_loop();
|
|
|
2124
|
|
|
2125 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
2126 S_IWUSR | S_IRUSR, NULL);
|
|
|
2127 ASSERT_GE(r, 0);
|
|
|
2128 ASSERT_GE(req.result, 0);
|
|
|
2129 file = req.result;
|
|
|
2130 uv_fs_req_cleanup(&req);
|
|
|
2131
|
|
|
2132 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
2133 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL);
|
|
|
2134 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
2135 ASSERT_EQ(req.result, sizeof(test_buf));
|
|
|
2136 uv_fs_req_cleanup(&req);
|
|
|
2137
|
|
|
2138 uv_fs_close(loop, &req, file, NULL);
|
|
|
2139
|
|
|
2140 /* sync link */
|
|
|
2141 r = uv_fs_link(NULL, &req, "test_file", "test_file_link", NULL);
|
|
|
2142 ASSERT_OK(r);
|
|
|
2143 ASSERT_OK(req.result);
|
|
|
2144 uv_fs_req_cleanup(&req);
|
|
|
2145
|
|
|
2146 r = uv_fs_open(NULL, &req, "test_file_link", UV_FS_O_RDWR, 0, NULL);
|
|
|
2147 ASSERT_GE(r, 0);
|
|
|
2148 ASSERT_GE(req.result, 0);
|
|
|
2149 link = req.result;
|
|
|
2150 uv_fs_req_cleanup(&req);
|
|
|
2151
|
|
|
2152 memset(buf, 0, sizeof(buf));
|
|
|
2153 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
2154 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL);
|
|
|
2155 ASSERT_GE(r, 0);
|
|
|
2156 ASSERT_GE(req.result, 0);
|
|
|
2157 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
2158
|
|
|
2159 close(link);
|
|
|
2160
|
|
|
2161 /* async link */
|
|
|
2162 r = uv_fs_link(loop, &req, "test_file", "test_file_link2", link_cb);
|
|
|
2163 ASSERT_OK(r);
|
|
|
2164 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2165 ASSERT_EQ(1, link_cb_count);
|
|
|
2166
|
|
|
2167 r = uv_fs_open(NULL, &req, "test_file_link2", UV_FS_O_RDWR, 0, NULL);
|
|
|
2168 ASSERT_GE(r, 0);
|
|
|
2169 ASSERT_GE(req.result, 0);
|
|
|
2170 link = req.result;
|
|
|
2171 uv_fs_req_cleanup(&req);
|
|
|
2172
|
|
|
2173 memset(buf, 0, sizeof(buf));
|
|
|
2174 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
2175 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL);
|
|
|
2176 ASSERT_GE(r, 0);
|
|
|
2177 ASSERT_GE(req.result, 0);
|
|
|
2178 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
2179
|
|
|
2180 uv_fs_close(loop, &req, link, NULL);
|
|
|
2181
|
|
|
2182 /*
|
|
|
2183 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
2184 * calls. This should drop out immediately.
|
|
|
2185 */
|
|
|
2186 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2187
|
|
|
2188 /* Cleanup. */
|
|
|
2189 unlink("test_file");
|
|
|
2190 unlink("test_file_link");
|
|
|
2191 unlink("test_file_link2");
|
|
|
2192
|
|
|
2193 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2194 return 0;
|
|
|
2195 }
|
|
|
2196
|
|
|
2197
|
|
|
2198 TEST_IMPL(fs_readlink) {
|
|
|
2199 /* Must return UV_ENOENT on an inexistent file */
|
|
|
2200 {
|
|
|
2201 uv_fs_t req;
|
|
|
2202
|
|
|
2203 loop = uv_default_loop();
|
|
|
2204 ASSERT_OK(uv_fs_readlink(loop, &req, "no_such_file", dummy_cb));
|
|
|
2205 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
2206 ASSERT_EQ(1, dummy_cb_count);
|
|
|
2207 ASSERT_NULL(req.ptr);
|
|
|
2208 ASSERT_EQ(req.result, UV_ENOENT);
|
|
|
2209 uv_fs_req_cleanup(&req);
|
|
|
2210
|
|
|
2211 ASSERT_EQ(UV_ENOENT, uv_fs_readlink(NULL, &req, "no_such_file", NULL));
|
|
|
2212 ASSERT_NULL(req.ptr);
|
|
|
2213 ASSERT_EQ(req.result, UV_ENOENT);
|
|
|
2214 uv_fs_req_cleanup(&req);
|
|
|
2215 }
|
|
|
2216
|
|
|
2217 /* Must return UV_EINVAL on a non-symlink file */
|
|
|
2218 {
|
|
|
2219 int r;
|
|
|
2220 uv_fs_t req;
|
|
|
2221 uv_file file;
|
|
|
2222
|
|
|
2223 /* Setup */
|
|
|
2224
|
|
|
2225 /* Create a non-symlink file */
|
|
|
2226 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
2227 S_IWUSR | S_IRUSR, NULL);
|
|
|
2228 ASSERT_GE(r, 0);
|
|
|
2229 ASSERT_GE(req.result, 0);
|
|
|
2230 file = req.result;
|
|
|
2231 uv_fs_req_cleanup(&req);
|
|
|
2232
|
|
|
2233 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
2234 ASSERT_OK(r);
|
|
|
2235 ASSERT_OK(req.result);
|
|
|
2236 uv_fs_req_cleanup(&req);
|
|
|
2237
|
|
|
2238 /* Test */
|
|
|
2239 r = uv_fs_readlink(NULL, &req, "test_file", NULL);
|
|
|
2240 ASSERT_EQ(r, UV_EINVAL);
|
|
|
2241 uv_fs_req_cleanup(&req);
|
|
|
2242
|
|
|
2243 /* Cleanup */
|
|
|
2244 unlink("test_file");
|
|
|
2245 }
|
|
|
2246
|
|
|
2247 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2248 return 0;
|
|
|
2249 }
|
|
|
2250
|
|
|
2251
|
|
|
2252 TEST_IMPL(fs_realpath) {
|
|
|
2253 uv_fs_t req;
|
|
|
2254
|
|
|
2255 loop = uv_default_loop();
|
|
|
2256 ASSERT_OK(uv_fs_realpath(loop, &req, "no_such_file", dummy_cb));
|
|
|
2257 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
2258 ASSERT_EQ(1, dummy_cb_count);
|
|
|
2259 ASSERT_NULL(req.ptr);
|
|
|
2260 ASSERT_EQ(req.result, UV_ENOENT);
|
|
|
2261 uv_fs_req_cleanup(&req);
|
|
|
2262
|
|
|
2263 ASSERT_EQ(UV_ENOENT, uv_fs_realpath(NULL, &req, "no_such_file", NULL));
|
|
|
2264 ASSERT_NULL(req.ptr);
|
|
|
2265 ASSERT_EQ(req.result, UV_ENOENT);
|
|
|
2266 uv_fs_req_cleanup(&req);
|
|
|
2267
|
|
|
2268 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2269 return 0;
|
|
|
2270 }
|
|
|
2271
|
|
|
2272
|
|
|
2273 TEST_IMPL(fs_symlink) {
|
|
|
2274 int r;
|
|
|
2275 uv_fs_t req;
|
|
|
2276 uv_file file;
|
|
|
2277 uv_file link;
|
|
|
2278 char test_file_abs_buf[PATHMAX];
|
|
|
2279 size_t test_file_abs_size;
|
|
|
2280
|
|
|
2281 /* Setup. */
|
|
|
2282 unlink("test_file");
|
|
|
2283 unlink("test_file_symlink");
|
|
|
2284 unlink("test_file_symlink2");
|
|
|
2285 unlink("test_file_symlink_symlink");
|
|
|
2286 unlink("test_file_symlink2_symlink");
|
|
|
2287 test_file_abs_size = sizeof(test_file_abs_buf);
|
|
|
2288 #ifdef _WIN32
|
|
|
2289 uv_cwd(test_file_abs_buf, &test_file_abs_size);
|
|
|
2290 strcat(test_file_abs_buf, "\\test_file");
|
|
|
2291 #else
|
|
|
2292 uv_cwd(test_file_abs_buf, &test_file_abs_size);
|
|
|
2293 strcat(test_file_abs_buf, "/test_file");
|
|
|
2294 #endif
|
|
|
2295
|
|
|
2296 loop = uv_default_loop();
|
|
|
2297
|
|
|
2298 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
2299 S_IWUSR | S_IRUSR, NULL);
|
|
|
2300 ASSERT_GE(r, 0);
|
|
|
2301 ASSERT_GE(req.result, 0);
|
|
|
2302 file = req.result;
|
|
|
2303 uv_fs_req_cleanup(&req);
|
|
|
2304
|
|
|
2305 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
2306 r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL);
|
|
|
2307 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
2308 ASSERT_EQ(req.result, sizeof(test_buf));
|
|
|
2309 uv_fs_req_cleanup(&req);
|
|
|
2310
|
|
|
2311 uv_fs_close(loop, &req, file, NULL);
|
|
|
2312
|
|
|
2313 /* sync symlink */
|
|
|
2314 r = uv_fs_symlink(NULL, &req, "test_file", "test_file_symlink", 0, NULL);
|
|
|
2315 #ifdef _WIN32
|
|
|
2316 if (r < 0) {
|
|
|
2317 if (r == UV_ENOTSUP) {
|
|
|
2318 /*
|
|
|
2319 * Windows doesn't support symlinks on older versions.
|
|
|
2320 * We just pass the test and bail out early if we get ENOTSUP.
|
|
|
2321 */
|
|
|
2322 return 0;
|
|
|
2323 } else if (r == UV_EPERM) {
|
|
|
2324 /*
|
|
|
2325 * Creating a symlink is only allowed when running elevated.
|
|
|
2326 * We pass the test and bail out early if we get UV_EPERM.
|
|
|
2327 */
|
|
|
2328 return 0;
|
|
|
2329 }
|
|
|
2330 }
|
|
|
2331 #endif
|
|
|
2332 ASSERT_OK(r);
|
|
|
2333 ASSERT_OK(req.result);
|
|
|
2334 uv_fs_req_cleanup(&req);
|
|
|
2335
|
|
|
2336 r = uv_fs_open(NULL, &req, "test_file_symlink", UV_FS_O_RDWR, 0, NULL);
|
|
|
2337 ASSERT_GE(r, 0);
|
|
|
2338 ASSERT_GE(req.result, 0);
|
|
|
2339 link = req.result;
|
|
|
2340 uv_fs_req_cleanup(&req);
|
|
|
2341
|
|
|
2342 memset(buf, 0, sizeof(buf));
|
|
|
2343 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
2344 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL);
|
|
|
2345 ASSERT_GE(r, 0);
|
|
|
2346 ASSERT_GE(req.result, 0);
|
|
|
2347 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
2348
|
|
|
2349 uv_fs_close(loop, &req, link, NULL);
|
|
|
2350
|
|
|
2351 r = uv_fs_symlink(NULL,
|
|
|
2352 &req,
|
|
|
2353 "test_file_symlink",
|
|
|
2354 "test_file_symlink_symlink",
|
|
|
2355 0,
|
|
|
2356 NULL);
|
|
|
2357 ASSERT_OK(r);
|
|
|
2358 uv_fs_req_cleanup(&req);
|
|
|
2359
|
|
|
2360 #if defined(__MSYS__)
|
|
|
2361 RETURN_SKIP("symlink reading is not supported on MSYS2");
|
|
|
2362 #endif
|
|
|
2363
|
|
|
2364 r = uv_fs_readlink(NULL, &req, "test_file_symlink_symlink", NULL);
|
|
|
2365 ASSERT_OK(r);
|
|
|
2366 ASSERT_OK(strcmp(req.ptr, "test_file_symlink"));
|
|
|
2367 uv_fs_req_cleanup(&req);
|
|
|
2368
|
|
|
2369 r = uv_fs_realpath(NULL, &req, "test_file_symlink_symlink", NULL);
|
|
|
2370 ASSERT_OK(r);
|
|
|
2371 #ifdef _WIN32
|
|
|
2372 ASSERT_OK(_stricmp(req.ptr, test_file_abs_buf));
|
|
|
2373 #else
|
|
|
2374 ASSERT_OK(strcmp(req.ptr, test_file_abs_buf));
|
|
|
2375 #endif
|
|
|
2376 uv_fs_req_cleanup(&req);
|
|
|
2377
|
|
|
2378 /* async link */
|
|
|
2379 r = uv_fs_symlink(loop,
|
|
|
2380 &req,
|
|
|
2381 "test_file",
|
|
|
2382 "test_file_symlink2",
|
|
|
2383 0,
|
|
|
2384 symlink_cb);
|
|
|
2385 ASSERT_OK(r);
|
|
|
2386 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2387 ASSERT_EQ(1, symlink_cb_count);
|
|
|
2388
|
|
|
2389 r = uv_fs_open(NULL, &req, "test_file_symlink2", UV_FS_O_RDWR, 0, NULL);
|
|
|
2390 ASSERT_GE(r, 0);
|
|
|
2391 ASSERT_GE(req.result, 0);
|
|
|
2392 link = req.result;
|
|
|
2393 uv_fs_req_cleanup(&req);
|
|
|
2394
|
|
|
2395 memset(buf, 0, sizeof(buf));
|
|
|
2396 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
2397 r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL);
|
|
|
2398 ASSERT_GE(r, 0);
|
|
|
2399 ASSERT_GE(req.result, 0);
|
|
|
2400 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
2401
|
|
|
2402 uv_fs_close(loop, &req, link, NULL);
|
|
|
2403
|
|
|
2404 r = uv_fs_symlink(NULL,
|
|
|
2405 &req,
|
|
|
2406 "test_file_symlink2",
|
|
|
2407 "test_file_symlink2_symlink",
|
|
|
2408 0,
|
|
|
2409 NULL);
|
|
|
2410 ASSERT_OK(r);
|
|
|
2411 uv_fs_req_cleanup(&req);
|
|
|
2412
|
|
|
2413 r = uv_fs_readlink(loop, &req, "test_file_symlink2_symlink", readlink_cb);
|
|
|
2414 ASSERT_OK(r);
|
|
|
2415 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2416 ASSERT_EQ(1, readlink_cb_count);
|
|
|
2417
|
|
|
2418 r = uv_fs_realpath(loop, &req, "test_file", realpath_cb);
|
|
|
2419 ASSERT_OK(r);
|
|
|
2420 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2421 ASSERT_EQ(1, realpath_cb_count);
|
|
|
2422
|
|
|
2423 /*
|
|
|
2424 * Run the loop just to check we don't have make any extraneous uv_ref()
|
|
|
2425 * calls. This should drop out immediately.
|
|
|
2426 */
|
|
|
2427 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2428
|
|
|
2429 /* Cleanup. */
|
|
|
2430 unlink("test_file");
|
|
|
2431 unlink("test_file_symlink");
|
|
|
2432 unlink("test_file_symlink_symlink");
|
|
|
2433 unlink("test_file_symlink2");
|
|
|
2434 unlink("test_file_symlink2_symlink");
|
|
|
2435
|
|
|
2436 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2437 return 0;
|
|
|
2438 }
|
|
|
2439
|
|
|
2440
|
|
|
2441 int test_symlink_dir_impl(int type) {
|
|
|
2442 uv_fs_t req;
|
|
|
2443 int r;
|
|
|
2444 char* test_dir;
|
|
|
2445 uv_dirent_t dent;
|
|
|
2446 static char test_dir_abs_buf[PATHMAX];
|
|
|
2447 size_t test_dir_abs_size;
|
|
|
2448
|
|
|
2449 /* set-up */
|
|
|
2450 unlink("test_dir/file1");
|
|
|
2451 unlink("test_dir/file2");
|
|
|
2452 rmdir("test_dir");
|
|
|
2453 rmdir("test_dir_symlink");
|
|
|
2454 test_dir_abs_size = sizeof(test_dir_abs_buf);
|
|
|
2455
|
|
|
2456 loop = uv_default_loop();
|
|
|
2457
|
|
|
2458 uv_fs_mkdir(NULL, &req, "test_dir", 0777, NULL);
|
|
|
2459 uv_fs_req_cleanup(&req);
|
|
|
2460
|
|
|
2461 #ifdef _WIN32
|
|
|
2462 strcpy(test_dir_abs_buf, "\\\\?\\");
|
|
|
2463 uv_cwd(test_dir_abs_buf + 4, &test_dir_abs_size);
|
|
|
2464 test_dir_abs_size += 4;
|
|
|
2465 strcat(test_dir_abs_buf, "\\test_dir");
|
|
|
2466 test_dir_abs_size += strlen("\\test_dir");
|
|
|
2467 test_dir = test_dir_abs_buf;
|
|
|
2468 #else
|
|
|
2469 uv_cwd(test_dir_abs_buf, &test_dir_abs_size);
|
|
|
2470 strcat(test_dir_abs_buf, "/test_dir");
|
|
|
2471 test_dir_abs_size += strlen("/test_dir");
|
|
|
2472 test_dir = "test_dir";
|
|
|
2473 #endif
|
|
|
2474
|
|
|
2475 r = uv_fs_symlink(NULL, &req, test_dir, "test_dir_symlink", type, NULL);
|
|
|
2476 if (type == UV_FS_SYMLINK_DIR && (r == UV_ENOTSUP || r == UV_EPERM)) {
|
|
|
2477 uv_fs_req_cleanup(&req);
|
|
|
2478 RETURN_SKIP("this version of Windows doesn't support unprivileged "
|
|
|
2479 "creation of directory symlinks");
|
|
|
2480 }
|
|
|
2481 fprintf(stderr, "r == %i\n", r);
|
|
|
2482 ASSERT_OK(r);
|
|
|
2483 ASSERT_OK(req.result);
|
|
|
2484 uv_fs_req_cleanup(&req);
|
|
|
2485
|
|
|
2486 r = uv_fs_stat(NULL, &req, "test_dir_symlink", NULL);
|
|
|
2487 ASSERT_OK(r);
|
|
|
2488 ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFDIR);
|
|
|
2489 uv_fs_req_cleanup(&req);
|
|
|
2490
|
|
|
2491 r = uv_fs_lstat(NULL, &req, "test_dir_symlink", NULL);
|
|
|
2492 ASSERT_OK(r);
|
|
|
2493 #if defined(__MSYS__)
|
|
|
2494 RETURN_SKIP("symlink reading is not supported on MSYS2");
|
|
|
2495 #endif
|
|
|
2496 ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFLNK);
|
|
|
2497 #ifdef _WIN32
|
|
|
2498 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen(test_dir + 4));
|
|
|
2499 #else
|
|
|
2500 # ifdef __PASE__
|
|
|
2501 /* On IBMi PASE, st_size returns the length of the symlink itself. */
|
|
|
2502 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen("test_dir_symlink"));
|
|
|
2503 # else
|
|
|
2504 ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen(test_dir));
|
|
|
2505 # endif
|
|
|
2506 #endif
|
|
|
2507 uv_fs_req_cleanup(&req);
|
|
|
2508
|
|
|
2509 r = uv_fs_readlink(NULL, &req, "test_dir_symlink", NULL);
|
|
|
2510 ASSERT_OK(r);
|
|
|
2511 #ifdef _WIN32
|
|
|
2512 ASSERT_OK(strcmp(req.ptr, test_dir + 4));
|
|
|
2513 #else
|
|
|
2514 ASSERT_OK(strcmp(req.ptr, test_dir));
|
|
|
2515 #endif
|
|
|
2516 uv_fs_req_cleanup(&req);
|
|
|
2517
|
|
|
2518 r = uv_fs_realpath(NULL, &req, "test_dir_symlink", NULL);
|
|
|
2519 ASSERT_OK(r);
|
|
|
2520 #ifdef _WIN32
|
|
|
2521 ASSERT_EQ(strlen(req.ptr), test_dir_abs_size - 4);
|
|
|
2522 ASSERT_OK(_strnicmp(req.ptr, test_dir + 4, test_dir_abs_size - 4));
|
|
|
2523 #else
|
|
|
2524 ASSERT_OK(strcmp(req.ptr, test_dir_abs_buf));
|
|
|
2525 #endif
|
|
|
2526 uv_fs_req_cleanup(&req);
|
|
|
2527
|
|
|
2528 r = uv_fs_open(NULL, &open_req1, "test_dir/file1",
|
|
|
2529 UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
2530 S_IWUSR | S_IRUSR, NULL);
|
|
|
2531 ASSERT_GE(r, 0);
|
|
|
2532 uv_fs_req_cleanup(&open_req1);
|
|
|
2533 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
2534 ASSERT_OK(r);
|
|
|
2535 uv_fs_req_cleanup(&close_req);
|
|
|
2536
|
|
|
2537 r = uv_fs_open(NULL, &open_req1, "test_dir/file2",
|
|
|
2538 UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
2539 S_IWUSR | S_IRUSR, NULL);
|
|
|
2540 ASSERT_GE(r, 0);
|
|
|
2541 uv_fs_req_cleanup(&open_req1);
|
|
|
2542 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
2543 ASSERT_OK(r);
|
|
|
2544 uv_fs_req_cleanup(&close_req);
|
|
|
2545
|
|
|
2546 r = uv_fs_scandir(NULL, &scandir_req, "test_dir_symlink", 0, NULL);
|
|
|
2547 ASSERT_EQ(2, r);
|
|
|
2548 ASSERT_EQ(2, scandir_req.result);
|
|
|
2549 ASSERT(scandir_req.ptr);
|
|
|
2550 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
|
|
|
2551 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
|
|
|
2552 assert_is_file_type(dent);
|
|
|
2553 }
|
|
|
2554 uv_fs_req_cleanup(&scandir_req);
|
|
|
2555 ASSERT(!scandir_req.ptr);
|
|
|
2556
|
|
|
2557 /* unlink will remove the directory symlink */
|
|
|
2558 r = uv_fs_unlink(NULL, &req, "test_dir_symlink", NULL);
|
|
|
2559 ASSERT_OK(r);
|
|
|
2560 uv_fs_req_cleanup(&req);
|
|
|
2561
|
|
|
2562 r = uv_fs_scandir(NULL, &scandir_req, "test_dir_symlink", 0, NULL);
|
|
|
2563 ASSERT_EQ(r, UV_ENOENT);
|
|
|
2564 uv_fs_req_cleanup(&scandir_req);
|
|
|
2565
|
|
|
2566 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL);
|
|
|
2567 ASSERT_EQ(2, r);
|
|
|
2568 ASSERT_EQ(2, scandir_req.result);
|
|
|
2569 ASSERT(scandir_req.ptr);
|
|
|
2570 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
|
|
|
2571 ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
|
|
|
2572 assert_is_file_type(dent);
|
|
|
2573 }
|
|
|
2574 uv_fs_req_cleanup(&scandir_req);
|
|
|
2575 ASSERT(!scandir_req.ptr);
|
|
|
2576
|
|
|
2577 /* clean-up */
|
|
|
2578 unlink("test_dir/file1");
|
|
|
2579 unlink("test_dir/file2");
|
|
|
2580 rmdir("test_dir");
|
|
|
2581 rmdir("test_dir_symlink");
|
|
|
2582
|
|
|
2583 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2584 return 0;
|
|
|
2585 }
|
|
|
2586
|
|
|
2587 TEST_IMPL(fs_symlink_dir) {
|
|
|
2588 return test_symlink_dir_impl(UV_FS_SYMLINK_DIR);
|
|
|
2589 }
|
|
|
2590
|
|
|
2591 TEST_IMPL(fs_symlink_junction) {
|
|
|
2592 return test_symlink_dir_impl(UV_FS_SYMLINK_JUNCTION);
|
|
|
2593 }
|
|
|
2594
|
|
|
2595 #ifdef _WIN32
|
|
|
2596 TEST_IMPL(fs_non_symlink_reparse_point) {
|
|
|
2597 uv_fs_t req;
|
|
|
2598 int r;
|
|
|
2599 HANDLE file_handle;
|
|
|
2600 REPARSE_GUID_DATA_BUFFER reparse_buffer;
|
|
|
2601 DWORD bytes_returned;
|
|
|
2602 uv_dirent_t dent;
|
|
|
2603
|
|
|
2604 /* set-up */
|
|
|
2605 unlink("test_dir/test_file");
|
|
|
2606 rmdir("test_dir");
|
|
|
2607
|
|
|
2608 loop = uv_default_loop();
|
|
|
2609
|
|
|
2610 uv_fs_mkdir(NULL, &req, "test_dir", 0777, NULL);
|
|
|
2611 uv_fs_req_cleanup(&req);
|
|
|
2612
|
|
|
2613 file_handle = CreateFile("test_dir/test_file",
|
|
|
2614 GENERIC_WRITE | FILE_WRITE_ATTRIBUTES,
|
|
|
2615 0,
|
|
|
2616 NULL,
|
|
|
2617 CREATE_ALWAYS,
|
|
|
2618 FILE_FLAG_OPEN_REPARSE_POINT |
|
|
|
2619 FILE_FLAG_BACKUP_SEMANTICS,
|
|
|
2620 NULL);
|
|
|
2621 ASSERT_PTR_NE(file_handle, INVALID_HANDLE_VALUE);
|
|
|
2622
|
|
|
2623 memset(&reparse_buffer, 0, REPARSE_GUID_DATA_BUFFER_HEADER_SIZE);
|
|
|
2624 reparse_buffer.ReparseTag = REPARSE_TAG;
|
|
|
2625 reparse_buffer.ReparseDataLength = 0;
|
|
|
2626 reparse_buffer.ReparseGuid = REPARSE_GUID;
|
|
|
2627
|
|
|
2628 r = DeviceIoControl(file_handle,
|
|
|
2629 FSCTL_SET_REPARSE_POINT,
|
|
|
2630 &reparse_buffer,
|
|
|
2631 REPARSE_GUID_DATA_BUFFER_HEADER_SIZE,
|
|
|
2632 NULL,
|
|
|
2633 0,
|
|
|
2634 &bytes_returned,
|
|
|
2635 NULL);
|
|
|
2636 ASSERT(r);
|
|
|
2637
|
|
|
2638 CloseHandle(file_handle);
|
|
|
2639
|
|
|
2640 r = uv_fs_readlink(NULL, &req, "test_dir/test_file", NULL);
|
|
|
2641 ASSERT(r == UV_EINVAL && GetLastError() == ERROR_SYMLINK_NOT_SUPPORTED);
|
|
|
2642 uv_fs_req_cleanup(&req);
|
|
|
2643
|
|
|
2644 /*
|
|
|
2645 Placeholder tests for exercising the behavior fixed in issue #995.
|
|
|
2646 To run, update the path with the IP address of a Mac with the hard drive
|
|
|
2647 shared via SMB as "Macintosh HD".
|
|
|
2648
|
|
|
2649 r = uv_fs_stat(NULL, &req, "\\\\<mac_ip>\\Macintosh HD\\.DS_Store", NULL);
|
|
|
2650 ASSERT_OK(r);
|
|
|
2651 uv_fs_req_cleanup(&req);
|
|
|
2652
|
|
|
2653 r = uv_fs_lstat(NULL, &req, "\\\\<mac_ip>\\Macintosh HD\\.DS_Store", NULL);
|
|
|
2654 ASSERT_OK(r);
|
|
|
2655 uv_fs_req_cleanup(&req);
|
|
|
2656 */
|
|
|
2657
|
|
|
2658 /*
|
|
|
2659 uv_fs_stat and uv_fs_lstat can only work on non-symlink reparse
|
|
|
2660 points when a minifilter driver is registered which intercepts
|
|
|
2661 associated filesystem requests. Installing a driver is beyond
|
|
|
2662 the scope of this test.
|
|
|
2663
|
|
|
2664 r = uv_fs_stat(NULL, &req, "test_dir/test_file", NULL);
|
|
|
2665 ASSERT_OK(r);
|
|
|
2666 uv_fs_req_cleanup(&req);
|
|
|
2667
|
|
|
2668 r = uv_fs_lstat(NULL, &req, "test_dir/test_file", NULL);
|
|
|
2669 ASSERT_OK(r);
|
|
|
2670 uv_fs_req_cleanup(&req);
|
|
|
2671 */
|
|
|
2672
|
|
|
2673 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL);
|
|
|
2674 ASSERT_EQ(1, r);
|
|
|
2675 ASSERT_EQ(1, scandir_req.result);
|
|
|
2676 ASSERT(scandir_req.ptr);
|
|
|
2677 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
|
|
|
2678 ASSERT_OK(strcmp(dent.name, "test_file"));
|
|
|
2679 /* uv_fs_scandir incorrectly identifies non-symlink reparse points
|
|
|
2680 as links because it doesn't open the file and verify the reparse
|
|
|
2681 point tag. The PowerShell Get-ChildItem command shares this
|
|
|
2682 behavior, so it's reasonable to leave it as is. */
|
|
|
2683 ASSERT_EQ(dent.type, UV_DIRENT_LINK);
|
|
|
2684 }
|
|
|
2685 uv_fs_req_cleanup(&scandir_req);
|
|
|
2686 ASSERT(!scandir_req.ptr);
|
|
|
2687
|
|
|
2688 /* clean-up */
|
|
|
2689 unlink("test_dir/test_file");
|
|
|
2690 rmdir("test_dir");
|
|
|
2691
|
|
|
2692 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2693 return 0;
|
|
|
2694 }
|
|
|
2695
|
|
|
2696 TEST_IMPL(fs_lstat_windows_store_apps) {
|
|
|
2697 uv_loop_t* loop;
|
|
|
2698 char localappdata[MAX_PATH];
|
|
|
2699 char windowsapps_path[MAX_PATH];
|
|
|
2700 char file_path[MAX_PATH];
|
|
|
2701 size_t len;
|
|
|
2702 int r;
|
|
|
2703 uv_fs_t req;
|
|
|
2704 uv_fs_t stat_req;
|
|
|
2705 uv_dirent_t dirent;
|
|
|
2706
|
|
|
2707 loop = uv_default_loop();
|
|
|
2708 ASSERT_NOT_NULL(loop);
|
|
|
2709 len = sizeof(localappdata);
|
|
|
2710 r = uv_os_getenv("LOCALAPPDATA", localappdata, &len);
|
|
|
2711 if (r == UV_ENOENT) {
|
|
|
2712 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2713 return TEST_SKIP;
|
|
|
2714 }
|
|
|
2715 ASSERT_OK(r);
|
|
|
2716 r = snprintf(windowsapps_path,
|
|
|
2717 sizeof(localappdata),
|
|
|
2718 "%s\\Microsoft\\WindowsApps",
|
|
|
2719 localappdata);
|
|
|
2720 ASSERT_GT(r, 0);
|
|
|
2721 if (uv_fs_opendir(loop, &req, windowsapps_path, NULL) != 0) {
|
|
|
2722 /* If we cannot read the directory, skip the test. */
|
|
|
2723 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2724 return TEST_SKIP;
|
|
|
2725 }
|
|
|
2726 if (uv_fs_scandir(loop, &req, windowsapps_path, 0, NULL) <= 0) {
|
|
|
2727 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2728 return TEST_SKIP;
|
|
|
2729 }
|
|
|
2730 while (uv_fs_scandir_next(&req, &dirent) != UV_EOF) {
|
|
|
2731 if (dirent.type != UV_DIRENT_LINK) {
|
|
|
2732 continue;
|
|
|
2733 }
|
|
|
2734 if (snprintf(file_path,
|
|
|
2735 sizeof(file_path),
|
|
|
2736 "%s\\%s",
|
|
|
2737 windowsapps_path,
|
|
|
2738 dirent.name) < 0) {
|
|
|
2739 continue;
|
|
|
2740 }
|
|
|
2741 ASSERT_OK(uv_fs_lstat(loop, &stat_req, file_path, NULL));
|
|
|
2742 }
|
|
|
2743 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2744 return 0;
|
|
|
2745 }
|
|
|
2746 #endif
|
|
|
2747
|
|
|
2748
|
|
|
2749 TEST_IMPL(fs_utime) {
|
|
|
2750 utime_check_t checkme;
|
|
|
2751 const char* path = "test_file";
|
|
|
2752 double atime;
|
|
|
2753 double mtime;
|
|
|
2754 uv_fs_t req;
|
|
|
2755 int r;
|
|
|
2756
|
|
|
2757 /* Setup. */
|
|
|
2758 loop = uv_default_loop();
|
|
|
2759 unlink(path);
|
|
|
2760 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
2761 S_IWUSR | S_IRUSR,
|
|
|
2762 NULL);
|
|
|
2763 ASSERT_GE(r, 0);
|
|
|
2764 ASSERT_GE(req.result, 0);
|
|
|
2765 uv_fs_req_cleanup(&req);
|
|
|
2766 uv_fs_close(loop, &req, r, NULL);
|
|
|
2767
|
|
|
2768 atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */
|
|
|
2769
|
|
|
2770 ASSERT_OK(uv_fs_utime(NULL, &req, path, atime, mtime, NULL));
|
|
|
2771 ASSERT_OK(req.result);
|
|
|
2772 uv_fs_req_cleanup(&req);
|
|
|
2773 check_utime(path, atime, mtime, /* test_lutime */ 0);
|
|
|
2774
|
|
|
2775 ASSERT_OK(uv_fs_utime(NULL,
|
|
|
2776 &req,
|
|
|
2777 path,
|
|
|
2778 UV_FS_UTIME_OMIT,
|
|
|
2779 UV_FS_UTIME_OMIT,
|
|
|
2780 NULL));
|
|
|
2781 ASSERT_OK(req.result);
|
|
|
2782 uv_fs_req_cleanup(&req);
|
|
|
2783 check_utime(path, atime, mtime, /* test_lutime */ 0);
|
|
|
2784
|
|
|
2785 ASSERT_OK(uv_fs_utime(NULL,
|
|
|
2786 &req,
|
|
|
2787 path,
|
|
|
2788 UV_FS_UTIME_NOW,
|
|
|
2789 UV_FS_UTIME_OMIT,
|
|
|
2790 NULL));
|
|
|
2791 ASSERT_OK(req.result);
|
|
|
2792 uv_fs_req_cleanup(&req);
|
|
|
2793 check_utime(path, UV_FS_UTIME_NOW, mtime, /* test_lutime */ 0);
|
|
|
2794
|
|
|
2795 ASSERT_OK(uv_fs_utime(NULL, &req, path, atime, mtime, NULL));
|
|
|
2796 ASSERT_OK(req.result);
|
|
|
2797 uv_fs_req_cleanup(&req);
|
|
|
2798 check_utime(path, atime, mtime, /* test_lutime */ 0);
|
|
|
2799
|
|
|
2800 ASSERT_OK(uv_fs_utime(NULL,
|
|
|
2801 &req,
|
|
|
2802 path,
|
|
|
2803 UV_FS_UTIME_OMIT,
|
|
|
2804 UV_FS_UTIME_NOW,
|
|
|
2805 NULL));
|
|
|
2806 ASSERT_OK(req.result);
|
|
|
2807 uv_fs_req_cleanup(&req);
|
|
|
2808 check_utime(path, atime, UV_FS_UTIME_NOW, /* test_lutime */ 0);
|
|
|
2809
|
|
|
2810 atime = mtime = 1291404900.25; /* 2010-12-03 20:35:00.25 - mees <3 */
|
|
|
2811 checkme.path = path;
|
|
|
2812 checkme.atime = atime;
|
|
|
2813 checkme.mtime = mtime;
|
|
|
2814
|
|
|
2815 /* async utime */
|
|
|
2816 utime_req.data = &checkme;
|
|
|
2817 r = uv_fs_utime(loop, &utime_req, path, atime, mtime, utime_cb);
|
|
|
2818 ASSERT_OK(r);
|
|
|
2819 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2820 ASSERT_EQ(1, utime_cb_count);
|
|
|
2821
|
|
|
2822 /* Cleanup. */
|
|
|
2823 unlink(path);
|
|
|
2824
|
|
|
2825 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2826 return 0;
|
|
|
2827 }
|
|
|
2828
|
|
|
2829
|
|
|
2830 TEST_IMPL(fs_utime_round) {
|
|
|
2831 const char path[] = "test_file";
|
|
|
2832 double atime;
|
|
|
2833 double mtime;
|
|
|
2834 uv_fs_t req;
|
|
|
2835 int r;
|
|
|
2836
|
|
|
2837 loop = uv_default_loop();
|
|
|
2838 unlink(path);
|
|
|
2839 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
2840 S_IWUSR | S_IRUSR,
|
|
|
2841 NULL);
|
|
|
2842 ASSERT_GE(r, 0);
|
|
|
2843 ASSERT_GE(req.result, 0);
|
|
|
2844 uv_fs_req_cleanup(&req);
|
|
|
2845 ASSERT_OK(uv_fs_close(loop, &req, r, NULL));
|
|
|
2846
|
|
|
2847 atime = mtime = -14245440.25; /* 1969-07-20T02:56:00.25Z */
|
|
|
2848
|
|
|
2849 r = uv_fs_utime(NULL, &req, path, atime, mtime, NULL);
|
|
|
2850 #if !defined(__linux__) && \
|
|
|
2851 !defined(_WIN32) && \
|
|
|
2852 !defined(__APPLE__) && \
|
|
|
2853 !defined(__FreeBSD__) && \
|
|
|
2854 !defined(__sun)
|
|
|
2855 if (r != 0) {
|
|
|
2856 ASSERT_EQ(r, UV_EINVAL);
|
|
|
2857 RETURN_SKIP("utime on some OS (z/OS, IBM i PASE, AIX) or filesystems may reject pre-epoch timestamps");
|
|
|
2858 }
|
|
|
2859 #endif
|
|
|
2860 ASSERT_OK(r);
|
|
|
2861 ASSERT_OK(req.result);
|
|
|
2862 uv_fs_req_cleanup(&req);
|
|
|
2863 check_utime(path, atime, mtime, /* test_lutime */ 0);
|
|
|
2864 unlink(path);
|
|
|
2865
|
|
|
2866 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2867 return 0;
|
|
|
2868 }
|
|
|
2869
|
|
|
2870
|
|
|
2871 #ifdef _WIN32
|
|
|
2872 TEST_IMPL(fs_stat_root) {
|
|
|
2873 int r;
|
|
|
2874
|
|
|
2875 r = uv_fs_stat(NULL, &stat_req, "\\", NULL);
|
|
|
2876 ASSERT_OK(r);
|
|
|
2877
|
|
|
2878 r = uv_fs_stat(NULL, &stat_req, "..\\..\\..\\..\\..\\..\\..", NULL);
|
|
|
2879 ASSERT_OK(r);
|
|
|
2880
|
|
|
2881 r = uv_fs_stat(NULL, &stat_req, "..", NULL);
|
|
|
2882 ASSERT_OK(r);
|
|
|
2883
|
|
|
2884 r = uv_fs_stat(NULL, &stat_req, "..\\", NULL);
|
|
|
2885 ASSERT_OK(r);
|
|
|
2886
|
|
|
2887 /* stats the current directory on c: */
|
|
|
2888 r = uv_fs_stat(NULL, &stat_req, "c:", NULL);
|
|
|
2889 ASSERT_OK(r);
|
|
|
2890
|
|
|
2891 r = uv_fs_stat(NULL, &stat_req, "c:\\", NULL);
|
|
|
2892 ASSERT_OK(r);
|
|
|
2893
|
|
|
2894 r = uv_fs_stat(NULL, &stat_req, "\\\\?\\C:\\", NULL);
|
|
|
2895 ASSERT_OK(r);
|
|
|
2896
|
|
|
2897 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
2898 return 0;
|
|
|
2899 }
|
|
|
2900 #endif
|
|
|
2901
|
|
|
2902
|
|
|
2903 TEST_IMPL(fs_futime) {
|
|
|
2904 utime_check_t checkme;
|
|
|
2905 const char* path = "test_file";
|
|
|
2906 double atime;
|
|
|
2907 double mtime;
|
|
|
2908 uv_file file;
|
|
|
2909 uv_fs_t req;
|
|
|
2910 int r;
|
|
|
2911 #if defined(_AIX) && !defined(_AIX71)
|
|
|
2912 RETURN_SKIP("futime is not implemented for AIX versions below 7.1");
|
|
|
2913 #endif
|
|
|
2914
|
|
|
2915 /* Setup. */
|
|
|
2916 loop = uv_default_loop();
|
|
|
2917 unlink(path);
|
|
|
2918 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
2919 S_IWUSR | S_IRUSR,
|
|
|
2920 NULL);
|
|
|
2921 ASSERT_GE(r, 0);
|
|
|
2922 ASSERT_GE(req.result, 0);
|
|
|
2923 uv_fs_req_cleanup(&req);
|
|
|
2924 uv_fs_close(loop, &req, r, NULL);
|
|
|
2925
|
|
|
2926 atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */
|
|
|
2927
|
|
|
2928 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR, 0, NULL);
|
|
|
2929 ASSERT_GE(r, 0);
|
|
|
2930 ASSERT_GE(req.result, 0);
|
|
|
2931 file = req.result; /* FIXME probably not how it's supposed to be used */
|
|
|
2932 uv_fs_req_cleanup(&req);
|
|
|
2933
|
|
|
2934 r = uv_fs_futime(NULL, &req, file, atime, mtime, NULL);
|
|
|
2935 #if defined(__CYGWIN__) || defined(__MSYS__)
|
|
|
2936 ASSERT_EQ(r, UV_ENOSYS);
|
|
|
2937 RETURN_SKIP("futime not supported on Cygwin");
|
|
|
2938 #else
|
|
|
2939 ASSERT_OK(r);
|
|
|
2940 ASSERT_OK(req.result);
|
|
|
2941 #endif
|
|
|
2942 uv_fs_req_cleanup(&req);
|
|
|
2943 check_utime(path, atime, mtime, /* test_lutime */ 0);
|
|
|
2944
|
|
|
2945 ASSERT_OK(uv_fs_futime(NULL,
|
|
|
2946 &req,
|
|
|
2947 file,
|
|
|
2948 UV_FS_UTIME_OMIT,
|
|
|
2949 UV_FS_UTIME_OMIT,
|
|
|
2950 NULL));
|
|
|
2951 ASSERT_OK(req.result);
|
|
|
2952 uv_fs_req_cleanup(&req);
|
|
|
2953 check_utime(path, atime, mtime, /* test_lutime */ 0);
|
|
|
2954
|
|
|
2955 ASSERT_OK(uv_fs_futime(NULL,
|
|
|
2956 &req,
|
|
|
2957 file,
|
|
|
2958 UV_FS_UTIME_NOW,
|
|
|
2959 UV_FS_UTIME_OMIT,
|
|
|
2960 NULL));
|
|
|
2961 ASSERT_OK(req.result);
|
|
|
2962 uv_fs_req_cleanup(&req);
|
|
|
2963 check_utime(path, UV_FS_UTIME_NOW, mtime, /* test_lutime */ 0);
|
|
|
2964
|
|
|
2965 ASSERT_OK(uv_fs_futime(NULL, &req, file, atime, mtime, NULL));
|
|
|
2966 ASSERT_OK(req.result);
|
|
|
2967 uv_fs_req_cleanup(&req);
|
|
|
2968 check_utime(path, atime, mtime, /* test_lutime */ 0);
|
|
|
2969
|
|
|
2970 ASSERT_OK(uv_fs_futime(NULL,
|
|
|
2971 &req,
|
|
|
2972 file,
|
|
|
2973 UV_FS_UTIME_OMIT,
|
|
|
2974 UV_FS_UTIME_NOW,
|
|
|
2975 NULL));
|
|
|
2976 ASSERT_OK(req.result);
|
|
|
2977 uv_fs_req_cleanup(&req);
|
|
|
2978 check_utime(path, atime, UV_FS_UTIME_NOW, /* test_lutime */ 0);
|
|
|
2979
|
|
|
2980 atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */
|
|
|
2981
|
|
|
2982 checkme.atime = atime;
|
|
|
2983 checkme.mtime = mtime;
|
|
|
2984 checkme.path = path;
|
|
|
2985
|
|
|
2986 /* async futime */
|
|
|
2987 futime_req.data = &checkme;
|
|
|
2988 r = uv_fs_futime(loop, &futime_req, file, atime, mtime, futime_cb);
|
|
|
2989 ASSERT_OK(r);
|
|
|
2990 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
2991 ASSERT_EQ(1, futime_cb_count);
|
|
|
2992
|
|
|
2993 /* Cleanup. */
|
|
|
2994 unlink(path);
|
|
|
2995
|
|
|
2996 MAKE_VALGRIND_HAPPY(loop);
|
|
|
2997 return 0;
|
|
|
2998 }
|
|
|
2999
|
|
|
3000
|
|
|
3001 TEST_IMPL(fs_lutime) {
|
|
|
3002 utime_check_t checkme;
|
|
|
3003 const char* path = "test_file";
|
|
|
3004 const char* symlink_path = "test_file_symlink";
|
|
|
3005 double atime;
|
|
|
3006 double mtime;
|
|
|
3007 uv_fs_t req;
|
|
|
3008 int r, s;
|
|
|
3009
|
|
|
3010
|
|
|
3011 /* Setup */
|
|
|
3012 loop = uv_default_loop();
|
|
|
3013 unlink(path);
|
|
|
3014 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
3015 S_IWUSR | S_IRUSR,
|
|
|
3016 NULL);
|
|
|
3017 ASSERT_GE(r, 0);
|
|
|
3018 ASSERT_GE(req.result, 0);
|
|
|
3019 uv_fs_req_cleanup(&req);
|
|
|
3020 uv_fs_close(loop, &req, r, NULL);
|
|
|
3021
|
|
|
3022 unlink(symlink_path);
|
|
|
3023 s = uv_fs_symlink(NULL, &req, path, symlink_path, 0, NULL);
|
|
|
3024 #ifdef _WIN32
|
|
|
3025 if (s == UV_EPERM) {
|
|
|
3026 /*
|
|
|
3027 * Creating a symlink before Windows 10 Creators Update was only allowed
|
|
|
3028 * when running elevated console (with admin rights)
|
|
|
3029 */
|
|
|
3030 RETURN_SKIP(
|
|
|
3031 "Symlink creation requires elevated console (with admin rights)");
|
|
|
3032 }
|
|
|
3033 #endif
|
|
|
3034 ASSERT_OK(s);
|
|
|
3035 ASSERT_OK(req.result);
|
|
|
3036 uv_fs_req_cleanup(&req);
|
|
|
3037
|
|
|
3038 /* Test the synchronous version. */
|
|
|
3039 atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */
|
|
|
3040
|
|
|
3041 r = uv_fs_lutime(NULL, &req, symlink_path, atime, mtime, NULL);
|
|
|
3042 #if (defined(_AIX) && !defined(_AIX71)) || defined(__MVS__)
|
|
|
3043 ASSERT_EQ(r, UV_ENOSYS);
|
|
|
3044 RETURN_SKIP("lutime is not implemented for z/OS and AIX versions below 7.1");
|
|
|
3045 #endif
|
|
|
3046 ASSERT_OK(r);
|
|
|
3047 ASSERT_OK(req.result);
|
|
|
3048 uv_fs_req_cleanup(&req);
|
|
|
3049 check_utime(symlink_path, atime, mtime, /* test_lutime */ 1);
|
|
|
3050
|
|
|
3051 ASSERT_OK(uv_fs_lutime(NULL,
|
|
|
3052 &req,
|
|
|
3053 symlink_path,
|
|
|
3054 UV_FS_UTIME_OMIT,
|
|
|
3055 UV_FS_UTIME_OMIT,
|
|
|
3056 NULL));
|
|
|
3057 ASSERT_OK(req.result);
|
|
|
3058 uv_fs_req_cleanup(&req);
|
|
|
3059 check_utime(symlink_path, atime, mtime, /* test_lutime */ 1);
|
|
|
3060
|
|
|
3061 ASSERT_OK(uv_fs_lutime(NULL,
|
|
|
3062 &req,
|
|
|
3063 symlink_path,
|
|
|
3064 UV_FS_UTIME_NOW,
|
|
|
3065 UV_FS_UTIME_OMIT,
|
|
|
3066 NULL));
|
|
|
3067 ASSERT_OK(req.result);
|
|
|
3068 uv_fs_req_cleanup(&req);
|
|
|
3069 check_utime(symlink_path, UV_FS_UTIME_NOW, mtime, /* test_lutime */ 1);
|
|
|
3070
|
|
|
3071 ASSERT_OK(uv_fs_lutime(NULL, &req, symlink_path, atime, mtime, NULL));
|
|
|
3072 ASSERT_OK(req.result);
|
|
|
3073 uv_fs_req_cleanup(&req);
|
|
|
3074 check_utime(symlink_path, atime, mtime, /* test_lutime */ 1);
|
|
|
3075
|
|
|
3076 ASSERT_OK(uv_fs_lutime(NULL,
|
|
|
3077 &req,
|
|
|
3078 symlink_path,
|
|
|
3079 UV_FS_UTIME_OMIT,
|
|
|
3080 UV_FS_UTIME_NOW,
|
|
|
3081 NULL));
|
|
|
3082 ASSERT_OK(req.result);
|
|
|
3083 uv_fs_req_cleanup(&req);
|
|
|
3084 check_utime(symlink_path, atime, UV_FS_UTIME_NOW, /* test_lutime */ 1);
|
|
|
3085
|
|
|
3086 /* Test the asynchronous version. */
|
|
|
3087 atime = mtime = 1291404900; /* 2010-12-03 20:35:00 */
|
|
|
3088
|
|
|
3089 checkme.atime = atime;
|
|
|
3090 checkme.mtime = mtime;
|
|
|
3091 checkme.path = symlink_path;
|
|
|
3092 req.data = &checkme;
|
|
|
3093
|
|
|
3094 r = uv_fs_lutime(loop, &req, symlink_path, atime, mtime, lutime_cb);
|
|
|
3095 ASSERT_OK(r);
|
|
|
3096 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
3097 ASSERT_EQ(1, lutime_cb_count);
|
|
|
3098
|
|
|
3099 /* Cleanup. */
|
|
|
3100 unlink(path);
|
|
|
3101 unlink(symlink_path);
|
|
|
3102
|
|
|
3103 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3104 return 0;
|
|
|
3105 }
|
|
|
3106
|
|
|
3107
|
|
|
3108 TEST_IMPL(fs_stat_missing_path) {
|
|
|
3109 uv_fs_t req;
|
|
|
3110 int r;
|
|
|
3111
|
|
|
3112 loop = uv_default_loop();
|
|
|
3113
|
|
|
3114 r = uv_fs_stat(NULL, &req, "non_existent_file", NULL);
|
|
|
3115 ASSERT_EQ(r, UV_ENOENT);
|
|
|
3116 ASSERT_EQ(req.result, UV_ENOENT);
|
|
|
3117 uv_fs_req_cleanup(&req);
|
|
|
3118
|
|
|
3119 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3120 return 0;
|
|
|
3121 }
|
|
|
3122
|
|
|
3123
|
|
|
3124 TEST_IMPL(fs_scandir_empty_dir) {
|
|
|
3125 const char* path;
|
|
|
3126 uv_fs_t req;
|
|
|
3127 uv_dirent_t dent;
|
|
|
3128 int r;
|
|
|
3129
|
|
|
3130 path = "./empty_dir/";
|
|
|
3131 loop = uv_default_loop();
|
|
|
3132
|
|
|
3133 uv_fs_mkdir(NULL, &req, path, 0777, NULL);
|
|
|
3134 uv_fs_req_cleanup(&req);
|
|
|
3135
|
|
|
3136 /* Fill the req to ensure that required fields are cleaned up */
|
|
|
3137 memset(&req, 0xdb, sizeof(req));
|
|
|
3138
|
|
|
3139 r = uv_fs_scandir(NULL, &req, path, 0, NULL);
|
|
|
3140 ASSERT_OK(r);
|
|
|
3141 ASSERT_OK(req.result);
|
|
|
3142 ASSERT_NULL(req.ptr);
|
|
|
3143 ASSERT_EQ(UV_EOF, uv_fs_scandir_next(&req, &dent));
|
|
|
3144 uv_fs_req_cleanup(&req);
|
|
|
3145
|
|
|
3146 r = uv_fs_scandir(loop, &scandir_req, path, 0, empty_scandir_cb);
|
|
|
3147 ASSERT_OK(r);
|
|
|
3148
|
|
|
3149 ASSERT_OK(scandir_cb_count);
|
|
|
3150 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
3151 ASSERT_EQ(1, scandir_cb_count);
|
|
|
3152
|
|
|
3153 uv_fs_rmdir(NULL, &req, path, NULL);
|
|
|
3154 uv_fs_req_cleanup(&req);
|
|
|
3155
|
|
|
3156 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3157 return 0;
|
|
|
3158 }
|
|
|
3159
|
|
|
3160
|
|
|
3161 TEST_IMPL(fs_scandir_non_existent_dir) {
|
|
|
3162 const char* path;
|
|
|
3163 uv_fs_t req;
|
|
|
3164 uv_dirent_t dent;
|
|
|
3165 int r;
|
|
|
3166
|
|
|
3167 path = "./non_existent_dir/";
|
|
|
3168 loop = uv_default_loop();
|
|
|
3169
|
|
|
3170 uv_fs_rmdir(NULL, &req, path, NULL);
|
|
|
3171 uv_fs_req_cleanup(&req);
|
|
|
3172
|
|
|
3173 /* Fill the req to ensure that required fields are cleaned up */
|
|
|
3174 memset(&req, 0xdb, sizeof(req));
|
|
|
3175
|
|
|
3176 r = uv_fs_scandir(NULL, &req, path, 0, NULL);
|
|
|
3177 ASSERT_EQ(r, UV_ENOENT);
|
|
|
3178 ASSERT_EQ(req.result, UV_ENOENT);
|
|
|
3179 ASSERT_NULL(req.ptr);
|
|
|
3180 ASSERT_EQ(UV_ENOENT, uv_fs_scandir_next(&req, &dent));
|
|
|
3181 uv_fs_req_cleanup(&req);
|
|
|
3182
|
|
|
3183 r = uv_fs_scandir(loop, &scandir_req, path, 0, non_existent_scandir_cb);
|
|
|
3184 ASSERT_OK(r);
|
|
|
3185
|
|
|
3186 ASSERT_OK(scandir_cb_count);
|
|
|
3187 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
3188 ASSERT_EQ(1, scandir_cb_count);
|
|
|
3189
|
|
|
3190 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3191 return 0;
|
|
|
3192 }
|
|
|
3193
|
|
|
3194 TEST_IMPL(fs_scandir_file) {
|
|
|
3195 const char* path;
|
|
|
3196 int r;
|
|
|
3197
|
|
|
3198 path = "test/fixtures/empty_file";
|
|
|
3199 loop = uv_default_loop();
|
|
|
3200
|
|
|
3201 r = uv_fs_scandir(NULL, &scandir_req, path, 0, NULL);
|
|
|
3202 ASSERT_EQ(r, UV_ENOTDIR);
|
|
|
3203 uv_fs_req_cleanup(&scandir_req);
|
|
|
3204
|
|
|
3205 r = uv_fs_scandir(loop, &scandir_req, path, 0, file_scandir_cb);
|
|
|
3206 ASSERT_OK(r);
|
|
|
3207
|
|
|
3208 ASSERT_OK(scandir_cb_count);
|
|
|
3209 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
3210 ASSERT_EQ(1, scandir_cb_count);
|
|
|
3211
|
|
|
3212 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3213 return 0;
|
|
|
3214 }
|
|
|
3215
|
|
|
3216
|
|
|
3217 /* Run in Valgrind. Should not leak when the iterator isn't exhausted. */
|
|
|
3218 TEST_IMPL(fs_scandir_early_exit) {
|
|
|
3219 uv_dirent_t d;
|
|
|
3220 uv_fs_t req;
|
|
|
3221
|
|
|
3222 ASSERT_LT(0, uv_fs_scandir(NULL, &req, "test/fixtures/one_file", 0, NULL));
|
|
|
3223 ASSERT_NE(UV_EOF, uv_fs_scandir_next(&req, &d));
|
|
|
3224 uv_fs_req_cleanup(&req);
|
|
|
3225
|
|
|
3226 ASSERT_LT(0, uv_fs_scandir(NULL, &req, "test/fixtures", 0, NULL));
|
|
|
3227 ASSERT_NE(UV_EOF, uv_fs_scandir_next(&req, &d));
|
|
|
3228 uv_fs_req_cleanup(&req);
|
|
|
3229
|
|
|
3230 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
3231 return 0;
|
|
|
3232 }
|
|
|
3233
|
|
|
3234
|
|
|
3235 TEST_IMPL(fs_open_dir) {
|
|
|
3236 const char* path;
|
|
|
3237 uv_fs_t req;
|
|
|
3238 int r, file;
|
|
|
3239
|
|
|
3240 path = ".";
|
|
|
3241 loop = uv_default_loop();
|
|
|
3242
|
|
|
3243 r = uv_fs_open(NULL, &req, path, UV_FS_O_RDONLY, 0, NULL);
|
|
|
3244 ASSERT_GE(r, 0);
|
|
|
3245 ASSERT_GE(req.result, 0);
|
|
|
3246 ASSERT_NULL(req.ptr);
|
|
|
3247 file = r;
|
|
|
3248 uv_fs_req_cleanup(&req);
|
|
|
3249
|
|
|
3250 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
3251 ASSERT_OK(r);
|
|
|
3252
|
|
|
3253 r = uv_fs_open(loop, &req, path, UV_FS_O_RDONLY, 0, open_cb_simple);
|
|
|
3254 ASSERT_OK(r);
|
|
|
3255
|
|
|
3256 ASSERT_OK(open_cb_count);
|
|
|
3257 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
3258 ASSERT_EQ(1, open_cb_count);
|
|
|
3259
|
|
|
3260 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3261 return 0;
|
|
|
3262 }
|
|
|
3263
|
|
|
3264
|
|
|
3265 static void fs_file_open_append(int add_flags) {
|
|
|
3266 int r;
|
|
|
3267
|
|
|
3268 /* Setup. */
|
|
|
3269 unlink("test_file");
|
|
|
3270
|
|
|
3271 loop = uv_default_loop();
|
|
|
3272
|
|
|
3273 r = uv_fs_open(NULL, &open_req1, "test_file",
|
|
|
3274 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR,
|
|
|
3275 NULL);
|
|
|
3276 ASSERT_GE(r, 0);
|
|
|
3277 ASSERT_GE(open_req1.result, 0);
|
|
|
3278 uv_fs_req_cleanup(&open_req1);
|
|
|
3279
|
|
|
3280 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
3281 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3282 ASSERT_GE(r, 0);
|
|
|
3283 ASSERT_GE(write_req.result, 0);
|
|
|
3284 uv_fs_req_cleanup(&write_req);
|
|
|
3285
|
|
|
3286 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3287 ASSERT_OK(r);
|
|
|
3288 ASSERT_OK(close_req.result);
|
|
|
3289 uv_fs_req_cleanup(&close_req);
|
|
|
3290
|
|
|
3291 r = uv_fs_open(NULL, &open_req1, "test_file",
|
|
|
3292 UV_FS_O_RDWR | UV_FS_O_APPEND | add_flags, 0, NULL);
|
|
|
3293 ASSERT_GE(r, 0);
|
|
|
3294 ASSERT_GE(open_req1.result, 0);
|
|
|
3295 uv_fs_req_cleanup(&open_req1);
|
|
|
3296
|
|
|
3297 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
3298 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3299 ASSERT_GE(r, 0);
|
|
|
3300 ASSERT_GE(write_req.result, 0);
|
|
|
3301 uv_fs_req_cleanup(&write_req);
|
|
|
3302
|
|
|
3303 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3304 ASSERT_OK(r);
|
|
|
3305 ASSERT_OK(close_req.result);
|
|
|
3306 uv_fs_req_cleanup(&close_req);
|
|
|
3307
|
|
|
3308 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags,
|
|
|
3309 S_IRUSR, NULL);
|
|
|
3310 ASSERT_GE(r, 0);
|
|
|
3311 ASSERT_GE(open_req1.result, 0);
|
|
|
3312 uv_fs_req_cleanup(&open_req1);
|
|
|
3313
|
|
|
3314 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3315 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3316 printf("read = %d\n", r);
|
|
|
3317 ASSERT_EQ(26, r);
|
|
|
3318 ASSERT_EQ(26, read_req.result);
|
|
|
3319 ASSERT_OK(memcmp(buf,
|
|
|
3320 "test-buffer\n\0test-buffer\n\0",
|
|
|
3321 sizeof("test-buffer\n\0test-buffer\n\0") - 1));
|
|
|
3322 uv_fs_req_cleanup(&read_req);
|
|
|
3323
|
|
|
3324 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3325 ASSERT_OK(r);
|
|
|
3326 ASSERT_OK(close_req.result);
|
|
|
3327 uv_fs_req_cleanup(&close_req);
|
|
|
3328
|
|
|
3329 /* Cleanup */
|
|
|
3330 unlink("test_file");
|
|
|
3331 }
|
|
|
3332 TEST_IMPL(fs_file_open_append) {
|
|
|
3333 fs_file_open_append(0);
|
|
|
3334 fs_file_open_append(UV_FS_O_FILEMAP);
|
|
|
3335
|
|
|
3336 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
3337 return 0;
|
|
|
3338 }
|
|
|
3339
|
|
|
3340
|
|
|
3341 TEST_IMPL(fs_rename_to_existing_file) {
|
|
|
3342 int r;
|
|
|
3343
|
|
|
3344 /* Setup. */
|
|
|
3345 unlink("test_file");
|
|
|
3346 unlink("test_file2");
|
|
|
3347
|
|
|
3348 loop = uv_default_loop();
|
|
|
3349
|
|
|
3350 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
3351 S_IWUSR | S_IRUSR, NULL);
|
|
|
3352 ASSERT_GE(r, 0);
|
|
|
3353 ASSERT_GE(open_req1.result, 0);
|
|
|
3354 uv_fs_req_cleanup(&open_req1);
|
|
|
3355
|
|
|
3356 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
3357 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3358 ASSERT_GE(r, 0);
|
|
|
3359 ASSERT_GE(write_req.result, 0);
|
|
|
3360 uv_fs_req_cleanup(&write_req);
|
|
|
3361
|
|
|
3362 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3363 ASSERT_OK(r);
|
|
|
3364 ASSERT_OK(close_req.result);
|
|
|
3365 uv_fs_req_cleanup(&close_req);
|
|
|
3366
|
|
|
3367 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
3368 S_IWUSR | S_IRUSR, NULL);
|
|
|
3369 ASSERT_GE(r, 0);
|
|
|
3370 ASSERT_GE(open_req1.result, 0);
|
|
|
3371 uv_fs_req_cleanup(&open_req1);
|
|
|
3372
|
|
|
3373 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3374 ASSERT_OK(r);
|
|
|
3375 ASSERT_OK(close_req.result);
|
|
|
3376 uv_fs_req_cleanup(&close_req);
|
|
|
3377
|
|
|
3378 r = uv_fs_rename(NULL, &rename_req, "test_file", "test_file2", NULL);
|
|
|
3379 ASSERT_OK(r);
|
|
|
3380 ASSERT_OK(rename_req.result);
|
|
|
3381 uv_fs_req_cleanup(&rename_req);
|
|
|
3382
|
|
|
3383 r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDONLY, 0, NULL);
|
|
|
3384 ASSERT_GE(r, 0);
|
|
|
3385 ASSERT_GE(open_req1.result, 0);
|
|
|
3386 uv_fs_req_cleanup(&open_req1);
|
|
|
3387
|
|
|
3388 memset(buf, 0, sizeof(buf));
|
|
|
3389 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3390 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3391 ASSERT_GE(r, 0);
|
|
|
3392 ASSERT_GE(read_req.result, 0);
|
|
|
3393 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
3394 uv_fs_req_cleanup(&read_req);
|
|
|
3395
|
|
|
3396 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3397 ASSERT_OK(r);
|
|
|
3398 ASSERT_OK(close_req.result);
|
|
|
3399 uv_fs_req_cleanup(&close_req);
|
|
|
3400
|
|
|
3401 /* Cleanup */
|
|
|
3402 unlink("test_file");
|
|
|
3403 unlink("test_file2");
|
|
|
3404
|
|
|
3405 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3406 return 0;
|
|
|
3407 }
|
|
|
3408
|
|
|
3409
|
|
|
3410 static void fs_read_bufs(int add_flags) {
|
|
|
3411 char scratch[768];
|
|
|
3412 uv_buf_t bufs[4];
|
|
|
3413
|
|
|
3414 ASSERT_LE(0, uv_fs_open(NULL, &open_req1,
|
|
|
3415 "test/fixtures/lorem_ipsum.txt",
|
|
|
3416 UV_FS_O_RDONLY | add_flags, 0, NULL));
|
|
|
3417 ASSERT_GE(open_req1.result, 0);
|
|
|
3418 uv_fs_req_cleanup(&open_req1);
|
|
|
3419
|
|
|
3420 ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result,
|
|
|
3421 NULL, 0, 0, NULL));
|
|
|
3422 ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result,
|
|
|
3423 NULL, 1, 0, NULL));
|
|
|
3424 ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result,
|
|
|
3425 bufs, 0, 0, NULL));
|
|
|
3426
|
|
|
3427 bufs[0] = uv_buf_init(scratch + 0, 256);
|
|
|
3428 bufs[1] = uv_buf_init(scratch + 256, 256);
|
|
|
3429 bufs[2] = uv_buf_init(scratch + 512, 128);
|
|
|
3430 bufs[3] = uv_buf_init(scratch + 640, 128);
|
|
|
3431
|
|
|
3432 ASSERT_EQ(446, uv_fs_read(NULL,
|
|
|
3433 &read_req,
|
|
|
3434 open_req1.result,
|
|
|
3435 bufs + 0,
|
|
|
3436 2, /* 2x 256 bytes. */
|
|
|
3437 0, /* Positional read. */
|
|
|
3438 NULL));
|
|
|
3439 ASSERT_EQ(446, read_req.result);
|
|
|
3440 uv_fs_req_cleanup(&read_req);
|
|
|
3441
|
|
|
3442 ASSERT_EQ(190, uv_fs_read(NULL,
|
|
|
3443 &read_req,
|
|
|
3444 open_req1.result,
|
|
|
3445 bufs + 2,
|
|
|
3446 2, /* 2x 128 bytes. */
|
|
|
3447 256, /* Positional read. */
|
|
|
3448 NULL));
|
|
|
3449 ASSERT_EQ(read_req.result, /* 446 - 256 */ 190);
|
|
|
3450 uv_fs_req_cleanup(&read_req);
|
|
|
3451
|
|
|
3452 ASSERT_OK(memcmp(bufs[1].base + 0, bufs[2].base, 128));
|
|
|
3453 ASSERT_OK(memcmp(bufs[1].base + 128, bufs[3].base, 190 - 128));
|
|
|
3454
|
|
|
3455 ASSERT_OK(uv_fs_close(NULL, &close_req, open_req1.result, NULL));
|
|
|
3456 ASSERT_OK(close_req.result);
|
|
|
3457 uv_fs_req_cleanup(&close_req);
|
|
|
3458 }
|
|
|
3459 TEST_IMPL(fs_read_bufs) {
|
|
|
3460 fs_read_bufs(0);
|
|
|
3461 fs_read_bufs(UV_FS_O_FILEMAP);
|
|
|
3462
|
|
|
3463 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
3464 return 0;
|
|
|
3465 }
|
|
|
3466
|
|
|
3467
|
|
|
3468 static void fs_read_file_eof(int add_flags) {
|
|
|
3469 #if defined(__CYGWIN__) || defined(__MSYS__)
|
|
|
3470 RETURN_SKIP("Cygwin pread at EOF may (incorrectly) return data!");
|
|
|
3471 #endif
|
|
|
3472 int r;
|
|
|
3473
|
|
|
3474 /* Setup. */
|
|
|
3475 unlink("test_file");
|
|
|
3476
|
|
|
3477 loop = uv_default_loop();
|
|
|
3478
|
|
|
3479 r = uv_fs_open(NULL, &open_req1, "test_file",
|
|
|
3480 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR,
|
|
|
3481 NULL);
|
|
|
3482 ASSERT_GE(r, 0);
|
|
|
3483 ASSERT_GE(open_req1.result, 0);
|
|
|
3484 uv_fs_req_cleanup(&open_req1);
|
|
|
3485
|
|
|
3486 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
3487 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3488 ASSERT_GE(r, 0);
|
|
|
3489 ASSERT_GE(write_req.result, 0);
|
|
|
3490 uv_fs_req_cleanup(&write_req);
|
|
|
3491
|
|
|
3492 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3493 ASSERT_OK(r);
|
|
|
3494 ASSERT_OK(close_req.result);
|
|
|
3495 uv_fs_req_cleanup(&close_req);
|
|
|
3496
|
|
|
3497 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0,
|
|
|
3498 NULL);
|
|
|
3499 ASSERT_GE(r, 0);
|
|
|
3500 ASSERT_GE(open_req1.result, 0);
|
|
|
3501 uv_fs_req_cleanup(&open_req1);
|
|
|
3502
|
|
|
3503 memset(buf, 0, sizeof(buf));
|
|
|
3504 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3505 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3506 ASSERT_GE(r, 0);
|
|
|
3507 ASSERT_GE(read_req.result, 0);
|
|
|
3508 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
3509 uv_fs_req_cleanup(&read_req);
|
|
|
3510
|
|
|
3511 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3512 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1,
|
|
|
3513 read_req.result, NULL);
|
|
|
3514 ASSERT_OK(r);
|
|
|
3515 ASSERT_OK(read_req.result);
|
|
|
3516 uv_fs_req_cleanup(&read_req);
|
|
|
3517
|
|
|
3518 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3519 ASSERT_OK(r);
|
|
|
3520 ASSERT_OK(close_req.result);
|
|
|
3521 uv_fs_req_cleanup(&close_req);
|
|
|
3522
|
|
|
3523 /* Cleanup */
|
|
|
3524 unlink("test_file");
|
|
|
3525 }
|
|
|
3526 TEST_IMPL(fs_read_file_eof) {
|
|
|
3527 fs_read_file_eof(0);
|
|
|
3528 fs_read_file_eof(UV_FS_O_FILEMAP);
|
|
|
3529
|
|
|
3530 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
3531 return 0;
|
|
|
3532 }
|
|
|
3533
|
|
|
3534
|
|
|
3535 static void fs_write_multiple_bufs(int add_flags) {
|
|
|
3536 uv_buf_t iovs[2];
|
|
|
3537 int r;
|
|
|
3538
|
|
|
3539 /* Setup. */
|
|
|
3540 unlink("test_file");
|
|
|
3541
|
|
|
3542 loop = uv_default_loop();
|
|
|
3543
|
|
|
3544 r = uv_fs_open(NULL, &open_req1, "test_file",
|
|
|
3545 UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR,
|
|
|
3546 NULL);
|
|
|
3547 ASSERT_GE(r, 0);
|
|
|
3548 ASSERT_GE(open_req1.result, 0);
|
|
|
3549 uv_fs_req_cleanup(&open_req1);
|
|
|
3550
|
|
|
3551 iovs[0] = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
3552 iovs[1] = uv_buf_init(test_buf2, sizeof(test_buf2));
|
|
|
3553 r = uv_fs_write(NULL, &write_req, open_req1.result, iovs, 2, 0, NULL);
|
|
|
3554 ASSERT_GE(r, 0);
|
|
|
3555 ASSERT_GE(write_req.result, 0);
|
|
|
3556 uv_fs_req_cleanup(&write_req);
|
|
|
3557
|
|
|
3558 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3559 ASSERT_OK(r);
|
|
|
3560 ASSERT_OK(close_req.result);
|
|
|
3561 uv_fs_req_cleanup(&close_req);
|
|
|
3562
|
|
|
3563 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0,
|
|
|
3564 NULL);
|
|
|
3565 ASSERT_GE(r, 0);
|
|
|
3566 ASSERT_GE(open_req1.result, 0);
|
|
|
3567 uv_fs_req_cleanup(&open_req1);
|
|
|
3568
|
|
|
3569 memset(buf, 0, sizeof(buf));
|
|
|
3570 memset(buf2, 0, sizeof(buf2));
|
|
|
3571 /* Read the strings back to separate buffers. */
|
|
|
3572 iovs[0] = uv_buf_init(buf, sizeof(test_buf));
|
|
|
3573 iovs[1] = uv_buf_init(buf2, sizeof(test_buf2));
|
|
|
3574 ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR));
|
|
|
3575 r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, 2, -1, NULL);
|
|
|
3576 ASSERT_GE(r, 0);
|
|
|
3577 ASSERT_EQ(read_req.result, sizeof(test_buf) + sizeof(test_buf2));
|
|
|
3578 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
3579 ASSERT_OK(strcmp(buf2, test_buf2));
|
|
|
3580 uv_fs_req_cleanup(&read_req);
|
|
|
3581
|
|
|
3582 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3583 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3584 ASSERT_OK(r);
|
|
|
3585 ASSERT_OK(read_req.result);
|
|
|
3586 uv_fs_req_cleanup(&read_req);
|
|
|
3587
|
|
|
3588 /* Read the strings back to separate buffers. */
|
|
|
3589 iovs[0] = uv_buf_init(buf, sizeof(test_buf));
|
|
|
3590 iovs[1] = uv_buf_init(buf2, sizeof(test_buf2));
|
|
|
3591 r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, 2, 0, NULL);
|
|
|
3592 ASSERT_GE(r, 0);
|
|
|
3593 if (read_req.result == sizeof(test_buf)) {
|
|
|
3594 /* Infer that preadv is not available. */
|
|
|
3595 uv_fs_req_cleanup(&read_req);
|
|
|
3596 r = uv_fs_read(NULL, &read_req, open_req1.result, &iovs[1], 1, read_req.result, NULL);
|
|
|
3597 ASSERT_GE(r, 0);
|
|
|
3598 ASSERT_EQ(read_req.result, sizeof(test_buf2));
|
|
|
3599 } else {
|
|
|
3600 ASSERT_EQ(read_req.result, sizeof(test_buf) + sizeof(test_buf2));
|
|
|
3601 }
|
|
|
3602 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
3603 ASSERT_OK(strcmp(buf2, test_buf2));
|
|
|
3604 uv_fs_req_cleanup(&read_req);
|
|
|
3605
|
|
|
3606 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3607 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1,
|
|
|
3608 sizeof(test_buf) + sizeof(test_buf2), NULL);
|
|
|
3609 ASSERT_OK(r);
|
|
|
3610 ASSERT_OK(read_req.result);
|
|
|
3611 uv_fs_req_cleanup(&read_req);
|
|
|
3612
|
|
|
3613 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3614 ASSERT_OK(r);
|
|
|
3615 ASSERT_OK(close_req.result);
|
|
|
3616 uv_fs_req_cleanup(&close_req);
|
|
|
3617
|
|
|
3618 /* Cleanup */
|
|
|
3619 unlink("test_file");
|
|
|
3620 }
|
|
|
3621 TEST_IMPL(fs_write_multiple_bufs) {
|
|
|
3622 fs_write_multiple_bufs(0);
|
|
|
3623 fs_write_multiple_bufs(UV_FS_O_FILEMAP);
|
|
|
3624
|
|
|
3625 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
3626 return 0;
|
|
|
3627 }
|
|
|
3628
|
|
|
3629
|
|
|
3630 static void fs_write_alotof_bufs(int add_flags) {
|
|
|
3631 size_t iovcount;
|
|
|
3632 size_t iovmax;
|
|
|
3633 uv_buf_t* iovs;
|
|
|
3634 char* buffer;
|
|
|
3635 size_t index;
|
|
|
3636 int r;
|
|
|
3637
|
|
|
3638 iovcount = 54321;
|
|
|
3639
|
|
|
3640 /* Setup. */
|
|
|
3641 unlink("test_file");
|
|
|
3642
|
|
|
3643 loop = uv_default_loop();
|
|
|
3644
|
|
|
3645 iovs = malloc(sizeof(*iovs) * iovcount);
|
|
|
3646 ASSERT_NOT_NULL(iovs);
|
|
|
3647 iovmax = uv_test_getiovmax();
|
|
|
3648
|
|
|
3649 r = uv_fs_open(NULL,
|
|
|
3650 &open_req1,
|
|
|
3651 "test_file",
|
|
|
3652 UV_FS_O_RDWR | UV_FS_O_CREAT | add_flags,
|
|
|
3653 S_IWUSR | S_IRUSR,
|
|
|
3654 NULL);
|
|
|
3655 ASSERT_GE(r, 0);
|
|
|
3656 ASSERT_GE(open_req1.result, 0);
|
|
|
3657 uv_fs_req_cleanup(&open_req1);
|
|
|
3658
|
|
|
3659 for (index = 0; index < iovcount; ++index)
|
|
|
3660 iovs[index] = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
3661
|
|
|
3662 r = uv_fs_write(NULL,
|
|
|
3663 &write_req,
|
|
|
3664 open_req1.result,
|
|
|
3665 iovs,
|
|
|
3666 iovcount,
|
|
|
3667 -1,
|
|
|
3668 NULL);
|
|
|
3669 ASSERT_GE(r, 0);
|
|
|
3670 ASSERT_EQ((size_t)write_req.result, sizeof(test_buf) * iovcount);
|
|
|
3671 uv_fs_req_cleanup(&write_req);
|
|
|
3672
|
|
|
3673 /* Read the strings back to separate buffers. */
|
|
|
3674 buffer = malloc(sizeof(test_buf) * iovcount);
|
|
|
3675 ASSERT_NOT_NULL(buffer);
|
|
|
3676
|
|
|
3677 for (index = 0; index < iovcount; ++index)
|
|
|
3678 iovs[index] = uv_buf_init(buffer + index * sizeof(test_buf),
|
|
|
3679 sizeof(test_buf));
|
|
|
3680
|
|
|
3681 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3682 ASSERT_OK(r);
|
|
|
3683 ASSERT_OK(close_req.result);
|
|
|
3684 uv_fs_req_cleanup(&close_req);
|
|
|
3685
|
|
|
3686 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0,
|
|
|
3687 NULL);
|
|
|
3688 ASSERT_GE(r, 0);
|
|
|
3689 ASSERT_GE(open_req1.result, 0);
|
|
|
3690 uv_fs_req_cleanup(&open_req1);
|
|
|
3691
|
|
|
3692 r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, iovcount, -1, NULL);
|
|
|
3693 if (iovcount > iovmax)
|
|
|
3694 iovcount = iovmax;
|
|
|
3695 ASSERT_GE(r, 0);
|
|
|
3696 ASSERT_EQ((size_t)read_req.result, sizeof(test_buf) * iovcount);
|
|
|
3697
|
|
|
3698 for (index = 0; index < iovcount; ++index)
|
|
|
3699 ASSERT_OK(strncmp(buffer + index * sizeof(test_buf),
|
|
|
3700 test_buf,
|
|
|
3701 sizeof(test_buf)));
|
|
|
3702
|
|
|
3703 uv_fs_req_cleanup(&read_req);
|
|
|
3704 free(buffer);
|
|
|
3705
|
|
|
3706 ASSERT_EQ(lseek(open_req1.result, write_req.result, SEEK_SET),
|
|
|
3707 write_req.result);
|
|
|
3708 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3709 r = uv_fs_read(NULL,
|
|
|
3710 &read_req,
|
|
|
3711 open_req1.result,
|
|
|
3712 &iov,
|
|
|
3713 1,
|
|
|
3714 -1,
|
|
|
3715 NULL);
|
|
|
3716 ASSERT_OK(r);
|
|
|
3717 ASSERT_OK(read_req.result);
|
|
|
3718 uv_fs_req_cleanup(&read_req);
|
|
|
3719
|
|
|
3720 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3721 ASSERT_OK(r);
|
|
|
3722 ASSERT_OK(close_req.result);
|
|
|
3723 uv_fs_req_cleanup(&close_req);
|
|
|
3724
|
|
|
3725 /* Cleanup */
|
|
|
3726 unlink("test_file");
|
|
|
3727 free(iovs);
|
|
|
3728 }
|
|
|
3729 TEST_IMPL(fs_write_alotof_bufs) {
|
|
|
3730 fs_write_alotof_bufs(0);
|
|
|
3731 fs_write_alotof_bufs(UV_FS_O_FILEMAP);
|
|
|
3732
|
|
|
3733 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
3734 return 0;
|
|
|
3735 }
|
|
|
3736
|
|
|
3737
|
|
|
3738 static void fs_write_alotof_bufs_with_offset(int add_flags) {
|
|
|
3739 size_t iovcount;
|
|
|
3740 size_t iovmax;
|
|
|
3741 uv_buf_t* iovs;
|
|
|
3742 char* buffer;
|
|
|
3743 size_t index;
|
|
|
3744 int r;
|
|
|
3745 int64_t offset;
|
|
|
3746 char* filler;
|
|
|
3747 int filler_len;
|
|
|
3748
|
|
|
3749 filler = "0123456789";
|
|
|
3750 filler_len = strlen(filler);
|
|
|
3751 iovcount = 54321;
|
|
|
3752
|
|
|
3753 /* Setup. */
|
|
|
3754 unlink("test_file");
|
|
|
3755
|
|
|
3756 loop = uv_default_loop();
|
|
|
3757
|
|
|
3758 iovs = malloc(sizeof(*iovs) * iovcount);
|
|
|
3759 ASSERT_NOT_NULL(iovs);
|
|
|
3760 iovmax = uv_test_getiovmax();
|
|
|
3761
|
|
|
3762 r = uv_fs_open(NULL,
|
|
|
3763 &open_req1,
|
|
|
3764 "test_file",
|
|
|
3765 UV_FS_O_RDWR | UV_FS_O_CREAT | add_flags,
|
|
|
3766 S_IWUSR | S_IRUSR,
|
|
|
3767 NULL);
|
|
|
3768 ASSERT_GE(r, 0);
|
|
|
3769 ASSERT_GE(open_req1.result, 0);
|
|
|
3770 uv_fs_req_cleanup(&open_req1);
|
|
|
3771
|
|
|
3772 iov = uv_buf_init(filler, filler_len);
|
|
|
3773 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
3774 ASSERT_EQ(r, filler_len);
|
|
|
3775 ASSERT_EQ(write_req.result, filler_len);
|
|
|
3776 uv_fs_req_cleanup(&write_req);
|
|
|
3777 offset = (int64_t)r;
|
|
|
3778
|
|
|
3779 for (index = 0; index < iovcount; ++index)
|
|
|
3780 iovs[index] = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
3781
|
|
|
3782 r = uv_fs_write(NULL,
|
|
|
3783 &write_req,
|
|
|
3784 open_req1.result,
|
|
|
3785 iovs,
|
|
|
3786 iovcount,
|
|
|
3787 offset,
|
|
|
3788 NULL);
|
|
|
3789 ASSERT_GE(r, 0);
|
|
|
3790 ASSERT_EQ((size_t)write_req.result, sizeof(test_buf) * iovcount);
|
|
|
3791 uv_fs_req_cleanup(&write_req);
|
|
|
3792
|
|
|
3793 /* Read the strings back to separate buffers. */
|
|
|
3794 buffer = malloc(sizeof(test_buf) * iovcount);
|
|
|
3795 ASSERT_NOT_NULL(buffer);
|
|
|
3796
|
|
|
3797 for (index = 0; index < iovcount; ++index)
|
|
|
3798 iovs[index] = uv_buf_init(buffer + index * sizeof(test_buf),
|
|
|
3799 sizeof(test_buf));
|
|
|
3800
|
|
|
3801 r = uv_fs_read(NULL, &read_req, open_req1.result,
|
|
|
3802 iovs, iovcount, offset, NULL);
|
|
|
3803 ASSERT_GE(r, 0);
|
|
|
3804 if (r == sizeof(test_buf))
|
|
|
3805 iovcount = 1; /* Infer that preadv is not available. */
|
|
|
3806 else if (iovcount > iovmax)
|
|
|
3807 iovcount = iovmax;
|
|
|
3808 ASSERT_EQ((size_t)read_req.result, sizeof(test_buf) * iovcount);
|
|
|
3809
|
|
|
3810 for (index = 0; index < iovcount; ++index)
|
|
|
3811 ASSERT_OK(strncmp(buffer + index * sizeof(test_buf),
|
|
|
3812 test_buf,
|
|
|
3813 sizeof(test_buf)));
|
|
|
3814
|
|
|
3815 uv_fs_req_cleanup(&read_req);
|
|
|
3816 free(buffer);
|
|
|
3817
|
|
|
3818 r = uv_fs_stat(NULL, &stat_req, "test_file", NULL);
|
|
|
3819 ASSERT_OK(r);
|
|
|
3820 ASSERT_EQ((int64_t)((uv_stat_t*)stat_req.ptr)->st_size,
|
|
|
3821 offset + (int64_t)write_req.result);
|
|
|
3822 uv_fs_req_cleanup(&stat_req);
|
|
|
3823
|
|
|
3824 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3825 r = uv_fs_read(NULL,
|
|
|
3826 &read_req,
|
|
|
3827 open_req1.result,
|
|
|
3828 &iov,
|
|
|
3829 1,
|
|
|
3830 offset + write_req.result,
|
|
|
3831 NULL);
|
|
|
3832 ASSERT_OK(r);
|
|
|
3833 ASSERT_OK(read_req.result);
|
|
|
3834 uv_fs_req_cleanup(&read_req);
|
|
|
3835
|
|
|
3836 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3837 ASSERT_OK(r);
|
|
|
3838 ASSERT_OK(close_req.result);
|
|
|
3839 uv_fs_req_cleanup(&close_req);
|
|
|
3840
|
|
|
3841 /* Cleanup */
|
|
|
3842 unlink("test_file");
|
|
|
3843 free(iovs);
|
|
|
3844 }
|
|
|
3845 TEST_IMPL(fs_write_alotof_bufs_with_offset) {
|
|
|
3846 fs_write_alotof_bufs_with_offset(0);
|
|
|
3847 fs_write_alotof_bufs_with_offset(UV_FS_O_FILEMAP);
|
|
|
3848
|
|
|
3849 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
3850 return 0;
|
|
|
3851 }
|
|
|
3852
|
|
|
3853 TEST_IMPL(fs_read_dir) {
|
|
|
3854 int r;
|
|
|
3855 char buf[2];
|
|
|
3856 loop = uv_default_loop();
|
|
|
3857
|
|
|
3858 /* Setup */
|
|
|
3859 rmdir("test_dir");
|
|
|
3860 r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb);
|
|
|
3861 ASSERT_OK(r);
|
|
|
3862 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
3863 ASSERT_EQ(1, mkdir_cb_count);
|
|
|
3864 /* Setup Done Here */
|
|
|
3865
|
|
|
3866 /* Get a file descriptor for the directory */
|
|
|
3867 r = uv_fs_open(loop,
|
|
|
3868 &open_req1,
|
|
|
3869 "test_dir",
|
|
|
3870 UV_FS_O_RDONLY | UV_FS_O_DIRECTORY,
|
|
|
3871 S_IWUSR | S_IRUSR,
|
|
|
3872 NULL);
|
|
|
3873 ASSERT_GE(r, 0);
|
|
|
3874 uv_fs_req_cleanup(&open_req1);
|
|
|
3875
|
|
|
3876 /* Try to read data from the directory */
|
|
|
3877 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
3878 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 0, NULL);
|
|
|
3879 #if defined(__FreeBSD__) || \
|
|
|
3880 defined(__OpenBSD__) || \
|
|
|
3881 defined(__NetBSD__) || \
|
|
|
3882 defined(__DragonFly__) || \
|
|
|
3883 defined(_AIX) || \
|
|
|
3884 defined(__sun) || \
|
|
|
3885 defined(__MVS__)
|
|
|
3886 /*
|
|
|
3887 * As of now, these operating systems support reading from a directory,
|
|
|
3888 * that too depends on the filesystem this temporary test directory is
|
|
|
3889 * created on. That is why this assertion is a bit lenient.
|
|
|
3890 */
|
|
|
3891 ASSERT((r >= 0) || (r == UV_EISDIR));
|
|
|
3892 #else
|
|
|
3893 ASSERT_EQ(r, UV_EISDIR);
|
|
|
3894 #endif
|
|
|
3895 uv_fs_req_cleanup(&read_req);
|
|
|
3896
|
|
|
3897 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
3898 ASSERT_OK(r);
|
|
|
3899 uv_fs_req_cleanup(&close_req);
|
|
|
3900
|
|
|
3901 /* Cleanup */
|
|
|
3902 rmdir("test_dir");
|
|
|
3903
|
|
|
3904 MAKE_VALGRIND_HAPPY(loop);
|
|
|
3905 return 0;
|
|
|
3906 }
|
|
|
3907
|
|
|
3908 #ifdef _WIN32
|
|
|
3909
|
|
|
3910 TEST_IMPL(fs_partial_read) {
|
|
|
3911 RETURN_SKIP("Test not implemented on Windows.");
|
|
|
3912 }
|
|
|
3913
|
|
|
3914 TEST_IMPL(fs_partial_write) {
|
|
|
3915 RETURN_SKIP("Test not implemented on Windows.");
|
|
|
3916 }
|
|
|
3917
|
|
|
3918 #else /* !_WIN32 */
|
|
|
3919
|
|
|
3920 struct thread_ctx {
|
|
|
3921 pthread_t pid;
|
|
|
3922 int fd;
|
|
|
3923 char* data;
|
|
|
3924 int size;
|
|
|
3925 int interval;
|
|
|
3926 int doread;
|
|
|
3927 };
|
|
|
3928
|
|
|
3929 static void thread_main(void* arg) {
|
|
|
3930 const struct thread_ctx* ctx;
|
|
|
3931 int size;
|
|
|
3932 char* data;
|
|
|
3933
|
|
|
3934 ctx = (struct thread_ctx*)arg;
|
|
|
3935 size = ctx->size;
|
|
|
3936 data = ctx->data;
|
|
|
3937
|
|
|
3938 while (size > 0) {
|
|
|
3939 ssize_t result;
|
|
|
3940 int nbytes;
|
|
|
3941 nbytes = size < ctx->interval ? size : ctx->interval;
|
|
|
3942 if (ctx->doread) {
|
|
|
3943 result = write(ctx->fd, data, nbytes);
|
|
|
3944 /* Should not see EINTR (or other errors) */
|
|
|
3945 ASSERT_EQ(result, nbytes);
|
|
|
3946 } else {
|
|
|
3947 result = read(ctx->fd, data, nbytes);
|
|
|
3948 /* Should not see EINTR (or other errors),
|
|
|
3949 * but might get a partial read if we are faster than the writer
|
|
|
3950 */
|
|
|
3951 ASSERT(result > 0 && result <= nbytes);
|
|
|
3952 }
|
|
|
3953
|
|
|
3954 pthread_kill(ctx->pid, SIGUSR1);
|
|
|
3955 size -= result;
|
|
|
3956 data += result;
|
|
|
3957 }
|
|
|
3958 }
|
|
|
3959
|
|
|
3960 static void sig_func(uv_signal_t* handle, int signum) {
|
|
|
3961 uv_signal_stop(handle);
|
|
|
3962 }
|
|
|
3963
|
|
|
3964 static size_t uv_test_fs_buf_offset(uv_buf_t* bufs, size_t size) {
|
|
|
3965 size_t offset;
|
|
|
3966 /* Figure out which bufs are done */
|
|
|
3967 for (offset = 0; size > 0 && bufs[offset].len <= size; ++offset)
|
|
|
3968 size -= bufs[offset].len;
|
|
|
3969
|
|
|
3970 /* Fix a partial read/write */
|
|
|
3971 if (size > 0) {
|
|
|
3972 bufs[offset].base += size;
|
|
|
3973 bufs[offset].len -= size;
|
|
|
3974 }
|
|
|
3975 return offset;
|
|
|
3976 }
|
|
|
3977
|
|
|
3978 static void test_fs_partial(int doread) {
|
|
|
3979 struct thread_ctx ctx;
|
|
|
3980 uv_thread_t thread;
|
|
|
3981 uv_signal_t signal;
|
|
|
3982 int pipe_fds[2];
|
|
|
3983 size_t iovcount;
|
|
|
3984 uv_buf_t* iovs;
|
|
|
3985 char* buffer;
|
|
|
3986 size_t index;
|
|
|
3987
|
|
|
3988 iovcount = 54321;
|
|
|
3989
|
|
|
3990 iovs = malloc(sizeof(*iovs) * iovcount);
|
|
|
3991 ASSERT_NOT_NULL(iovs);
|
|
|
3992
|
|
|
3993 ctx.pid = pthread_self();
|
|
|
3994 ctx.doread = doread;
|
|
|
3995 ctx.interval = 1000;
|
|
|
3996 ctx.size = sizeof(test_buf) * iovcount;
|
|
|
3997 ctx.data = calloc(ctx.size, 1);
|
|
|
3998 ASSERT_NOT_NULL(ctx.data);
|
|
|
3999 buffer = calloc(ctx.size, 1);
|
|
|
4000 ASSERT_NOT_NULL(buffer);
|
|
|
4001
|
|
|
4002 for (index = 0; index < iovcount; ++index)
|
|
|
4003 iovs[index] = uv_buf_init(buffer + index * sizeof(test_buf), sizeof(test_buf));
|
|
|
4004
|
|
|
4005 loop = uv_default_loop();
|
|
|
4006
|
|
|
4007 ASSERT_OK(uv_signal_init(loop, &signal));
|
|
|
4008 ASSERT_OK(uv_signal_start(&signal, sig_func, SIGUSR1));
|
|
|
4009
|
|
|
4010 ASSERT_OK(pipe(pipe_fds));
|
|
|
4011
|
|
|
4012 ctx.fd = pipe_fds[doread];
|
|
|
4013 ASSERT_OK(uv_thread_create(&thread, thread_main, &ctx));
|
|
|
4014
|
|
|
4015 if (doread) {
|
|
|
4016 uv_buf_t* read_iovs;
|
|
|
4017 int nread;
|
|
|
4018 read_iovs = iovs;
|
|
|
4019 nread = 0;
|
|
|
4020 while (nread < ctx.size) {
|
|
|
4021 int result;
|
|
|
4022 result = uv_fs_read(loop, &read_req, pipe_fds[0], read_iovs, iovcount, -1, NULL);
|
|
|
4023 if (result > 0) {
|
|
|
4024 size_t read_iovcount;
|
|
|
4025 read_iovcount = uv_test_fs_buf_offset(read_iovs, result);
|
|
|
4026 read_iovs += read_iovcount;
|
|
|
4027 iovcount -= read_iovcount;
|
|
|
4028 nread += result;
|
|
|
4029 } else {
|
|
|
4030 ASSERT_EQ(result, UV_EINTR);
|
|
|
4031 }
|
|
|
4032 uv_fs_req_cleanup(&read_req);
|
|
|
4033 }
|
|
|
4034 } else {
|
|
|
4035 int result;
|
|
|
4036 result = uv_fs_write(loop, &write_req, pipe_fds[1], iovs, iovcount, -1, NULL);
|
|
|
4037 ASSERT_EQ(write_req.result, result);
|
|
|
4038 ASSERT_EQ(result, ctx.size);
|
|
|
4039 uv_fs_req_cleanup(&write_req);
|
|
|
4040 }
|
|
|
4041
|
|
|
4042 ASSERT_OK(uv_thread_join(&thread));
|
|
|
4043
|
|
|
4044 ASSERT_MEM_EQ(buffer, ctx.data, ctx.size);
|
|
|
4045
|
|
|
4046 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
4047
|
|
|
4048 ASSERT_OK(close(pipe_fds[1]));
|
|
|
4049 uv_close((uv_handle_t*) &signal, NULL);
|
|
|
4050
|
|
|
4051 { /* Make sure we read everything that we wrote. */
|
|
|
4052 int result;
|
|
|
4053 result = uv_fs_read(loop, &read_req, pipe_fds[0], iovs, 1, -1, NULL);
|
|
|
4054 ASSERT_OK(result);
|
|
|
4055 uv_fs_req_cleanup(&read_req);
|
|
|
4056 }
|
|
|
4057 ASSERT_OK(close(pipe_fds[0]));
|
|
|
4058
|
|
|
4059 free(iovs);
|
|
|
4060 free(buffer);
|
|
|
4061 free(ctx.data);
|
|
|
4062
|
|
|
4063 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4064 }
|
|
|
4065
|
|
|
4066 TEST_IMPL(fs_partial_read) {
|
|
|
4067 test_fs_partial(1);
|
|
|
4068 return 0;
|
|
|
4069 }
|
|
|
4070
|
|
|
4071 TEST_IMPL(fs_partial_write) {
|
|
|
4072 test_fs_partial(0);
|
|
|
4073 return 0;
|
|
|
4074 }
|
|
|
4075
|
|
|
4076 #endif/* _WIN32 */
|
|
|
4077
|
|
|
4078 TEST_IMPL(fs_read_write_null_arguments) {
|
|
|
4079 int r;
|
|
|
4080
|
|
|
4081 r = uv_fs_read(NULL, &read_req, 0, NULL, 0, -1, NULL);
|
|
|
4082 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4083 uv_fs_req_cleanup(&read_req);
|
|
|
4084
|
|
|
4085 r = uv_fs_write(NULL, &write_req, 0, NULL, 0, -1, NULL);
|
|
|
4086 /* Validate some memory management on failed input validation before sending
|
|
|
4087 fs work to the thread pool. */
|
|
|
4088 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4089 ASSERT_NULL(write_req.path);
|
|
|
4090 ASSERT_NULL(write_req.ptr);
|
|
|
4091 #ifdef _WIN32
|
|
|
4092 ASSERT_NULL(write_req.file.pathw);
|
|
|
4093 ASSERT_NULL(write_req.fs.info.new_pathw);
|
|
|
4094 ASSERT_NULL(write_req.fs.info.bufs);
|
|
|
4095 #else
|
|
|
4096 ASSERT_NULL(write_req.new_path);
|
|
|
4097 ASSERT_NULL(write_req.bufs);
|
|
|
4098 #endif
|
|
|
4099 uv_fs_req_cleanup(&write_req);
|
|
|
4100
|
|
|
4101 iov = uv_buf_init(NULL, 0);
|
|
|
4102 r = uv_fs_read(NULL, &read_req, 0, &iov, 0, -1, NULL);
|
|
|
4103 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4104 uv_fs_req_cleanup(&read_req);
|
|
|
4105
|
|
|
4106 iov = uv_buf_init(NULL, 0);
|
|
|
4107 r = uv_fs_write(NULL, &write_req, 0, &iov, 0, -1, NULL);
|
|
|
4108 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4109 uv_fs_req_cleanup(&write_req);
|
|
|
4110
|
|
|
4111 /* If the arguments are invalid, the loop should not be kept open */
|
|
|
4112 loop = uv_default_loop();
|
|
|
4113
|
|
|
4114 r = uv_fs_read(loop, &read_req, 0, NULL, 0, -1, fail_cb);
|
|
|
4115 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4116 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
4117 uv_fs_req_cleanup(&read_req);
|
|
|
4118
|
|
|
4119 r = uv_fs_write(loop, &write_req, 0, NULL, 0, -1, fail_cb);
|
|
|
4120 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4121 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
4122 uv_fs_req_cleanup(&write_req);
|
|
|
4123
|
|
|
4124 iov = uv_buf_init(NULL, 0);
|
|
|
4125 r = uv_fs_read(loop, &read_req, 0, &iov, 0, -1, fail_cb);
|
|
|
4126 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4127 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
4128 uv_fs_req_cleanup(&read_req);
|
|
|
4129
|
|
|
4130 iov = uv_buf_init(NULL, 0);
|
|
|
4131 r = uv_fs_write(loop, &write_req, 0, &iov, 0, -1, fail_cb);
|
|
|
4132 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4133 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
4134 uv_fs_req_cleanup(&write_req);
|
|
|
4135
|
|
|
4136 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4137 return 0;
|
|
|
4138 }
|
|
|
4139
|
|
|
4140
|
|
|
4141 TEST_IMPL(get_osfhandle_valid_handle) {
|
|
|
4142 int r;
|
|
|
4143 uv_os_fd_t fd;
|
|
|
4144
|
|
|
4145 /* Setup. */
|
|
|
4146 unlink("test_file");
|
|
|
4147
|
|
|
4148 loop = uv_default_loop();
|
|
|
4149
|
|
|
4150 r = uv_fs_open(NULL,
|
|
|
4151 &open_req1, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
4152 S_IWUSR | S_IRUSR,
|
|
|
4153 NULL);
|
|
|
4154 ASSERT_GE(r, 0);
|
|
|
4155 ASSERT_GE(open_req1.result, 0);
|
|
|
4156 uv_fs_req_cleanup(&open_req1);
|
|
|
4157
|
|
|
4158 fd = uv_get_osfhandle(open_req1.result);
|
|
|
4159 #ifdef _WIN32
|
|
|
4160 ASSERT_PTR_NE(fd, INVALID_HANDLE_VALUE);
|
|
|
4161 #else
|
|
|
4162 ASSERT_GE(fd, 0);
|
|
|
4163 #endif
|
|
|
4164
|
|
|
4165 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4166 ASSERT_OK(r);
|
|
|
4167 ASSERT_OK(close_req.result);
|
|
|
4168 uv_fs_req_cleanup(&close_req);
|
|
|
4169
|
|
|
4170 /* Cleanup. */
|
|
|
4171 unlink("test_file");
|
|
|
4172
|
|
|
4173 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4174 return 0;
|
|
|
4175 }
|
|
|
4176
|
|
|
4177 TEST_IMPL(open_osfhandle_valid_handle) {
|
|
|
4178 int r;
|
|
|
4179 uv_os_fd_t handle;
|
|
|
4180 int fd;
|
|
|
4181
|
|
|
4182 /* Setup. */
|
|
|
4183 unlink("test_file");
|
|
|
4184
|
|
|
4185 loop = uv_default_loop();
|
|
|
4186
|
|
|
4187 r = uv_fs_open(NULL,
|
|
|
4188 &open_req1,
|
|
|
4189 "test_file",
|
|
|
4190 UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
4191 S_IWUSR | S_IRUSR,
|
|
|
4192 NULL);
|
|
|
4193 ASSERT_GE(r, 0);
|
|
|
4194 ASSERT_GE(open_req1.result, 0);
|
|
|
4195 uv_fs_req_cleanup(&open_req1);
|
|
|
4196
|
|
|
4197 handle = uv_get_osfhandle(open_req1.result);
|
|
|
4198 #ifdef _WIN32
|
|
|
4199 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE);
|
|
|
4200 #else
|
|
|
4201 ASSERT_GE(handle, 0);
|
|
|
4202 #endif
|
|
|
4203
|
|
|
4204 fd = uv_open_osfhandle(handle);
|
|
|
4205 #ifdef _WIN32
|
|
|
4206 ASSERT_GT(fd, 0);
|
|
|
4207 #else
|
|
|
4208 ASSERT_EQ(fd, open_req1.result);
|
|
|
4209 #endif
|
|
|
4210
|
|
|
4211 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4212 ASSERT_OK(r);
|
|
|
4213 ASSERT_OK(close_req.result);
|
|
|
4214 uv_fs_req_cleanup(&close_req);
|
|
|
4215
|
|
|
4216 /* Cleanup. */
|
|
|
4217 unlink("test_file");
|
|
|
4218
|
|
|
4219 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4220 return 0;
|
|
|
4221 }
|
|
|
4222
|
|
|
4223 TEST_IMPL(fs_file_pos_after_op_with_offset) {
|
|
|
4224 int r;
|
|
|
4225
|
|
|
4226 /* Setup. */
|
|
|
4227 unlink("test_file");
|
|
|
4228 loop = uv_default_loop();
|
|
|
4229
|
|
|
4230 r = uv_fs_open(loop,
|
|
|
4231 &open_req1, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT,
|
|
|
4232 S_IWUSR | S_IRUSR,
|
|
|
4233 NULL);
|
|
|
4234 ASSERT_GT(r, 0);
|
|
|
4235 uv_fs_req_cleanup(&open_req1);
|
|
|
4236
|
|
|
4237 iov = uv_buf_init(test_buf, sizeof(test_buf));
|
|
|
4238 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 0, NULL);
|
|
|
4239 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
4240 ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR));
|
|
|
4241 uv_fs_req_cleanup(&write_req);
|
|
|
4242
|
|
|
4243 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
4244 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 0, NULL);
|
|
|
4245 ASSERT_EQ(r, sizeof(test_buf));
|
|
|
4246 ASSERT_OK(strcmp(buf, test_buf));
|
|
|
4247 ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR));
|
|
|
4248 uv_fs_req_cleanup(&read_req);
|
|
|
4249
|
|
|
4250 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4251 ASSERT_OK(r);
|
|
|
4252 uv_fs_req_cleanup(&close_req);
|
|
|
4253
|
|
|
4254 /* Cleanup */
|
|
|
4255 unlink("test_file");
|
|
|
4256
|
|
|
4257 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4258 return 0;
|
|
|
4259 }
|
|
|
4260
|
|
|
4261 #ifdef _WIN32
|
|
|
4262 static void fs_file_pos_common(void) {
|
|
|
4263 int r;
|
|
|
4264
|
|
|
4265 iov = uv_buf_init("abc", 3);
|
|
|
4266 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
4267 ASSERT_EQ(3, r);
|
|
|
4268 uv_fs_req_cleanup(&write_req);
|
|
|
4269
|
|
|
4270 /* Read with offset should not change the position */
|
|
|
4271 iov = uv_buf_init(buf, 1);
|
|
|
4272 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 1, NULL);
|
|
|
4273 ASSERT_EQ(1, r);
|
|
|
4274 ASSERT_EQ(buf[0], 'b');
|
|
|
4275 uv_fs_req_cleanup(&read_req);
|
|
|
4276
|
|
|
4277 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
4278 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
4279 ASSERT_OK(r);
|
|
|
4280 uv_fs_req_cleanup(&read_req);
|
|
|
4281
|
|
|
4282 /* Write without offset should change the position */
|
|
|
4283 iov = uv_buf_init("d", 1);
|
|
|
4284 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
4285 ASSERT_EQ(1, r);
|
|
|
4286 uv_fs_req_cleanup(&write_req);
|
|
|
4287
|
|
|
4288 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
4289 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
4290 ASSERT_OK(r);
|
|
|
4291 uv_fs_req_cleanup(&read_req);
|
|
|
4292 }
|
|
|
4293
|
|
|
4294 static void fs_file_pos_close_check(const char *contents, int size) {
|
|
|
4295 int r;
|
|
|
4296
|
|
|
4297 /* Close */
|
|
|
4298 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4299 ASSERT_OK(r);
|
|
|
4300 uv_fs_req_cleanup(&close_req);
|
|
|
4301
|
|
|
4302 /* Confirm file contents */
|
|
|
4303 r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY, 0, NULL);
|
|
|
4304 ASSERT_GE(r, 0);
|
|
|
4305 ASSERT_GE(open_req1.result, 0);
|
|
|
4306 uv_fs_req_cleanup(&open_req1);
|
|
|
4307
|
|
|
4308 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
4309 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
4310 ASSERT_EQ(r, size);
|
|
|
4311 ASSERT_OK(strncmp(buf, contents, size));
|
|
|
4312 uv_fs_req_cleanup(&read_req);
|
|
|
4313
|
|
|
4314 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4315 ASSERT_OK(r);
|
|
|
4316 uv_fs_req_cleanup(&close_req);
|
|
|
4317
|
|
|
4318 /* Cleanup */
|
|
|
4319 unlink("test_file");
|
|
|
4320 }
|
|
|
4321
|
|
|
4322 static void fs_file_pos_write(int add_flags) {
|
|
|
4323 int r;
|
|
|
4324
|
|
|
4325 /* Setup. */
|
|
|
4326 unlink("test_file");
|
|
|
4327
|
|
|
4328 r = uv_fs_open(NULL,
|
|
|
4329 &open_req1,
|
|
|
4330 "test_file",
|
|
|
4331 UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_RDWR | add_flags,
|
|
|
4332 S_IWUSR | S_IRUSR,
|
|
|
4333 NULL);
|
|
|
4334 ASSERT_GT(r, 0);
|
|
|
4335 uv_fs_req_cleanup(&open_req1);
|
|
|
4336
|
|
|
4337 fs_file_pos_common();
|
|
|
4338
|
|
|
4339 /* Write with offset should not change the position */
|
|
|
4340 iov = uv_buf_init("e", 1);
|
|
|
4341 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 1, NULL);
|
|
|
4342 ASSERT_EQ(1, r);
|
|
|
4343 uv_fs_req_cleanup(&write_req);
|
|
|
4344
|
|
|
4345 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
4346 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
4347 ASSERT_OK(r);
|
|
|
4348 uv_fs_req_cleanup(&read_req);
|
|
|
4349
|
|
|
4350 fs_file_pos_close_check("aecd", 4);
|
|
|
4351 }
|
|
|
4352 TEST_IMPL(fs_file_pos_write) {
|
|
|
4353 fs_file_pos_write(0);
|
|
|
4354 fs_file_pos_write(UV_FS_O_FILEMAP);
|
|
|
4355
|
|
|
4356 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
4357 return 0;
|
|
|
4358 }
|
|
|
4359
|
|
|
4360 static void fs_file_pos_append(int add_flags) {
|
|
|
4361 int r;
|
|
|
4362
|
|
|
4363 /* Setup. */
|
|
|
4364 unlink("test_file");
|
|
|
4365
|
|
|
4366 r = uv_fs_open(NULL,
|
|
|
4367 &open_req1,
|
|
|
4368 "test_file",
|
|
|
4369 UV_FS_O_APPEND | UV_FS_O_CREAT | UV_FS_O_RDWR | add_flags,
|
|
|
4370 S_IWUSR | S_IRUSR,
|
|
|
4371 NULL);
|
|
|
4372 ASSERT_GT(r, 0);
|
|
|
4373 uv_fs_req_cleanup(&open_req1);
|
|
|
4374
|
|
|
4375 fs_file_pos_common();
|
|
|
4376
|
|
|
4377 /* Write with offset appends (ignoring offset)
|
|
|
4378 * but does not change the position */
|
|
|
4379 iov = uv_buf_init("e", 1);
|
|
|
4380 r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 1, NULL);
|
|
|
4381 ASSERT_EQ(1, r);
|
|
|
4382 uv_fs_req_cleanup(&write_req);
|
|
|
4383
|
|
|
4384 iov = uv_buf_init(buf, sizeof(buf));
|
|
|
4385 r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);
|
|
|
4386 ASSERT_EQ(1, r);
|
|
|
4387 ASSERT_EQ(buf[0], 'e');
|
|
|
4388 uv_fs_req_cleanup(&read_req);
|
|
|
4389
|
|
|
4390 fs_file_pos_close_check("abcde", 5);
|
|
|
4391 }
|
|
|
4392 TEST_IMPL(fs_file_pos_append) {
|
|
|
4393 fs_file_pos_append(0);
|
|
|
4394 fs_file_pos_append(UV_FS_O_FILEMAP);
|
|
|
4395
|
|
|
4396 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
4397 return 0;
|
|
|
4398 }
|
|
|
4399 #endif
|
|
|
4400
|
|
|
4401 TEST_IMPL(fs_null_req) {
|
|
|
4402 /* Verify that all fs functions return UV_EINVAL when the request is NULL. */
|
|
|
4403 int r;
|
|
|
4404
|
|
|
4405 r = uv_fs_open(NULL, NULL, NULL, 0, 0, NULL);
|
|
|
4406 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4407
|
|
|
4408 r = uv_fs_close(NULL, NULL, 0, NULL);
|
|
|
4409 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4410
|
|
|
4411 r = uv_fs_read(NULL, NULL, 0, NULL, 0, -1, NULL);
|
|
|
4412 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4413
|
|
|
4414 r = uv_fs_write(NULL, NULL, 0, NULL, 0, -1, NULL);
|
|
|
4415 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4416
|
|
|
4417 r = uv_fs_unlink(NULL, NULL, NULL, NULL);
|
|
|
4418 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4419
|
|
|
4420 r = uv_fs_mkdir(NULL, NULL, NULL, 0, NULL);
|
|
|
4421 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4422
|
|
|
4423 r = uv_fs_mkdtemp(NULL, NULL, NULL, NULL);
|
|
|
4424 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4425
|
|
|
4426 r = uv_fs_mkstemp(NULL, NULL, NULL, NULL);
|
|
|
4427 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4428
|
|
|
4429 r = uv_fs_rmdir(NULL, NULL, NULL, NULL);
|
|
|
4430 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4431
|
|
|
4432 r = uv_fs_scandir(NULL, NULL, NULL, 0, NULL);
|
|
|
4433 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4434
|
|
|
4435 r = uv_fs_link(NULL, NULL, NULL, NULL, NULL);
|
|
|
4436 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4437
|
|
|
4438 r = uv_fs_symlink(NULL, NULL, NULL, NULL, 0, NULL);
|
|
|
4439 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4440
|
|
|
4441 r = uv_fs_readlink(NULL, NULL, NULL, NULL);
|
|
|
4442 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4443
|
|
|
4444 r = uv_fs_realpath(NULL, NULL, NULL, NULL);
|
|
|
4445 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4446
|
|
|
4447 r = uv_fs_chown(NULL, NULL, NULL, 0, 0, NULL);
|
|
|
4448 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4449
|
|
|
4450 r = uv_fs_fchown(NULL, NULL, 0, 0, 0, NULL);
|
|
|
4451 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4452
|
|
|
4453 r = uv_fs_stat(NULL, NULL, NULL, NULL);
|
|
|
4454 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4455
|
|
|
4456 r = uv_fs_lstat(NULL, NULL, NULL, NULL);
|
|
|
4457 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4458
|
|
|
4459 r = uv_fs_fstat(NULL, NULL, 0, NULL);
|
|
|
4460 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4461
|
|
|
4462 r = uv_fs_rename(NULL, NULL, NULL, NULL, NULL);
|
|
|
4463 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4464
|
|
|
4465 r = uv_fs_fsync(NULL, NULL, 0, NULL);
|
|
|
4466 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4467
|
|
|
4468 r = uv_fs_fdatasync(NULL, NULL, 0, NULL);
|
|
|
4469 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4470
|
|
|
4471 r = uv_fs_ftruncate(NULL, NULL, 0, 0, NULL);
|
|
|
4472 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4473
|
|
|
4474 r = uv_fs_copyfile(NULL, NULL, NULL, NULL, 0, NULL);
|
|
|
4475 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4476
|
|
|
4477 r = uv_fs_sendfile(NULL, NULL, 0, 0, 0, 0, NULL);
|
|
|
4478 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4479
|
|
|
4480 r = uv_fs_access(NULL, NULL, NULL, 0, NULL);
|
|
|
4481 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4482
|
|
|
4483 r = uv_fs_chmod(NULL, NULL, NULL, 0, NULL);
|
|
|
4484 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4485
|
|
|
4486 r = uv_fs_fchmod(NULL, NULL, 0, 0, NULL);
|
|
|
4487 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4488
|
|
|
4489 r = uv_fs_utime(NULL, NULL, NULL, 0.0, 0.0, NULL);
|
|
|
4490 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4491
|
|
|
4492 r = uv_fs_futime(NULL, NULL, 0, 0.0, 0.0, NULL);
|
|
|
4493 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4494
|
|
|
4495 r = uv_fs_statfs(NULL, NULL, NULL, NULL);
|
|
|
4496 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4497
|
|
|
4498 /* This should be a no-op. */
|
|
|
4499 uv_fs_req_cleanup(NULL);
|
|
|
4500
|
|
|
4501 return 0;
|
|
|
4502 }
|
|
|
4503
|
|
|
4504 #ifdef _WIN32
|
|
|
4505 TEST_IMPL(fs_exclusive_sharing_mode) {
|
|
|
4506 int r;
|
|
|
4507
|
|
|
4508 /* Setup. */
|
|
|
4509 unlink("test_file");
|
|
|
4510
|
|
|
4511 ASSERT_GT(UV_FS_O_EXLOCK, 0);
|
|
|
4512
|
|
|
4513 r = uv_fs_open(NULL,
|
|
|
4514 &open_req1,
|
|
|
4515 "test_file",
|
|
|
4516 UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_EXLOCK,
|
|
|
4517 S_IWUSR | S_IRUSR,
|
|
|
4518 NULL);
|
|
|
4519 ASSERT_GE(r, 0);
|
|
|
4520 ASSERT_GE(open_req1.result, 0);
|
|
|
4521 uv_fs_req_cleanup(&open_req1);
|
|
|
4522
|
|
|
4523 r = uv_fs_open(NULL,
|
|
|
4524 &open_req2,
|
|
|
4525 "test_file", UV_FS_O_RDONLY | UV_FS_O_EXLOCK,
|
|
|
4526 S_IWUSR | S_IRUSR,
|
|
|
4527 NULL);
|
|
|
4528 ASSERT_LT(r, 0);
|
|
|
4529 ASSERT_LT(open_req2.result, 0);
|
|
|
4530 uv_fs_req_cleanup(&open_req2);
|
|
|
4531
|
|
|
4532 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4533 ASSERT_OK(r);
|
|
|
4534 ASSERT_OK(close_req.result);
|
|
|
4535 uv_fs_req_cleanup(&close_req);
|
|
|
4536
|
|
|
4537 r = uv_fs_open(NULL,
|
|
|
4538 &open_req2,
|
|
|
4539 "test_file", UV_FS_O_RDONLY | UV_FS_O_EXLOCK,
|
|
|
4540 S_IWUSR | S_IRUSR,
|
|
|
4541 NULL);
|
|
|
4542 ASSERT_GE(r, 0);
|
|
|
4543 ASSERT_GE(open_req2.result, 0);
|
|
|
4544 uv_fs_req_cleanup(&open_req2);
|
|
|
4545
|
|
|
4546 r = uv_fs_close(NULL, &close_req, open_req2.result, NULL);
|
|
|
4547 ASSERT_OK(r);
|
|
|
4548 ASSERT_OK(close_req.result);
|
|
|
4549 uv_fs_req_cleanup(&close_req);
|
|
|
4550
|
|
|
4551 /* Cleanup */
|
|
|
4552 unlink("test_file");
|
|
|
4553
|
|
|
4554 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
4555 return 0;
|
|
|
4556 }
|
|
|
4557 #endif
|
|
|
4558
|
|
|
4559 #ifdef _WIN32
|
|
|
4560 TEST_IMPL(fs_file_flag_no_buffering) {
|
|
|
4561 int r;
|
|
|
4562
|
|
|
4563 /* Setup. */
|
|
|
4564 unlink("test_file");
|
|
|
4565
|
|
|
4566 ASSERT_GT(UV_FS_O_APPEND, 0);
|
|
|
4567 ASSERT_GT(UV_FS_O_CREAT, 0);
|
|
|
4568 ASSERT_GT(UV_FS_O_DIRECT, 0);
|
|
|
4569 ASSERT_GT(UV_FS_O_RDWR, 0);
|
|
|
4570
|
|
|
4571 /* FILE_APPEND_DATA must be excluded from FILE_GENERIC_WRITE: */
|
|
|
4572 r = uv_fs_open(NULL,
|
|
|
4573 &open_req1,
|
|
|
4574 "test_file",
|
|
|
4575 UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_DIRECT,
|
|
|
4576 S_IWUSR | S_IRUSR,
|
|
|
4577 NULL);
|
|
|
4578 ASSERT_GE(r, 0);
|
|
|
4579 ASSERT_GE(open_req1.result, 0);
|
|
|
4580 uv_fs_req_cleanup(&open_req1);
|
|
|
4581
|
|
|
4582 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4583 ASSERT_OK(r);
|
|
|
4584 ASSERT_OK(close_req.result);
|
|
|
4585 uv_fs_req_cleanup(&close_req);
|
|
|
4586
|
|
|
4587 /* FILE_APPEND_DATA and FILE_FLAG_NO_BUFFERING are mutually exclusive: */
|
|
|
4588 r = uv_fs_open(NULL,
|
|
|
4589 &open_req2,
|
|
|
4590 "test_file",
|
|
|
4591 UV_FS_O_APPEND | UV_FS_O_DIRECT,
|
|
|
4592 S_IWUSR | S_IRUSR,
|
|
|
4593 NULL);
|
|
|
4594 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4595 ASSERT_EQ(open_req2.result, UV_EINVAL);
|
|
|
4596 uv_fs_req_cleanup(&open_req2);
|
|
|
4597
|
|
|
4598 /* Cleanup */
|
|
|
4599 unlink("test_file");
|
|
|
4600
|
|
|
4601 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
4602 return 0;
|
|
|
4603 }
|
|
|
4604 #endif
|
|
|
4605
|
|
|
4606 #ifdef _WIN32
|
|
|
4607 int call_icacls(const char* command, ...) {
|
|
|
4608 char icacls_command[1024];
|
|
|
4609 va_list args;
|
|
|
4610
|
|
|
4611 va_start(args, command);
|
|
|
4612 vsnprintf(icacls_command, ARRAYSIZE(icacls_command), command, args);
|
|
|
4613 va_end(args);
|
|
|
4614 return system(icacls_command);
|
|
|
4615 }
|
|
|
4616
|
|
|
4617 TEST_IMPL(fs_open_readonly_acl) {
|
|
|
4618 uv_passwd_t pwd;
|
|
|
4619 uv_fs_t req;
|
|
|
4620 int r;
|
|
|
4621
|
|
|
4622 /*
|
|
|
4623 Based on Node.js test from
|
|
|
4624 https://github.com/nodejs/node/commit/3ba81e34e86a5c32658e218cb6e65b13e8326bc5
|
|
|
4625
|
|
|
4626 If anything goes wrong, you can delte the test_fle_icacls with:
|
|
|
4627
|
|
|
4628 icacls test_file_icacls /remove "%USERNAME%" /inheritance:e
|
|
|
4629 attrib -r test_file_icacls
|
|
|
4630 del test_file_icacls
|
|
|
4631 */
|
|
|
4632
|
|
|
4633 /* Setup - clear the ACL and remove the file */
|
|
|
4634 loop = uv_default_loop();
|
|
|
4635 r = uv_os_get_passwd(&pwd);
|
|
|
4636 ASSERT_OK(r);
|
|
|
4637 call_icacls("icacls test_file_icacls /remove \"%s\" /inheritance:e",
|
|
|
4638 pwd.username);
|
|
|
4639 uv_fs_chmod(loop, &req, "test_file_icacls", S_IWUSR, NULL);
|
|
|
4640 unlink("test_file_icacls");
|
|
|
4641
|
|
|
4642 /* Create the file */
|
|
|
4643 r = uv_fs_open(loop,
|
|
|
4644 &open_req1,
|
|
|
4645 "test_file_icacls",
|
|
|
4646 UV_FS_O_RDONLY | UV_FS_O_CREAT,
|
|
|
4647 S_IRUSR,
|
|
|
4648 NULL);
|
|
|
4649 ASSERT_GE(r, 0);
|
|
|
4650 ASSERT_GE(open_req1.result, 0);
|
|
|
4651 uv_fs_req_cleanup(&open_req1);
|
|
|
4652 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4653 ASSERT_OK(r);
|
|
|
4654 ASSERT_OK(close_req.result);
|
|
|
4655 uv_fs_req_cleanup(&close_req);
|
|
|
4656
|
|
|
4657 /* Set up ACL */
|
|
|
4658 r = call_icacls("icacls test_file_icacls /inheritance:r /remove \"%s\"",
|
|
|
4659 pwd.username);
|
|
|
4660 if (r != 0) {
|
|
|
4661 goto acl_cleanup;
|
|
|
4662 }
|
|
|
4663 r = call_icacls("icacls test_file_icacls /grant \"%s\":RX", pwd.username);
|
|
|
4664 if (r != 0) {
|
|
|
4665 goto acl_cleanup;
|
|
|
4666 }
|
|
|
4667
|
|
|
4668 /* Try opening the file */
|
|
|
4669 r = uv_fs_open(NULL, &open_req1, "test_file_icacls", UV_FS_O_RDONLY, 0,
|
|
|
4670 NULL);
|
|
|
4671 if (r < 0) {
|
|
|
4672 goto acl_cleanup;
|
|
|
4673 }
|
|
|
4674 uv_fs_req_cleanup(&open_req1);
|
|
|
4675 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4676 if (r != 0) {
|
|
|
4677 goto acl_cleanup;
|
|
|
4678 }
|
|
|
4679 uv_fs_req_cleanup(&close_req);
|
|
|
4680
|
|
|
4681 acl_cleanup:
|
|
|
4682 /* Cleanup */
|
|
|
4683 call_icacls("icacls test_file_icacls /remove \"%s\" /inheritance:e",
|
|
|
4684 pwd.username);
|
|
|
4685 unlink("test_file_icacls");
|
|
|
4686 uv_os_free_passwd(&pwd);
|
|
|
4687 ASSERT_OK(r);
|
|
|
4688 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4689 return 0;
|
|
|
4690 }
|
|
|
4691
|
|
|
4692 TEST_IMPL(fs_stat_no_permission) {
|
|
|
4693 uv_passwd_t pwd;
|
|
|
4694 uv_fs_t req;
|
|
|
4695 int r;
|
|
|
4696 char* filename = "test_file_no_permission.txt";
|
|
|
4697
|
|
|
4698 /* Setup - clear the ACL and remove the file */
|
|
|
4699 loop = uv_default_loop();
|
|
|
4700 r = uv_os_get_passwd(&pwd);
|
|
|
4701 ASSERT_OK(r);
|
|
|
4702 call_icacls("icacls %s /remove *S-1-1-0:(F)", filename);
|
|
|
4703 unlink(filename);
|
|
|
4704
|
|
|
4705 /* Create the file */
|
|
|
4706 r = uv_fs_open(loop,
|
|
|
4707 &open_req1,
|
|
|
4708 filename,
|
|
|
4709 UV_FS_O_RDONLY | UV_FS_O_CREAT,
|
|
|
4710 S_IRUSR,
|
|
|
4711 NULL);
|
|
|
4712 ASSERT_GE(r, 0);
|
|
|
4713 ASSERT_GE(open_req1.result, 0);
|
|
|
4714 uv_fs_req_cleanup(&open_req1);
|
|
|
4715 r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);
|
|
|
4716 ASSERT_OK(r);
|
|
|
4717 ASSERT_OK(close_req.result);
|
|
|
4718 uv_fs_req_cleanup(&close_req);
|
|
|
4719
|
|
|
4720 /* Set up ACL */
|
|
|
4721 r = call_icacls("icacls %s /deny *S-1-1-0:(F)", filename);
|
|
|
4722 if (r != 0) {
|
|
|
4723 goto acl_cleanup;
|
|
|
4724 }
|
|
|
4725
|
|
|
4726 /* Read file stats */
|
|
|
4727 r = uv_fs_stat(NULL, &req, filename, NULL);
|
|
|
4728 if (r != 0) {
|
|
|
4729 goto acl_cleanup;
|
|
|
4730 }
|
|
|
4731
|
|
|
4732 uv_fs_req_cleanup(&req);
|
|
|
4733
|
|
|
4734 acl_cleanup:
|
|
|
4735 /* Cleanup */
|
|
|
4736 call_icacls("icacls %s /reset", filename);
|
|
|
4737 uv_fs_unlink(NULL, &unlink_req, filename, NULL);
|
|
|
4738 uv_fs_req_cleanup(&unlink_req);
|
|
|
4739 unlink(filename);
|
|
|
4740 uv_os_free_passwd(&pwd);
|
|
|
4741 ASSERT_OK(r);
|
|
|
4742 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4743 return 0;
|
|
|
4744 }
|
|
|
4745 #endif
|
|
|
4746
|
|
|
4747 #ifdef _WIN32
|
|
|
4748 TEST_IMPL(fs_fchmod_archive_readonly) {
|
|
|
4749 uv_fs_t req;
|
|
|
4750 uv_file file;
|
|
|
4751 int r;
|
|
|
4752 /* Test clearing read-only flag from files with Archive flag cleared */
|
|
|
4753
|
|
|
4754 /* Setup*/
|
|
|
4755 unlink("test_file");
|
|
|
4756 r = uv_fs_open(NULL,
|
|
|
4757 &req, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT,
|
|
|
4758 S_IWUSR | S_IRUSR,
|
|
|
4759 NULL);
|
|
|
4760 ASSERT_GE(r, 0);
|
|
|
4761 ASSERT_GE(req.result, 0);
|
|
|
4762 file = req.result;
|
|
|
4763 uv_fs_req_cleanup(&req);
|
|
|
4764 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
4765 ASSERT_OK(r);
|
|
|
4766 uv_fs_req_cleanup(&req);
|
|
|
4767 /* Make the file read-only and clear archive flag */
|
|
|
4768 r = SetFileAttributes("test_file", FILE_ATTRIBUTE_READONLY);
|
|
|
4769 ASSERT(r);
|
|
|
4770 check_permission("test_file", 0400);
|
|
|
4771 /* Try fchmod */
|
|
|
4772 r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDONLY, 0, NULL);
|
|
|
4773 ASSERT_GE(r, 0);
|
|
|
4774 ASSERT_GE(req.result, 0);
|
|
|
4775 file = req.result;
|
|
|
4776 uv_fs_req_cleanup(&req);
|
|
|
4777 r = uv_fs_fchmod(NULL, &req, file, S_IWUSR, NULL);
|
|
|
4778 ASSERT_OK(r);
|
|
|
4779 ASSERT_OK(req.result);
|
|
|
4780 uv_fs_req_cleanup(&req);
|
|
|
4781 r = uv_fs_close(NULL, &req, file, NULL);
|
|
|
4782 ASSERT_OK(r);
|
|
|
4783 uv_fs_req_cleanup(&req);
|
|
|
4784 check_permission("test_file", S_IWUSR);
|
|
|
4785
|
|
|
4786 /* Restore Archive flag for rest of the tests */
|
|
|
4787 r = SetFileAttributes("test_file", FILE_ATTRIBUTE_ARCHIVE);
|
|
|
4788 ASSERT(r);
|
|
|
4789
|
|
|
4790 return 0;
|
|
|
4791 }
|
|
|
4792
|
|
|
4793 TEST_IMPL(fs_invalid_mkdir_name) {
|
|
|
4794 uv_loop_t* loop;
|
|
|
4795 uv_fs_t req;
|
|
|
4796 int r;
|
|
|
4797
|
|
|
4798 loop = uv_default_loop();
|
|
|
4799 r = uv_fs_mkdir(loop, &req, "invalid>", 0, NULL);
|
|
|
4800 ASSERT_EQ(r, UV_EINVAL);
|
|
|
4801 ASSERT_EQ(UV_EINVAL, uv_fs_mkdir(loop, &req, "test:lol", 0, NULL));
|
|
|
4802
|
|
|
4803 return 0;
|
|
|
4804 }
|
|
|
4805 #endif
|
|
|
4806
|
|
|
4807 TEST_IMPL(fs_statfs) {
|
|
|
4808 uv_fs_t req;
|
|
|
4809 int r;
|
|
|
4810
|
|
|
4811 loop = uv_default_loop();
|
|
|
4812
|
|
|
4813 /* Test the synchronous version. */
|
|
|
4814 r = uv_fs_statfs(NULL, &req, ".", NULL);
|
|
|
4815 ASSERT_OK(r);
|
|
|
4816 statfs_cb(&req);
|
|
|
4817 ASSERT_EQ(1, statfs_cb_count);
|
|
|
4818
|
|
|
4819 /* Test the asynchronous version. */
|
|
|
4820 r = uv_fs_statfs(loop, &req, ".", statfs_cb);
|
|
|
4821 ASSERT_OK(r);
|
|
|
4822 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
4823 ASSERT_EQ(2, statfs_cb_count);
|
|
|
4824
|
|
|
4825 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4826 return 0;
|
|
|
4827 }
|
|
|
4828
|
|
|
4829 TEST_IMPL(fs_get_system_error) {
|
|
|
4830 uv_fs_t req;
|
|
|
4831 int r;
|
|
|
4832 int system_error;
|
|
|
4833
|
|
|
4834 r = uv_fs_statfs(NULL, &req, "non_existing_file", NULL);
|
|
|
4835 ASSERT(r);
|
|
|
4836
|
|
|
4837 system_error = uv_fs_get_system_error(&req);
|
|
|
4838 #ifdef _WIN32
|
|
|
4839 ASSERT_EQ(system_error, ERROR_FILE_NOT_FOUND);
|
|
|
4840 #else
|
|
|
4841 ASSERT_EQ(system_error, ENOENT);
|
|
|
4842 #endif
|
|
|
4843
|
|
|
4844 return 0;
|
|
|
4845 }
|
|
|
4846
|
|
|
4847
|
|
|
4848 TEST_IMPL(fs_stat_batch_multiple) {
|
|
|
4849 uv_fs_t req[300];
|
|
|
4850 int r;
|
|
|
4851 int i;
|
|
|
4852
|
|
|
4853 rmdir("test_dir");
|
|
|
4854
|
|
|
4855 r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0755, NULL);
|
|
|
4856 ASSERT_OK(r);
|
|
|
4857
|
|
|
4858 loop = uv_default_loop();
|
|
|
4859
|
|
|
4860 for (i = 0; i < (int) ARRAY_SIZE(req); ++i) {
|
|
|
4861 r = uv_fs_stat(loop, &req[i], "test_dir", stat_batch_cb);
|
|
|
4862 ASSERT_OK(r);
|
|
|
4863 }
|
|
|
4864
|
|
|
4865 uv_run(loop, UV_RUN_DEFAULT);
|
|
|
4866 ASSERT_EQ(stat_cb_count, ARRAY_SIZE(req));
|
|
|
4867
|
|
|
4868 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4869 return 0;
|
|
|
4870 }
|
|
|
4871
|
|
|
4872
|
|
|
4873 #ifdef _WIN32
|
|
|
4874 TEST_IMPL(fs_wtf) {
|
|
|
4875 int r;
|
|
|
4876 HANDLE file_handle;
|
|
|
4877 uv_dirent_t dent;
|
|
|
4878 static char test_file_buf[PATHMAX];
|
|
|
4879
|
|
|
4880 /* set-up */
|
|
|
4881 _wunlink(L"test_dir/hi\xD801\x0037");
|
|
|
4882 rmdir("test_dir");
|
|
|
4883
|
|
|
4884 loop = uv_default_loop();
|
|
|
4885
|
|
|
4886 r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0777, NULL);
|
|
|
4887 ASSERT_OK(r);
|
|
|
4888 uv_fs_req_cleanup(&mkdir_req);
|
|
|
4889
|
|
|
4890 file_handle = CreateFileW(L"test_dir/hi\xD801\x0037",
|
|
|
4891 GENERIC_WRITE | FILE_WRITE_ATTRIBUTES,
|
|
|
4892 0,
|
|
|
4893 NULL,
|
|
|
4894 CREATE_ALWAYS,
|
|
|
4895 FILE_FLAG_OPEN_REPARSE_POINT |
|
|
|
4896 FILE_FLAG_BACKUP_SEMANTICS,
|
|
|
4897 NULL);
|
|
|
4898 ASSERT_PTR_NE(file_handle, INVALID_HANDLE_VALUE);
|
|
|
4899
|
|
|
4900 CloseHandle(file_handle);
|
|
|
4901
|
|
|
4902 r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL);
|
|
|
4903 ASSERT_EQ(1, r);
|
|
|
4904 ASSERT_EQ(1, scandir_req.result);
|
|
|
4905 ASSERT_NOT_NULL(scandir_req.ptr);
|
|
|
4906 while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
|
|
|
4907 snprintf(test_file_buf, sizeof(test_file_buf), "test_dir\\%s", dent.name);
|
|
|
4908 printf("stat %s\n", test_file_buf);
|
|
|
4909 r = uv_fs_stat(NULL, &stat_req, test_file_buf, NULL);
|
|
|
4910 ASSERT_OK(r);
|
|
|
4911 }
|
|
|
4912 uv_fs_req_cleanup(&scandir_req);
|
|
|
4913 ASSERT_NULL(scandir_req.ptr);
|
|
|
4914
|
|
|
4915 /* clean-up */
|
|
|
4916 _wunlink(L"test_dir/hi\xD801\x0037");
|
|
|
4917 rmdir("test_dir");
|
|
|
4918
|
|
|
4919 MAKE_VALGRIND_HAPPY(loop);
|
|
|
4920 return 0;
|
|
|
4921 }
|
|
|
4922 #endif
|
