c/libuv
1
0
Fork 0
mirror of https://github.com/libuv/libuv synced 2025-03-28 21:13:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

unix,win: add uv_fs_{open,read,close}dir()

Browse Source 
Co-authored-by: Julien Gilli <jgilli@nodejs.org>
Co-authored-by: Jeremy Whitlock <jwhitlock@apache.org>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
PR-URL: https://github.com/libuv/libuv/pull/2057
Refs: https://github.com/joyent/libuv/issues/1430
Refs: https://github.com/joyent/libuv/pull/1521
Refs: https://github.com/joyent/libuv/pull/1574
Refs: https://github.com/libuv/libuv/pull/175
Refs: https://github.com/nodejs/node/issues/583
Refs: https://github.com/libuv/libuv/pull/416
Refs: https://github.com/libuv/libuv/issues/170
This commit is contained in:
cjihrig 2015-01-30 11:04:03 -08:00
parent 575d41481e
commit 99440bb673
No known key found for this signature in database
GPG Key ID: 7434390BDBE9B9C5
13 changed files with 902 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -53,6 +53,7 @@ set(uv_test_sources
test/test-fs-event.c
test/test-fs-poll.c
test/test-fs.c
test/test-fs-readdir.c
test/test-get-currentexe.c
test/test-get-loadavg.c
test/test-get-memory.c

1
Makefile.am
View File

@ -191,6 +191,7 @@ test_run_tests_SOURCES = test/blackhole-server.c \
test/test-fs-event.c \
test/test-fs-poll.c \
test/test-fs.c \
test/test-fs-readdir.c \
test/test-fork.c \
test/test-getters-setters.c \
test/test-get-currentexe.c \

58
docs/src/fs.rst
View File

@ -122,6 +122,21 @@ Data types
uv_dirent_type_t type;
} uv_dirent_t;
.. c:type:: uv_dir_t
Data type used for streaming directory iteration.
Used by :c:func:`uv_fs_opendir()`, :c:func:`uv_fs_readdir()`, and
:c:func:`uv_fs_closedir()`. `dirents` represents a user provided array of
`uv_dirent_t`s used to hold results. `nentries` is the user provided maximum
array size of `dirents`.
::
typedef struct uv_dir_s {
uv_dirent_t* dirents;
size_t nentries;
} uv_dir_t;
Public members
^^^^^^^^^^^^^^
@ -208,6 +223,49 @@ API
Equivalent to :man:`rmdir(2)`.
.. c:function:: int uv_fs_opendir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
Opens `path` as a directory stream. On success, a `uv_dir_t` is allocated
and returned via `req->ptr`. This memory is not freed by
`uv_fs_req_cleanup()`, although `req->ptr` is set to `NULL`. The allocated
memory must be freed by calling `uv_fs_closedir()`. On failure, no memory
is allocated.
The contents of the directory can be iterated over by passing the resulting
`uv_dir_t` to `uv_fs_readdir()`.
.. versionadded:: 1.28.0
.. c:function:: int uv_fs_closedir(uv_loop_t* loop, uv_fs_t* req, uv_dir_t* dir, uv_fs_cb cb)
Closes the directory stream represented by `dir` and frees the memory
allocated by `uv_fs_opendir()`.
.. versionadded:: 1.28.0
.. c:function:: int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, uv_dir_t* dir, uv_fs_cb cb)
Iterates over the directory stream, `dir`, returned by a successful
`uv_fs_opendir()` call. Prior to invoking `uv_fs_readdir()`, the caller
must set `dir->dirents` and `dir->nentries`, representing the array of
:c:type:`uv_dirent_t` elements used to hold the read directory entries and
its size.
On success, the result is an integer >= 0 representing the number of entries
read from the stream.
.. versionadded:: 1.28.0
.. warning::
`uv_fs_readdir()` is not thread safe.
.. note::
This function does not return the "." and ".." entries.
.. note::
On success this function allocates memory that must be freed using
`uv_fs_req_cleanup()`.
.. c:function:: int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb)
.. c:function:: int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent)

25
include/uv.h
View File

@ -202,6 +202,7 @@ typedef enum {
/* Handle types. */
typedef struct uv_loop_s uv_loop_t;
typedef struct uv_handle_s uv_handle_t;
typedef struct uv_dir_s uv_dir_t;
typedef struct uv_stream_s uv_stream_t;
typedef struct uv_tcp_s uv_tcp_t;
typedef struct uv_udp_s uv_udp_t;
@ -1196,9 +1197,19 @@ typedef enum {
UV_FS_FCHOWN,
UV_FS_REALPATH,
UV_FS_COPYFILE,
UV_FS_LCHOWN
UV_FS_LCHOWN,
UV_FS_OPENDIR,
UV_FS_READDIR,
UV_FS_CLOSEDIR
} uv_fs_type;
struct uv_dir_s {
uv_dirent_t* dirents;
size_t nentries;
void* reserved[4];
UV_DIR_PRIVATE_FIELDS
};
/* uv_fs_t is a subclass of uv_req_t. */
struct uv_fs_s {
UV_REQ_FIELDS
@ -1291,6 +1302,18 @@ UV_EXTERN int uv_fs_scandir(uv_loop_t* loop,
uv_fs_cb cb);
UV_EXTERN int uv_fs_scandir_next(uv_fs_t* req,
uv_dirent_t* ent);
UV_EXTERN int uv_fs_opendir(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
uv_fs_cb cb);
UV_EXTERN int uv_fs_readdir(uv_loop_t* loop,
uv_fs_t* req,
uv_dir_t* dir,
uv_fs_cb cb);
UV_EXTERN int uv_fs_closedir(uv_loop_t* loop,
uv_fs_t* req,
uv_dir_t* dir,
uv_fs_cb cb);
UV_EXTERN int uv_fs_stat(uv_loop_t* loop,
uv_fs_t* req,
const char* path,

3
include/uv/unix.h
View File

@ -166,6 +166,9 @@ typedef uid_t uv_uid_t;
typedef struct dirent uv__dirent_t;
#define UV_DIR_PRIVATE_FIELDS \
DIR* dir;
#if defined(DT_UNKNOWN)
# define HAVE_DIRENT_TYPES
# if defined(DT_REG)

5
include/uv/win.h
View File

@ -301,6 +301,11 @@ typedef struct uv__dirent_s {
char d_name[1];
} uv__dirent_t;
#define UV_DIR_PRIVATE_FIELDS \
HANDLE dir_handle; \
WIN32_FIND_DATAW find_data; \
BOOL need_find_call;
#define HAVE_DIRENT_TYPES
#define UV__DT_DIR UV_DIRENT_DIR
#define UV__DT_FILE UV_DIRENT_FILE

125
src/unix/fs.c
View File

@ -351,7 +351,7 @@ static int uv__fs_scandir_sort(UV_CONST_DIRENT** a, UV_CONST_DIRENT** b) {
static ssize_t uv__fs_scandir(uv_fs_t* req) {
uv__dirent_t **dents;
uv__dirent_t** dents;
int n;
dents = NULL;
@ -375,6 +375,87 @@ static ssize_t uv__fs_scandir(uv_fs_t* req) {
return n;
}
static int uv__fs_opendir(uv_fs_t* req) {
uv_dir_t* dir;
dir = uv__malloc(sizeof(*dir));
if (dir == NULL)
goto error;
dir->dir = opendir(req->path);
if (dir->dir == NULL)
goto error;
req->ptr = dir;
return 0;
error:
uv__free(dir);
req->ptr = NULL;
return -1;
}
static int uv__fs_readdir(uv_fs_t* req) {
uv_dir_t* dir;
uv_dirent_t* dirent;
struct dirent* res;
unsigned int dirent_idx;
unsigned int i;
dir = req->ptr;
dirent_idx = 0;
while (dirent_idx < dir->nentries) {
/* readdir() returns NULL on end of directory, as well as on error. errno
is used to differentiate between the two conditions. */
errno = 0;
res = readdir(dir->dir);
if (res == NULL) {
if (errno != 0)
goto error;
break;
}
if (strcmp(res->d_name, ".") == 0 || strcmp(res->d_name, "..") == 0)
continue;
dirent = &dir->dirents[dirent_idx];
dirent->name = uv__strdup(res->d_name);
if (dirent->name == NULL)
goto error;
dirent->type = uv__fs_get_dirent_type(res);
++dirent_idx;
}
return dirent_idx;
error:
for (i = 0; i < dirent_idx; ++i) {
uv__free((char*) dir->dirents[i].name);
dir->dirents[i].name = NULL;
}
return -1;
}
static int uv__fs_closedir(uv_fs_t* req) {
uv_dir_t* dir;
dir = req->ptr;
if (dir->dir != NULL) {
closedir(dir->dir);
dir->dir = NULL;
}
uv__free(req->ptr);
req->ptr = NULL;
return 0;
}
#if defined(_POSIX_PATH_MAX)
# define UV__FS_PATH_MAX _POSIX_PATH_MAX
#elif defined(PATH_MAX)
@ -1266,6 +1347,9 @@ static void uv__fs_work(struct uv__work* w) {
X(OPEN, uv__fs_open(req));
X(READ, uv__fs_read(req));
X(SCANDIR, uv__fs_scandir(req));
X(OPENDIR, uv__fs_opendir(req));
X(READDIR, uv__fs_readdir(req));
X(CLOSEDIR, uv__fs_closedir(req));
X(READLINK, uv__fs_readlink(req));
X(REALPATH, uv__fs_realpath(req));
X(RENAME, rename(req->path, req->new_path));
@ -1536,6 +1620,40 @@ int uv_fs_scandir(uv_loop_t* loop,
POST;
}
int uv_fs_opendir(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
uv_fs_cb cb) {
INIT(OPENDIR);
PATH;
POST;
}
int uv_fs_readdir(uv_loop_t* loop,
uv_fs_t* req,
uv_dir_t* dir,
uv_fs_cb cb) {
INIT(READDIR);
if (dir == NULL || dir->dir == NULL || dir->dirents == NULL)
return UV_EINVAL;
req->ptr = dir;
POST;
}
int uv_fs_closedir(uv_loop_t* loop,
uv_fs_t* req,
uv_dir_t* dir,
uv_fs_cb cb) {
INIT(CLOSEDIR);
if (dir == NULL)
return UV_EINVAL;
req->ptr = dir;
POST;
}
int uv_fs_readlink(uv_loop_t* loop,
uv_fs_t* req,
@ -1676,6 +1794,9 @@ void uv_fs_req_cleanup(uv_fs_t* req) {
req->path = NULL;
req->new_path = NULL;
if (req->fs_type == UV_FS_READDIR && req->ptr != NULL)
uv__fs_readdir_cleanup(req);
if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
uv__fs_scandir_cleanup(req);
@ -1683,7 +1804,7 @@ void uv_fs_req_cleanup(uv_fs_t* req) {
uv__free(req->bufs);
req->bufs = NULL;
if (req->ptr != &req->statbuf)
if (req->fs_type != UV_FS_OPENDIR && req->ptr != &req->statbuf)
uv__free(req->ptr);
req->ptr = NULL;
}

49
src/uv-common.c
View File

@ -631,37 +631,66 @@ int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent) {
dent = dents[(*nbufs)++];
ent->name = dent->d_name;
ent->type = uv__fs_get_dirent_type(dent);
return 0;
}
uv_dirent_type_t uv__fs_get_dirent_type(uv__dirent_t* dent) {
uv_dirent_type_t type;
#ifdef HAVE_DIRENT_TYPES
switch (dent->d_type) {
case UV__DT_DIR:
ent->type = UV_DIRENT_DIR;
type = UV_DIRENT_DIR;
break;
case UV__DT_FILE:
ent->type = UV_DIRENT_FILE;
type = UV_DIRENT_FILE;
break;
case UV__DT_LINK:
ent->type = UV_DIRENT_LINK;
type = UV_DIRENT_LINK;
break;
case UV__DT_FIFO:
ent->type = UV_DIRENT_FIFO;
type = UV_DIRENT_FIFO;
break;
case UV__DT_SOCKET:
ent->type = UV_DIRENT_SOCKET;
type = UV_DIRENT_SOCKET;
break;
case UV__DT_CHAR:
ent->type = UV_DIRENT_CHAR;
type = UV_DIRENT_CHAR;
break;
case UV__DT_BLOCK:
ent->type = UV_DIRENT_BLOCK;
type = UV_DIRENT_BLOCK;
break;
default:
ent->type = UV_DIRENT_UNKNOWN;
type = UV_DIRENT_UNKNOWN;
}
#else
ent->type = UV_DIRENT_UNKNOWN;
type = UV_DIRENT_UNKNOWN;
#endif
return 0;
return type;
}
void uv__fs_readdir_cleanup(uv_fs_t* req) {
uv_dir_t* dir;
uv_dirent_t* dirents;
int i;
if (req->ptr == NULL)
return;
dir = req->ptr;
dirents = dir->dirents;
req->ptr = NULL;
if (dirents == NULL)
return;
for (i = 0; i < req->result; ++i) {
uv__free((char*) dirents[i].name);
dirents[i].name = NULL;
}
}

2
src/uv-common.h
View File

@ -193,6 +193,8 @@ size_t uv__count_bufs(const uv_buf_t bufs[], unsigned int nbufs);
int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value);
void uv__fs_scandir_cleanup(uv_fs_t* req);
void uv__fs_readdir_cleanup(uv_fs_t* req);
uv_dirent_type_t uv__fs_get_dirent_type(uv__dirent_t* dent);
int uv__next_timeout(const uv_loop_t* loop);
void uv__run_timers(uv_loop_t* loop);

175
src/win/fs.c
View File

@ -1125,6 +1125,137 @@ cleanup:
uv__free(dirents);
}
void fs__opendir(uv_fs_t* req) {
WCHAR* pathw;
size_t len;
const WCHAR* fmt;
WCHAR* find_path;
uv_dir_t* dir;
pathw = req->file.pathw;
dir = NULL;
find_path = NULL;
/* Figure out whether path is a file or a directory. */
if (!(GetFileAttributesW(pathw) & FILE_ATTRIBUTE_DIRECTORY)) {
SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);
goto error;
}
dir = uv__malloc(sizeof(*dir));
if (dir == NULL) {
SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
goto error;
}
len = wcslen(pathw);
if (len == 0)
fmt = L"./*";
else if (IS_SLASH(pathw[len - 1]))
fmt = L"%s*";
else
fmt = L"%s\\*";
find_path = uv__malloc(sizeof(WCHAR) * (len + 4));
if (find_path == NULL) {
SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
goto error;
}
_snwprintf(find_path, len + 3, fmt, pathw);
dir->dir_handle = FindFirstFileW(find_path, &dir->find_data);
uv__free(find_path);
find_path = NULL;
if (dir->dir_handle == INVALID_HANDLE_VALUE &&
GetLastError() != ERROR_FILE_NOT_FOUND) {
SET_REQ_WIN32_ERROR(req, GetLastError());
goto error;
}
dir->need_find_call = FALSE;
req->ptr = dir;
SET_REQ_RESULT(req, 0);
return;
error:
uv__free(dir);
uv__free(find_path);
req->ptr = NULL;
}
void fs__readdir(uv_fs_t* req) {
uv_dir_t* dir;
uv_dirent_t* dirents;
uv__dirent_t dent;
unsigned int dirent_idx;
PWIN32_FIND_DATAW find_data;
unsigned int i;
int r;
req->flags |= UV_FS_FREE_PTR;
dir = req->ptr;
dirents = dir->dirents;
memset(dirents, 0, dir->nentries * sizeof(*dir->dirents));
find_data = &dir->find_data;
dirent_idx = 0;
while (dirent_idx < dir->nentries) {
if (dir->need_find_call && FindNextFileW(dir->dir_handle, find_data) == 0) {
if (GetLastError() == ERROR_NO_MORE_FILES)
break;
goto error;
}
/* Skip "." and ".." entries. */
if (find_data->cFileName[0] == L'.' &&
(find_data->cFileName[1] == L'\0' ||
(find_data->cFileName[1] == L'.' &&
find_data->cFileName[2] == L'\0'))) {
dir->need_find_call = TRUE;
continue;
}
r = uv__convert_utf16_to_utf8((const WCHAR*) &find_data->cFileName,
-1,
(char**) &dirents[dirent_idx].name);
if (r != 0)
goto error;
/* Copy file type. */
if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
dent.d_type = UV__DT_DIR;
else if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0)
dent.d_type = UV__DT_LINK;
else if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_DEVICE) != 0)
dent.d_type = UV__DT_CHAR;
else
dent.d_type = UV__DT_FILE;
dirents[dirent_idx].type = uv__fs_get_dirent_type(&dent);
dir->need_find_call = TRUE;
++dirent_idx;
}
SET_REQ_RESULT(req, dirent_idx);
return;
error:
SET_REQ_WIN32_ERROR(req, GetLastError());
for (i = 0; i < dirent_idx; ++i) {
uv__free((char*) dirents[i].name);
dirents[i].name = NULL;
}
}
void fs__closedir(uv_fs_t* req) {
uv_dir_t* dir;
dir = req->ptr;
FindClose(dir->dir_handle);
uv__free(req->ptr);
SET_REQ_RESULT(req, 0);
}
INLINE static int fs__stat_handle(HANDLE handle, uv_stat_t* statbuf,
int do_lstat) {
@ -2039,6 +2170,9 @@ static void uv__fs_work(struct uv__work* w) {
XX(MKDTEMP, mkdtemp)
XX(RENAME, rename)
XX(SCANDIR, scandir)
XX(READDIR, readdir)
XX(OPENDIR, opendir)
XX(CLOSEDIR, closedir)
XX(LINK, link)
XX(SYMLINK, symlink)
XX(READLINK, readlink)
@ -2080,6 +2214,8 @@ void uv_fs_req_cleanup(uv_fs_t* req) {
if (req->flags & UV_FS_FREE_PTR) {
if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
uv__fs_scandir_cleanup(req);
else if (req->fs_type == UV_FS_READDIR)
uv__fs_readdir_cleanup(req);
else
uv__free(req->ptr);
}
@ -2247,6 +2383,45 @@ int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
POST;
}
int uv_fs_opendir(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
uv_fs_cb cb) {
int err;
INIT(UV_FS_OPENDIR);
err = fs__capture_path(req, path, NULL, cb != NULL);
if (err)
return uv_translate_sys_error(err);
POST;
}
int uv_fs_readdir(uv_loop_t* loop,
uv_fs_t* req,
uv_dir_t* dir,
uv_fs_cb cb) {
INIT(UV_FS_READDIR);
if (dir == NULL ||
dir->dirents == NULL ||
dir->dir_handle == INVALID_HANDLE_VALUE) {
return UV_EINVAL;
}
req->ptr = dir;
POST;
}
int uv_fs_closedir(uv_loop_t* loop,
uv_fs_t* req,
uv_dir_t* dir,
uv_fs_cb cb) {
INIT(UV_FS_CLOSEDIR);
if (dir == NULL)
return UV_EINVAL;
req->ptr = dir;
POST;
}
int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
const char* new_path, uv_fs_cb cb) {

462
test/test-fs-readdir.c Normal file
View File

@ -0,0 +1,462 @@
/* Copyright libuv project contributors. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "uv.h"
#include "task.h"
#include <fcntl.h>
#include <string.h>
static uv_fs_t opendir_req;
static uv_fs_t readdir_req;
static uv_fs_t closedir_req;
static uv_dirent_t dirents[1];
static int empty_opendir_cb_count;
static int empty_closedir_cb_count;
static void cleanup_test_files(void) {
uv_fs_t req;
uv_fs_unlink(NULL, &req, "test_dir/file1", NULL);
uv_fs_req_cleanup(&req);
uv_fs_unlink(NULL, &req, "test_dir/file2", NULL);
uv_fs_req_cleanup(&req);
uv_fs_rmdir(NULL, &req, "test_dir/test_subdir", NULL);
uv_fs_req_cleanup(&req);
uv_fs_rmdir(NULL, &req, "test_dir", NULL);
uv_fs_req_cleanup(&req);
}
static void empty_closedir_cb(uv_fs_t* req) {
ASSERT(req == &closedir_req);
ASSERT(req->fs_type == UV_FS_CLOSEDIR);
ASSERT(req->result == 0);
++empty_closedir_cb_count;
uv_fs_req_cleanup(req);
}
static void empty_readdir_cb(uv_fs_t* req) {
uv_dir_t* dir;
int r;
ASSERT(req == &readdir_req);
ASSERT(req->fs_type == UV_FS_READDIR);
ASSERT(req->result == 0);
dir = req->ptr;
r = uv_fs_closedir(uv_default_loop(),
&closedir_req,
dir,
empty_closedir_cb);
ASSERT(r == 0);
uv_fs_req_cleanup(req);
}
static void empty_opendir_cb(uv_fs_t* req) {
uv_dir_t* dir;
int r;
ASSERT(req == &opendir_req);
ASSERT(req->fs_type == UV_FS_OPENDIR);
ASSERT(req->result == 0);
ASSERT(req->ptr != NULL);
dir = req->ptr;
dir->dirents = dirents;
dir->nentries = ARRAY_SIZE(dirents);
r = uv_fs_readdir(uv_default_loop(),
&readdir_req,
dir,
empty_readdir_cb);
ASSERT(r == 0);
uv_fs_req_cleanup(req);
++empty_opendir_cb_count;
}
/*
* This test makes sure that both synchronous and asynchronous flavors
* of the uv_fs_opendir() -> uv_fs_readdir() -> uv_fs_closedir() sequence work
* as expected when processing an empty directory.
*/
TEST_IMPL(fs_readdir_empty_dir) {
const char* path;
uv_fs_t mkdir_req;
uv_fs_t rmdir_req;
int r;
int nb_entries_read;
uv_dir_t* dir;
path = "./empty_dir/";
uv_fs_mkdir(uv_default_loop(), &mkdir_req, path, 0777, NULL);
uv_fs_req_cleanup(&mkdir_req);
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
/* Testing the synchronous flavor. */
r = uv_fs_opendir(uv_default_loop(),
&opendir_req,
path,
NULL);
ASSERT(r == 0);
ASSERT(opendir_req.fs_type == UV_FS_OPENDIR);
ASSERT(opendir_req.result == 0);
ASSERT(opendir_req.ptr != NULL);
dir = opendir_req.ptr;
uv_fs_req_cleanup(&opendir_req);
/* Fill the req to ensure that required fields are cleaned up. */
memset(&readdir_req, 0xdb, sizeof(readdir_req));
dir->dirents = dirents;
dir->nentries = ARRAY_SIZE(dirents);
nb_entries_read = uv_fs_readdir(uv_default_loop(),
&readdir_req,
dir,
NULL);
ASSERT(nb_entries_read == 0);
uv_fs_req_cleanup(&readdir_req);
/* Fill the req to ensure that required fields are cleaned up. */
memset(&closedir_req, 0xdb, sizeof(closedir_req));
uv_fs_closedir(uv_default_loop(), &closedir_req, dir, NULL);
ASSERT(closedir_req.result == 0);
uv_fs_req_cleanup(&closedir_req);
/* Testing the asynchronous flavor. */
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
memset(&readdir_req, 0xdb, sizeof(readdir_req));
memset(&closedir_req, 0xdb, sizeof(closedir_req));
r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, empty_opendir_cb);
ASSERT(r == 0);
ASSERT(empty_opendir_cb_count == 0);
ASSERT(empty_closedir_cb_count == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(empty_opendir_cb_count == 1);
ASSERT(empty_closedir_cb_count == 1);
uv_fs_rmdir(uv_default_loop(), &rmdir_req, path, NULL);
uv_fs_req_cleanup(&rmdir_req);
MAKE_VALGRIND_HAPPY();
return 0;
}
/*
* This test makes sure that reading a non-existing directory with
* uv_fs_{open,read}_dir() returns proper error codes.
*/
static int non_existing_opendir_cb_count;
static void non_existing_opendir_cb(uv_fs_t* req) {
ASSERT(req == &opendir_req);
ASSERT(req->fs_type == UV_FS_OPENDIR);
ASSERT(req->result == UV_ENOENT);
ASSERT(req->ptr == NULL);
uv_fs_req_cleanup(req);
++non_existing_opendir_cb_count;
}
TEST_IMPL(fs_readdir_non_existing_dir) {
const char* path;
int r;
path = "./non-existing-dir/";
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
/* Testing the synchronous flavor. */
r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, NULL);
ASSERT(r == UV_ENOENT);
ASSERT(opendir_req.fs_type == UV_FS_OPENDIR);
ASSERT(opendir_req.result == UV_ENOENT);
ASSERT(opendir_req.ptr == NULL);
uv_fs_req_cleanup(&opendir_req);
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
/* Testing the async flavor. */
r = uv_fs_opendir(uv_default_loop(),
&opendir_req,
path,
non_existing_opendir_cb);
ASSERT(r == 0);
ASSERT(non_existing_opendir_cb_count == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(non_existing_opendir_cb_count == 1);
MAKE_VALGRIND_HAPPY();
return 0;
}
/*
* This test makes sure that reading a file as a directory reports correct
* error codes.
*/
static int file_opendir_cb_count;
static void file_opendir_cb(uv_fs_t* req) {
ASSERT(req == &opendir_req);
ASSERT(req->fs_type == UV_FS_OPENDIR);
ASSERT(req->result == UV_ENOTDIR);
ASSERT(req->ptr == NULL);
uv_fs_req_cleanup(req);
++file_opendir_cb_count;
}
TEST_IMPL(fs_readdir_file) {
const char* path;
int r;
path = "test/fixtures/empty_file";
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
/* Testing the synchronous flavor. */
r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, NULL);
ASSERT(r == UV_ENOTDIR);
ASSERT(opendir_req.fs_type == UV_FS_OPENDIR);
ASSERT(opendir_req.result == UV_ENOTDIR);
ASSERT(opendir_req.ptr == NULL);
uv_fs_req_cleanup(&opendir_req);
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
/* Testing the async flavor. */
r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, file_opendir_cb);
ASSERT(r == 0);
ASSERT(file_opendir_cb_count == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(file_opendir_cb_count == 1);
MAKE_VALGRIND_HAPPY();
return 0;
}
/*
* This test makes sure that reading a non-empty directory with
* uv_fs_{open,read}_dir() returns proper directory entries, including the
* correct entry types.
*/
static int non_empty_opendir_cb_count;
static int non_empty_readdir_cb_count;
static int non_empty_closedir_cb_count;
static void non_empty_closedir_cb(uv_fs_t* req) {
ASSERT(req == &closedir_req);
ASSERT(req->result == 0);
uv_fs_req_cleanup(req);
++non_empty_closedir_cb_count;
}
static void non_empty_readdir_cb(uv_fs_t* req) {
uv_dir_t* dir;
ASSERT(req == &readdir_req);
ASSERT(req->fs_type == UV_FS_READDIR);
dir = req->ptr;
if (req->result == 0) {
uv_fs_req_cleanup(req);
ASSERT(non_empty_readdir_cb_count == 3);
uv_fs_closedir(uv_default_loop(),
&closedir_req,
dir,
non_empty_closedir_cb);
} else {
ASSERT(req->result == 1);
ASSERT(dir->dirents == dirents);
ASSERT(strcmp(dirents[0].name, "file1") == 0 ||
strcmp(dirents[0].name, "file2") == 0 ||
strcmp(dirents[0].name, "test_subdir") == 0);
#ifdef HAVE_DIRENT_TYPES
if (!strcmp(dirents[0].name, "test_subdir"))
ASSERT(dirents[0].type == UV_DIRENT_DIR);
else
ASSERT(dirents[0].type == UV_DIRENT_FILE);
#else
ASSERT(dirents[0].type == UV_DIRENT_UNKNOWN);
#endif /* HAVE_DIRENT_TYPES */
++non_empty_readdir_cb_count;
uv_fs_req_cleanup(req);
dir->dirents = dirents;
dir->nentries = ARRAY_SIZE(dirents);
uv_fs_readdir(uv_default_loop(),
&readdir_req,
dir,
non_empty_readdir_cb);
}
}
static void non_empty_opendir_cb(uv_fs_t* req) {
uv_dir_t* dir;
int r;
ASSERT(req == &opendir_req);
ASSERT(req->fs_type == UV_FS_OPENDIR);
ASSERT(req->result == 0);
ASSERT(req->ptr != NULL);
dir = req->ptr;
dir->dirents = dirents;
dir->nentries = ARRAY_SIZE(dirents);
r = uv_fs_readdir(uv_default_loop(),
&readdir_req,
dir,
non_empty_readdir_cb);
ASSERT(r == 0);
uv_fs_req_cleanup(req);
++non_empty_opendir_cb_count;
}
TEST_IMPL(fs_readdir_non_empty_dir) {
size_t entries_count;
uv_fs_t mkdir_req;
uv_fs_t rmdir_req;
uv_fs_t create_req;
uv_fs_t close_req;
uv_dir_t* dir;
int r;
cleanup_test_files();
r = uv_fs_mkdir(uv_default_loop(), &mkdir_req, "test_dir", 0755, NULL);
ASSERT(r == 0);
/* Create two files synchronously. */
r = uv_fs_open(uv_default_loop(),
&create_req,
"test_dir/file1",
O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR,
NULL);
ASSERT(r >= 0);
uv_fs_req_cleanup(&create_req);
r = uv_fs_close(uv_default_loop(),
&close_req,
create_req.result,
NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);
r = uv_fs_open(uv_default_loop(),
&create_req,
"test_dir/file2",
O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR,
NULL);
ASSERT(r >= 0);
uv_fs_req_cleanup(&create_req);
r = uv_fs_close(uv_default_loop(),
&close_req,
create_req.result,
NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);
r = uv_fs_mkdir(uv_default_loop(),
&mkdir_req,
"test_dir/test_subdir",
0755,
NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&mkdir_req);
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
/* Testing the synchronous flavor. */
r = uv_fs_opendir(uv_default_loop(), &opendir_req, "test_dir", NULL);
ASSERT(r == 0);
ASSERT(opendir_req.fs_type == UV_FS_OPENDIR);
ASSERT(opendir_req.result == 0);
ASSERT(opendir_req.ptr != NULL);
entries_count = 0;
dir = opendir_req.ptr;
dir->dirents = dirents;
dir->nentries = ARRAY_SIZE(dirents);
uv_fs_req_cleanup(&opendir_req);
while (uv_fs_readdir(uv_default_loop(),
&readdir_req,
dir,
NULL) != 0) {
ASSERT(strcmp(dirents[0].name, "file1") == 0 ||
strcmp(dirents[0].name, "file2") == 0 ||
strcmp(dirents[0].name, "test_subdir") == 0);
#ifdef HAVE_DIRENT_TYPES
if (!strcmp(dirents[0].name, "test_subdir"))
ASSERT(dirents[0].type == UV_DIRENT_DIR);
else
ASSERT(dirents[0].type == UV_DIRENT_FILE);
#else
ASSERT(dirents[0].type == UV_DIRENT_UNKNOWN);
#endif /* HAVE_DIRENT_TYPES */
uv_fs_req_cleanup(&readdir_req);
++entries_count;
}
ASSERT(entries_count == 3);
uv_fs_req_cleanup(&readdir_req);
/* Fill the req to ensure that required fields are cleaned up. */
memset(&closedir_req, 0xdb, sizeof(closedir_req));
uv_fs_closedir(uv_default_loop(), &closedir_req, dir, NULL);
ASSERT(closedir_req.result == 0);
uv_fs_req_cleanup(&closedir_req);
/* Testing the asynchronous flavor. */
/* Fill the req to ensure that required fields are cleaned up. */
memset(&opendir_req, 0xdb, sizeof(opendir_req));
r = uv_fs_opendir(uv_default_loop(),
&opendir_req,
"test_dir",
non_empty_opendir_cb);
ASSERT(r == 0);
ASSERT(non_empty_opendir_cb_count == 0);
ASSERT(non_empty_closedir_cb_count == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(non_empty_opendir_cb_count == 1);
ASSERT(non_empty_closedir_cb_count == 1);
uv_fs_rmdir(uv_default_loop(), &rmdir_req, "test_subdir", NULL);
uv_fs_req_cleanup(&rmdir_req);
cleanup_test_files();
MAKE_VALGRIND_HAPPY();
return 0;
}

8
test/test-list.h
View File

@ -346,6 +346,10 @@ TEST_DECLARE (fs_scandir_empty_dir)
TEST_DECLARE (fs_scandir_non_existent_dir)
TEST_DECLARE (fs_scandir_file)
TEST_DECLARE (fs_open_dir)
TEST_DECLARE (fs_readdir_empty_dir)
TEST_DECLARE (fs_readdir_file)
TEST_DECLARE (fs_readdir_non_empty_dir)
TEST_DECLARE (fs_readdir_non_existing_dir)
TEST_DECLARE (fs_rename_to_existing_file)
TEST_DECLARE (fs_write_multiple_bufs)
TEST_DECLARE (fs_read_write_null_arguments)
@ -924,6 +928,10 @@ TASK_LIST_START
TEST_ENTRY (fs_scandir_non_existent_dir)
TEST_ENTRY (fs_scandir_file)
TEST_ENTRY (fs_open_dir)
TEST_ENTRY (fs_readdir_empty_dir)
TEST_ENTRY (fs_readdir_file)
TEST_ENTRY (fs_readdir_non_empty_dir)
TEST_ENTRY (fs_readdir_non_existing_dir)
TEST_ENTRY (fs_rename_to_existing_file)
TEST_ENTRY (fs_write_multiple_bufs)
TEST_ENTRY (fs_write_alotof_bufs)

1
test/test.gyp
View File

@ -32,6 +32,7 @@
'test-fail-always.c',
'test-fork.c',
'test-fs.c',
'test-fs-readdir.c',
'test-fs-copyfile.c',
'test-fs-event.c',
'test-fs-poll.c',