view release on metacpan or search on metacpan
libuv/ChangeLog view on Meta::CPAN
12941295129612971298129913001301130213031304130513061307130813091310131113121313Changes since version 1.10.0:
* Now working on version 1.10.1 (cjihrig)
* win: fix anonymous union syntax (Brad King)
* win: add missing break statement (cjihrig)
* doc: fix wrong man page
link
for
uv_fs_lstat() (Michele Caini)
* win, tty: handle empty buffer in uv_tty_write_bufs (Hitesh Kanwathirtha)
* doc: add cjihrig alternative GPG ID (cjihrig)
* Revert
"win,tty: add support for ANSI codes in win10 v1511"
(Ben Noordhuis)
2016.10.25, Version 1.10.0 (Stable), c8a373c729b4c9392e0e14fc53cd6b67b3051ab9
libuv/docs/src/fs.rst view on Meta::CPAN
274275276277278279280281282283284285286287288289290291292293294295296297298
get `ent` populated
with
the
next
directory entry data. When there are
no
more entries ``UV_EOF`` will be returned.
.. note::
Unlike `scandir(3)`, this function does not
return
the
"."
and
".."
entries.
.. note::
On Linux, getting the type of an entry is only supported by some file systems (btrfs, ext2,
ext3 and ext4 at the
time
of this writing), check the :man:`getdents(2)` man page.
.. c:function::
int
uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
.. c:function::
int
uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)
.. c:function::
int
uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
Equivalent to :man:`
stat
(2)`, :man:`fstat(2)` and :man:`
lstat
(2)` respectively.
.. c:function::
int
uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb)
Equivalent to :man:`
rename
(2)`.
.. c:function::
int
uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)
Equivalent to :man:`fsync(2)`.
.. note::
libuv/docs/src/fs_event.rst view on Meta::CPAN
666768697071727374757677787980818283848586* By
default
,
if
the fs event watcher is
given
a directory name, we will
* watch
for
all events in that directory. This flags overrides this behavior
* and makes fs_event report only changes to the directory entry itself. This
* flag does not affect individual files watched.
* This flag is currently not implemented yet on any backend.
*/
UV_FS_EVENT_WATCH_ENTRY = 1,
/*
* or kqueue to detect events. This may not work on remote file systems such
* as NFS mounts. This flag makes fs_event fall back to calling
stat
() on a
* regular interval.
* This flag is currently not implemented yet on any backend.
*/
UV_FS_EVENT_STAT = 2,
/*
* By
default
, event watcher,
when
watching directory, is not registering
* (is ignoring) changes in its subdirectories.
* This flag will
override
this behaviour on platforms that support it.
*/
UV_FS_EVENT_RECURSIVE = 4
libuv/include/uv.h view on Meta::CPAN
121712181219122012211222122312241225122612271228122912301231123212331234123512361237/* uv_fs_t is a subclass of uv_req_t. */
struct uv_fs_s {
UV_REQ_FIELDS
uv_fs_type fs_type;
uv_loop_t* loop;
uv_fs_cb cb;
ssize_t result;
void* ptr;
const char* path;
uv_stat_t statbuf; /* Stores the result of uv_fs_stat() and uv_fs_fstat(). */
UV_FS_PRIVATE_FIELDS
};
UV_EXTERN uv_fs_type uv_fs_get_type(const uv_fs_t*);
UV_EXTERN ssize_t uv_fs_get_result(const uv_fs_t*);
UV_EXTERN void* uv_fs_get_ptr(const uv_fs_t*);
UV_EXTERN const char* uv_fs_get_path(const uv_fs_t*);
UV_EXTERN uv_stat_t* uv_fs_get_statbuf(uv_fs_t*);
UV_EXTERN void uv_fs_req_cleanup(uv_fs_t* req);
libuv/include/uv.h view on Meta::CPAN
1312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336
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,
uv_fs_cb cb);
UV_EXTERN
int
uv_fs_fstat(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
uv_fs_cb cb);
UV_EXTERN
int
uv_fs_rename(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
const char* new_path,
uv_fs_cb cb);
UV_EXTERN
int
uv_fs_fsync(uv_loop_t* loop,
uv_fs_t* req,
libuv/include/uv.h view on Meta::CPAN
136713681369137013711372137313741375137613771378137913801381138213831384138513861387
const char* path,
double atime,
double mtime,
uv_fs_cb cb);
UV_EXTERN
int
uv_fs_futime(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
double atime,
double mtime,
uv_fs_cb cb);
UV_EXTERN
int
uv_fs_lstat(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
uv_fs_cb cb);
UV_EXTERN
int
uv_fs_link(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
const char* new_path,
uv_fs_cb cb);
/*
libuv/include/uv.h view on Meta::CPAN
144314441445144614471448144914501451145214531454145514561457145814591460146114621463struct uv_fs_event_s {
UV_HANDLE_FIELDS
/* private */
char* path;
UV_FS_EVENT_PRIVATE_FIELDS
};
/*
* uv_fs_stat() based polling file watcher.
*/
struct uv_fs_poll_s {
UV_HANDLE_FIELDS
/* Private, don't touch. */
void* poll_ctx;
};
UV_EXTERN
int
uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle);
UV_EXTERN
int
uv_fs_poll_start(uv_fs_poll_t* handle,
uv_fs_poll_cb poll_cb,
libuv/include/uv.h view on Meta::CPAN
149714981499150015011502150315041505150615071508150915101511151215131514151515161517* watch
for
all events in that directory. This flags overrides this behavior
* and makes fs_event report only changes to the directory entry itself. This
* flag does not affect individual files watched.
* This flag is currently not implemented yet on any backend.
*/
UV_FS_EVENT_WATCH_ENTRY = 1,
/*
* or kqueue to detect events. This may not work on remote filesystems such
* as NFS mounts. This flag makes fs_event fall back to calling
stat
() on a
* regular interval.
* This flag is currently not implemented yet on any backend.
*/
UV_FS_EVENT_STAT = 2,
/*
* By
default
, event watcher,
when
watching directory, is not registering
* (is ignoring) changes in it's subdirectories.
* This flag will
override
this behaviour on platforms that support it.
*/
libuv/src/fs-poll.c view on Meta::CPAN
8990919293949596979899100101102103104105106107108ctx->parent_handle = handle;
memcpy(ctx->path, path, len + 1);
err = uv_timer_init(loop,
&ctx
->timer_handle);
if
(err < 0)
goto
error;
ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
uv__handle_unref(
&ctx
->timer_handle);
err = uv_fs_stat(loop,
&ctx
->fs_req, ctx->path, poll_cb);
if
(err < 0)
goto
error;
if
(handle->poll_ctx != NULL)
ctx->previous = handle->poll_ctx;
handle->poll_ctx = ctx;
uv__handle_start(handle);
return
0;
libuv/src/fs-poll.c view on Meta::CPAN
170171172173174175176177178179180181182183184185186187188189static void timer_cb(uv_timer_t* timer) {
struct poll_ctx* ctx;
ctx = container_of(timer, struct poll_ctx, timer_handle);
assert(ctx->parent_handle != NULL);
assert(ctx->parent_handle->poll_ctx == ctx);
ctx->start_time = uv_now(ctx->loop);
if
(uv_fs_stat(ctx->loop,
&ctx
->fs_req, ctx->path, poll_cb))
abort();
}
static void poll_cb(uv_fs_t* req) {
uv_stat_t* statbuf;
struct poll_ctx* ctx;
uint64_t interval;
uv_fs_poll_t* handle;
libuv/src/fs-poll.c view on Meta::CPAN
215216217218219220221222223224225226227228229230231232233234235
ctx->busy_polling = 1;
out:
uv_fs_req_cleanup(req);
if
(!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle)) {
uv_close((uv_handle_t*)
&ctx
->timer_handle, timer_close_cb);
return
;
}
/* Reschedule timer, subtract the delay from doing the
stat
(). */
interval = ctx->interval;
interval -= (uv_now(ctx->loop) - ctx->start_time) % interval;
if
(uv_timer_start(
&ctx
->timer_handle, timer_cb, interval, 0))
abort();
}
static void timer_close_cb(uv_handle_t* timer) {
struct poll_ctx* ctx;
libuv/src/unix/aix.c view on Meta::CPAN
373374375376377378379380381382383384385386387388389390391392393/*
* Determine whether
given
pathname is a directory
* Returns 0
if
the path is a directory, -1
if
not
*
* Note: Opportunity here
for
more detailed error information but
* that requires changing callers of this function as well
*/
static
int
uv__path_is_a_directory(char* filename) {
struct
stat
statbuf;
if
(
stat
(filename,
&statbuf
) < 0)
return
-1; /* failed: not a directory, assume it is a file */
if
(statbuf.st_type == VDIR)
return
0;
return
-1;
}
/*
libuv/src/unix/fs.c view on Meta::CPAN
326327328329330331332333334335336337338339340341342343344
uv__free(req->bufs);
req->bufs = NULL;
req->nbufs = 0;
#ifdef __PASE__
/* PASE returns EOPNOTSUPP
when
reading a directory, convert to EISDIR */
if
(result == -1 && errno == EOPNOTSUPP) {
struct
stat
buf;
ssize_t rc;
rc = fstat(req->file,
&buf
);
if
(rc == 0 && S_ISDIR(buf.st_mode)) {
errno = EISDIR;
}
}
#endif
return
result;
}
libuv/src/unix/fs.c view on Meta::CPAN
490491492493494495496497498499500501502503504505506507508509510static ssize_t uv__fs_readlink(uv_fs_t* req) {
ssize_t maxlen;
ssize_t len;
char* buf;
char* newbuf;
#if defined(UV__FS_PATH_MAX_FALLBACK)
/* We may not have a real PATH_MAX. Read size of
link
. */
struct
stat
st;
int
ret;
ret =
lstat
(req->path,
&st
);
if
(ret != 0)
return
-1;
if
(!S_ISLNK(st.st_mode)) {
errno = EINVAL;
return
-1;
}
maxlen = st.st_size;
/* According to
readlink
(2)
lstat
can report st_size == 0
libuv/src/unix/fs.c view on Meta::CPAN
914915916917918919920921922923924925926927928929930931932933934err = 0;
/* Open the source file. */
srcfd = uv_fs_open(NULL,
&fs_req
, req->path, O_RDONLY, 0, NULL);
uv_fs_req_cleanup(
&fs_req
);
if
(srcfd < 0)
return
srcfd;
/* Get the source file's mode. */
if
(fstat(srcfd,
&statsbuf
)) {
err = UV__ERR(errno);
goto
out;
}
dst_flags = O_WRONLY | O_CREAT | O_TRUNC;
if
(req->flags & UV_FS_COPYFILE_EXCL)
dst_flags |= O_EXCL;
/* Open the destination file. */
libuv/src/unix/fs.c view on Meta::CPAN
102110221023102410251026102710281029103010311032103310341035103610371038103910401041
}
}
if
(result == 0)
return
0;
errno = UV__ERR(result);
return
-1;
}
static void uv__to_stat(struct
stat
* src, uv_stat_t* dst) {
dst->st_dev = src->st_dev;
dst->st_mode = src->st_mode;
dst->st_nlink = src->st_nlink;
dst->st_uid = src->st_uid;
dst->st_gid = src->st_gid;
dst->st_rdev = src->st_rdev;
dst->st_ino = src->st_ino;
dst->st_size = src->st_size;
dst->st_blksize = src->st_blksize;
dst->st_blocks = src->st_blocks;
libuv/src/unix/fs.c view on Meta::CPAN
11661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227
buf->st_birthtim.tv_sec = statxbuf.stx_btime.tv_sec;
buf->st_birthtim.tv_nsec = statxbuf.stx_btime.tv_nsec;
return
0;
#else
return
UV_ENOSYS;
#endif /* __linux__ */
}
static
int
uv__fs_stat(const char
*path
, uv_stat_t
*buf
) {
struct
stat
pbuf;
int
ret;
ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 0, buf);
if
(ret != UV_ENOSYS)
return
ret;
ret =
stat
(path,
&pbuf
);
if
(ret == 0)
uv__to_stat(
&pbuf
, buf);
return
ret;
}
static
int
uv__fs_lstat(const char
*path
, uv_stat_t
*buf
) {
struct
stat
pbuf;
int
ret;
ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 1, buf);
if
(ret != UV_ENOSYS)
return
ret;
ret =
lstat
(path,
&pbuf
);
if
(ret == 0)
uv__to_stat(
&pbuf
, buf);
return
ret;
}
static
int
uv__fs_fstat(
int
fd, uv_stat_t
*buf
) {
struct
stat
pbuf;
int
ret;
ret = uv__fs_statx(fd,
""
, /* is_fstat */ 1, /* is_lstat */ 0, buf);
if
(ret != UV_ENOSYS)
return
ret;
ret = fstat(fd,
&pbuf
);
if
(ret == 0)
uv__to_stat(
&pbuf
, buf);
return
ret;
}
static size_t uv__fs_buf_offset(uv_buf_t* bufs, size_t size) {
size_t offset;
/* Figure out which bufs are done */
for
(offset = 0; size > 0 && bufs[offset].len <= size; ++offset)
size -= bufs[offset].len;
libuv/src/unix/fs.c view on Meta::CPAN
1300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339
switch (req->fs_type) {
X(ACCESS, access(req->path, req->flags));
X(CHMOD,
chmod
(req->path, req->mode));
X(CHOWN,
chown
(req->path, req->uid, req->gid));
X(CLOSE, uv__fs_close(req->file));
X(COPYFILE, uv__fs_copyfile(req));
X(FCHMOD, fchmod(req->file, req->mode));
X(FCHOWN, fchown(req->file, req->uid, req->gid));
X(LCHOWN, lchown(req->path, req->uid, req->gid));
X(FDATASYNC, uv__fs_fdatasync(req));
X(FSTAT, uv__fs_fstat(req->file,
&req
->statbuf));
X(FSYNC, uv__fs_fsync(req));
X(FTRUNCATE, ftruncate(req->file, req->off));
X(FUTIME, uv__fs_futime(req));
X(LSTAT, uv__fs_lstat(req->path,
&req
->statbuf));
X(LINK,
link
(req->path, req->new_path));
X(MKDIR,
mkdir
(req->path, req->mode));
X(MKDTEMP, uv__fs_mkdtemp(req));
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));
X(RMDIR,
rmdir
(req->path));
X(SENDFILE, uv__fs_sendfile(req));
X(STAT, uv__fs_stat(req->path,
&req
->statbuf));
X(SYMLINK,
symlink
(req->path, req->new_path));
X(UNLINK,
unlink
(req->path));
X(UTIME, uv__fs_utime(req));
X(WRITE, uv__fs_write_all(req));
default
: abort();
}
#undef X
}
while
(r == -1 && errno == EINTR && retry_on_eintr);
if
(r == -1)
libuv/src/unix/fs.c view on Meta::CPAN
144914501451145214531454145514561457145814591460146114621463146414651466146714681469}
int
uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
INIT(FDATASYNC);
req->file = file;
POST;
}
int
uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
INIT(FSTAT);
req->file = file;
POST;
}
int
uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
INIT(FSYNC);
req->file = file;
POST;
libuv/src/unix/fs.c view on Meta::CPAN
148914901491149214931494149514961497149814991500150115021503150415051506150715081509
double mtime,
uv_fs_cb cb) {
INIT(FUTIME);
req->file = file;
req->atime = atime;
req->mtime = mtime;
POST;
}
int
uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
INIT(LSTAT);
PATH;
POST;
}
int
uv_fs_link(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
const char* new_path,
libuv/src/unix/fs.c view on Meta::CPAN
167316741675167616771678167916801681168216831684168516861687168816891690169116921693
uv_fs_cb cb) {
INIT(SENDFILE);
req->flags = in_fd; /* hack */
req->file = out_fd;
req->off = off;
req->bufsml[0].len = len;
POST;
}
int
uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
INIT(STAT);
PATH;
POST;
}
int
uv_fs_symlink(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
const char* new_path,
libuv/src/unix/pipe.c view on Meta::CPAN
344345346347348349350351352353354355356357358359360361362363if
(name_buffer == NULL)
return
UV_ENOMEM;
r = uv_pipe_getsockname(handle, name_buffer,
&name_len
);
if
(r != 0) {
uv__free(name_buffer);
return
r;
}
/*
stat
must be used as fstat
has
a bug on Darwin */
if
(
stat
(name_buffer,
&pipe_stat
) == -1) {
uv__free(name_buffer);
return
-errno;
}
desired_mode = 0;
if
(mode & UV_READABLE)
desired_mode |= S_IRUSR | S_IRGRP | S_IROTH;
if
(mode & UV_WRITABLE)
desired_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
libuv/src/unix/tty.c view on Meta::CPAN
6566676869707172737475767778798081828384/* Lookup device's major
for
the pts driver and cache it. */
static devmajor_t pts = NODEVMAJOR;
if
(pts == NODEVMAJOR) {
pts = getdevmajor(
"pts"
, S_IFCHR);
if
(pts == NODEVMAJOR)
abort();
}
/* Lookup
stat
structure behind the file descriptor. */
if
(fstat(fd,
&sb
) != 0)
abort();
/* Assert character device. */
if
(!S_ISCHR(sb.st_mode))
abort();
/* Assert valid major. */
if
(major(sb.st_rdev) == NODEVMAJOR)
abort();
libuv/src/unix/tty.c view on Meta::CPAN
289290291292293294295296297298299300301302303304305306307308309struct
stat
s;
socklen_t len;
int
type;
if
(file < 0)
return
UV_UNKNOWN_HANDLE;
if
(isatty(file))
return
UV_TTY;
if
(fstat(file,
&s
))
return
UV_UNKNOWN_HANDLE;
if
(S_ISREG(s.st_mode))
return
UV_FILE;
if
(S_ISCHR(s.st_mode))
return
UV_FILE; /* XXX UV_NAMED_PIPE? */
if
(S_ISFIFO(s.st_mode))
return
UV_NAMED_PIPE;
libuv/src/win/fs.c view on Meta::CPAN
144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478
CloseHandle(handle);
return
;
}
req->ptr =
&req
->statbuf;
req->result = 0;
CloseHandle(handle);
}
static void fs__stat(uv_fs_t* req) {
fs__stat_prepare_path(req->file.pathw);
fs__stat_impl(req, 0);
}
static void fs__lstat(uv_fs_t* req) {
fs__stat_prepare_path(req->file.pathw);
fs__stat_impl(req, 1);
}
static void fs__fstat(uv_fs_t* req) {
int
fd = req->file.fd;
HANDLE handle;
VERIFY_FD(fd, req);
handle = uv__get_osfhandle(fd);
if
(handle == INVALID_HANDLE_VALUE) {
SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
return
;
libuv/src/win/fs.c view on Meta::CPAN
2512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557
INIT(UV_FS_LCHOWN);
err = fs__capture_path(req, path, NULL, cb != NULL);
if
(err) {
return
uv_translate_sys_error(err);
}
POST;
}
int
uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
int
err;
INIT(UV_FS_STAT);
err = fs__capture_path(req, path, NULL, cb != NULL);
if
(err) {
return
uv_translate_sys_error(err);
}
POST;
}
int
uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
int
err;
INIT(UV_FS_LSTAT);
err = fs__capture_path(req, path, NULL, cb != NULL);
if
(err) {
return
uv_translate_sys_error(err);
}
POST;
}
int
uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
INIT(UV_FS_FSTAT);
req->file.fd = fd;
POST;
}
int
uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
const char* new_path, uv_fs_cb cb) {
int
err;
libuv/test/benchmark-fs-stat.c view on Meta::CPAN
222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135#include "task.h"
#include "uv.h"
#include <stdio.h>
#include <stdlib.h>
#define NUM_SYNC_REQS (10 * 1e5)
#define NUM_ASYNC_REQS (1 * (int) 1e5)
#define MAX_CONCURRENT_REQS 32
#define sync_stat(req, path) \
do
{ \
uv_fs_stat(NULL, (req), (path), NULL); \
uv_fs_req_cleanup((req)); \
} \
while
(0)
struct async_req {
const char* path;
uv_fs_t fs_req;
int
* count;
};
static void warmup(const char* path) {
uv_fs_t reqs[MAX_CONCURRENT_REQS];
unsigned
int
i;
/* warm up the thread pool */
for
(i = 0; i < ARRAY_SIZE(reqs); i++)
uv_fs_stat(uv_default_loop(), reqs + i, path, uv_fs_req_cleanup);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
/* warm up the OS dirent cache */
for
(i = 0; i < 16; i++)
sync_stat(reqs + 0, path);
}
static void sync_bench(const char* path) {
uint64_t
before
;
uint64_t
after
;
uv_fs_t req;
int
i;
/*
do
the sync benchmark */
before
= uv_hrtime();
for
(i = 0; i < NUM_SYNC_REQS; i++)
sync_stat(
&req
, path);
after
= uv_hrtime();
printf
(
"%s stats (sync): %.2fs (%s/s)\n"
,
fmt(1.0 * NUM_SYNC_REQS),
(
after
-
before
) / 1e9,
fmt((1.0 * NUM_SYNC_REQS) / ((
after
-
before
) / 1e9)));
fflush(stdout);
}
static void stat_cb(uv_fs_t* fs_req) {
struct async_req* req = container_of(fs_req, struct async_req, fs_req);
uv_fs_req_cleanup(
&req
->fs_req);
if
(
*req
->count == 0)
return
;
uv_fs_stat(uv_default_loop(),
&req
->fs_req, req->path, stat_cb);
(
*req
->count)--;
}
static void async_bench(const char* path) {
struct async_req reqs[MAX_CONCURRENT_REQS];
struct async_req* req;
uint64_t
before
;
uint64_t
after
;
int
count;
int
i;
for
(i = 1; i <= MAX_CONCURRENT_REQS; i++) {
count = NUM_ASYNC_REQS;
for
(req = reqs; req < reqs + i; req++) {
req->path = path;
req->count =
&count
;
uv_fs_stat(uv_default_loop(),
&req
->fs_req, req->path, stat_cb);
}
before
= uv_hrtime();
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
after
= uv_hrtime();
printf
(
"%s stats (%d concurrent): %.2fs (%s/s)\n"
,
fmt(1.0 * NUM_ASYNC_REQS),
i,
(
after
-
before
) / 1e9,
fmt((1.0 * NUM_ASYNC_REQS) / ((
after
-
before
) / 1e9)));
fflush(stdout);
}
}
/* This benchmark aims to measure the overhead of doing I/O syscalls from
* the thread pool. The
stat
()
syscall
was chosen because its results are
* easy
for
the operating
system
to cache, taking the actual I/O overhead
* out of the equation.
*/
BENCHMARK_IMPL(fs_stat) {
const char path[] =
"."
;
warmup(path);
sync_bench(path);
async_bench(path);
MAKE_VALGRIND_HAPPY();
return
0;
libuv/test/runner-unix.c view on Meta::CPAN
343344345346347348349350351352353354355356357358359360361362363
close
(args.
pipe
[1]);
return
retval;
}
/* Returns the number of bytes in the stdio output buffer
for
process `p`. */
long
int
process_output_size(process_info_t
*p
) {
/* Size of the p->stdout_file */
struct
stat
buf;
int
r = fstat(
fileno
(p->stdout_file),
&buf
);
if
(r < 0) {
return
-1;
}
return
(long)buf.st_size;
}
/* Copy the contents of the stdio output buffer to `fd`. */
int
process_copy_output(process_info_t* p, FILE* stream) {
libuv/test/test-fs-copyfile.c view on Meta::CPAN
4445464748495051525354555657585960616263646566676869static void handle_result(uv_fs_t* req) {
uv_fs_t stat_req;
uint64_t size;
uint64_t mode;
int
r;
ASSERT(req->fs_type == UV_FS_COPYFILE);
ASSERT(req->result == 0);
/* Verify that the file size and mode are the same. */
r = uv_fs_stat(NULL,
&stat_req
, req->path, NULL);
ASSERT(r == 0);
size = stat_req.statbuf.st_size;
mode = stat_req.statbuf.st_mode;
uv_fs_req_cleanup(
&stat_req
);
r = uv_fs_stat(NULL,
&stat_req
, dst, NULL);
ASSERT(r == 0);
ASSERT(stat_req.statbuf.st_size == size);
ASSERT(stat_req.statbuf.st_mode == mode);
uv_fs_req_cleanup(
&stat_req
);
uv_fs_req_cleanup(req);
result_check_count++;
}
static void touch_file(const char* name, unsigned
int
size) {
libuv/test/test-fs-copyfile.c view on Meta::CPAN
108109110111112113114115116117118119120121122123124125126127128uv_fs_req_cleanup(
&req
);
/* Fails
with
ENOENT
if
source does not exist. */
unlink
(src);
unlink
(dst);
r = uv_fs_copyfile(NULL,
&req
, src, dst, 0, NULL);
ASSERT(req.result == UV_ENOENT);
ASSERT(r == UV_ENOENT);
uv_fs_req_cleanup(
&req
);
/* The destination should not exist. */
r = uv_fs_stat(NULL,
&req
, dst, NULL);
ASSERT(r != 0);
uv_fs_req_cleanup(
&req
);
/* Copies file synchronously. Creates new file. */
unlink
(dst);
r = uv_fs_copyfile(NULL,
&req
, fixture, dst, 0, NULL);
ASSERT(r == 0);
handle_result(
&req
);
/* Copies a file of size zero. */
libuv/test/test-fs-event.c view on Meta::CPAN
488489490491492493494495496497498499500501502503504505506507loop = uv_default_loop();
remove(
"watch_dir/file1"
);
remove(
"watch_dir/"
);
create_dir(
"watch_dir"
);
create_file(
"watch_dir/file1"
);
/* Newer version of Windows ship
with
HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\NtfsDisable8dot3NameCreation
not equal to 0. So we verify the files we created are addressable by a 8.3
short name */
has_shortnames = uv_fs_stat(NULL,
&req
,
"watch_~1"
, NULL) != UV_ENOENT;
if
(has_shortnames) {
r = uv_fs_event_init(loop,
&fs_event
);
ASSERT(r == 0);
r = uv_fs_event_start(
&fs_event
, fs_event_cb_dir,
"watch_~1"
, 0);
ASSERT(r == 0);
r = uv_timer_init(loop,
&timer
);
ASSERT(r == 0);
r = uv_timer_start(
&timer
, timer_cb_file, 100, 0);
ASSERT(r == 0);
libuv/test/test-fs.c view on Meta::CPAN
156157158159160161162163164165166167168169170171172173174175176static GUID REPARSE_GUID = {
0x1bf6205f, 0x46ae, 0x4527,
{ 0xb1, 0x0c, 0xc5, 0x09, 0xb7, 0x55, 0x22, 0x80 }};
#endif
static void check_permission(const char* filename, unsigned
int
mode) {
int
r;
uv_fs_t req;
uv_stat_t* s;
r = uv_fs_stat(NULL,
&req
, filename, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
s =
&req
.statbuf;
#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
/*
* On Windows,
chmod
can only modify S_IWUSR (_S_IWRITE) bit,
* so only testing
for
the specified flags.
*/
ASSERT((s->st_mode & 0777) & mode);
libuv/test/test-fs.c view on Meta::CPAN
483484485486487488489490491492493494495496497498499500501502503
ASSERT(req->fs_type == UV_FS_MKDTEMP);
ASSERT(req->result == 0);
ASSERT(req->path);
ASSERT(strlen(req->path) == 15);
ASSERT(memcmp(req->path,
"test_dir_"
, 9) == 0);
ASSERT(memcmp(req->path + 9,
"XXXXXX"
, 6) != 0);
check_permission(req->path, 0700);
/* Check
if
req->path is actually a directory */
r = uv_fs_stat(NULL,
&stat_req
, req->path, NULL);
ASSERT(r == 0);
ASSERT(((uv_stat_t*)stat_req.ptr)->st_mode & S_IFDIR);
uv_fs_req_cleanup(
&stat_req
);
}
static void mkdtemp_cb(uv_fs_t* req) {
ASSERT(req ==
&mkdtemp_req1
);
check_mkdtemp_result(req);
mkdtemp_cb_count++;
libuv/test/test-fs.c view on Meta::CPAN
724725726727728729730731732733734735736737738739740741742743744
MAKE_VALGRIND_HAPPY();
return
0;
}
static void check_utime(const char* path, double atime, double mtime) {
uv_stat_t* s;
uv_fs_t req;
int
r;
r = uv_fs_stat(loop,
&req
, path, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
s =
&req
.statbuf;
ASSERT(s->st_atim.tv_sec + (s->st_atim.tv_nsec / 1000000000.0) == atime);
ASSERT(s->st_mtim.tv_sec + (s->st_mtim.tv_nsec / 1000000000.0) == mtime);
uv_fs_req_cleanup(
&req
);
}
libuv/test/test-fs.c view on Meta::CPAN
9991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030ASSERT(r == 2);
ASSERT(scandir_req.result == 2);
ASSERT(scandir_req.ptr);
while
(UV_EOF != uv_fs_scandir_next(
&scandir_req
,
&dent
)) {
ASSERT(strcmp(dent.name,
"file1"
) == 0 || strcmp(dent.name,
"file2"
) == 0);
assert_is_file_type(dent);
}
uv_fs_req_cleanup(
&scandir_req
);
ASSERT(!scandir_req.ptr);
r = uv_fs_stat(loop,
&stat_req
,
"test_dir"
, stat_cb);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);
r = uv_fs_stat(loop,
&stat_req
,
"test_dir/"
, stat_cb);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);
r = uv_fs_lstat(loop,
&stat_req
,
"test_dir"
, stat_cb);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);
r = uv_fs_lstat(loop,
&stat_req
,
"test_dir/"
, stat_cb);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(stat_cb_count == 4);
r = uv_fs_unlink(loop,
&unlink_req
,
"test_dir/file1"
, unlink_cb);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(unlink_cb_count == 1);
libuv/test/test-fs.c view on Meta::CPAN
109310941095109610971098109911001101110211031104110511061107110811091110111111121113
ASSERT(sendfile_cb_count == 1);
r = uv_fs_close(NULL,
&close_req
, open_req1.result, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(
&close_req
);
r = uv_fs_close(NULL,
&close_req
, open_req2.result, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(
&close_req
);
stat
(
"test_file"
,
&s1
);
stat
(
"test_file2"
,
&s2
);
ASSERT(65546 == s2.st_size && s1.st_size == s2.st_size);
/* Cleanup. */
unlink
(
"test_file"
);
unlink
(
"test_file2"
);
MAKE_VALGRIND_HAPPY();
return
0;
}
libuv/test/test-fs.c view on Meta::CPAN
1164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191
ASSERT(req.result >= 0);
file = req.result;
uv_fs_req_cleanup(
&req
);
iov = uv_buf_init(test_buf, sizeof(test_buf));
r = uv_fs_write(NULL,
&req
, file,
&iov
, 1, -1, NULL);
ASSERT(r == sizeof(test_buf));
ASSERT(req.result == sizeof(test_buf));
uv_fs_req_cleanup(
&req
);
r = uv_fs_fstat(NULL,
&req
, file, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
s = req.ptr;
ASSERT(s->st_size == sizeof(test_buf));
#ifndef _WIN32
r = fstat(file,
&t
);
ASSERT(r == 0);
ASSERT(s->st_dev == (uint64_t) t.st_dev);
ASSERT(s->st_mode == (uint64_t) t.st_mode);
ASSERT(s->st_nlink == (uint64_t) t.st_nlink);
ASSERT(s->st_uid == (uint64_t) t.st_uid);
ASSERT(s->st_gid == (uint64_t) t.st_gid);
ASSERT(s->st_rdev == (uint64_t) t.st_rdev);
ASSERT(s->st_ino == (uint64_t) t.st_ino);
ASSERT(s->st_size == (uint64_t) t.st_size);
libuv/test/test-fs.c view on Meta::CPAN
12551256125712581259126012611262126312641265126612671268126912701271127212731274
*/
ASSERT(s->st_birthtim.tv_sec == 0 ||
s->st_birthtim.tv_sec == t.st_ctim.tv_sec);
ASSERT(s->st_birthtim.tv_nsec == 0 ||
s->st_birthtim.tv_nsec == t.st_ctim.tv_nsec);
#endif
uv_fs_req_cleanup(
&req
);
/* Now
do
the uv_fs_fstat call asynchronously */
r = uv_fs_fstat(loop,
&req
, file, fstat_cb);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(fstat_cb_count == 1);
r = uv_fs_close(NULL,
&req
, file, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
uv_fs_req_cleanup(
&req
);
libuv/test/test-fs.c view on Meta::CPAN
20292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054
if
(type == UV_FS_SYMLINK_DIR && (r == UV_ENOTSUP || r == UV_EPERM)) {
uv_fs_req_cleanup(
&req
);
RETURN_SKIP(
"this version of Windows doesn't support unprivileged "
"creation of directory symlinks"
);
}
fprintf(stderr,
"r == %i\n"
, r);
ASSERT(r == 0);
ASSERT(req.result == 0);
uv_fs_req_cleanup(
&req
);
r = uv_fs_stat(NULL,
&req
,
"test_dir_symlink"
, NULL);
ASSERT(r == 0);
ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFDIR);
uv_fs_req_cleanup(
&req
);
r = uv_fs_lstat(NULL,
&req
,
"test_dir_symlink"
, NULL);
ASSERT(r == 0);
#if defined(__MSYS__)
RETURN_SKIP(
"symlink reading is not supported on MSYS2"
);
#endif
ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFLNK);
#ifdef _WIN32
ASSERT(((uv_stat_t*)req.ptr)->st_size == strlen(test_dir + 4));
#else
ASSERT(((uv_stat_t*)req.ptr)->st_size == strlen(test_dir));
#endif
libuv/test/test-fs.c view on Meta::CPAN
2194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233
r = uv_fs_readlink(NULL,
&req
,
"test_dir/test_file"
, NULL);
ASSERT(r == UV_EINVAL && GetLastError() == ERROR_SYMLINK_NOT_SUPPORTED);
uv_fs_req_cleanup(
&req
);
/*
Placeholder tests
for
exercising the behavior fixed in issue
#995.
To run, update the path
with
the IP address of a Mac
with
the hard drive
shared via SMB as
"Macintosh HD"
.
r = uv_fs_stat(NULL,
&req
,
"\\\\<mac_ip>\\Macintosh HD\\.DS_Store"
, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(
&req
);
r = uv_fs_lstat(NULL,
&req
,
"\\\\<mac_ip>\\Macintosh HD\\.DS_Store"
, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(
&req
);
*/
/*
uv_fs_stat and uv_fs_lstat can only work on non-
symlink
reparse
points
when
a minifilter driver is registered which intercepts
associated filesystem requests. Installing a driver is beyond
the scope of this test.
r = uv_fs_stat(NULL,
&req
,
"test_dir/test_file"
, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(
&req
);
r = uv_fs_lstat(NULL,
&req
,
"test_dir/test_file"
, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(
&req
);
*/
r = uv_fs_scandir(NULL,
&scandir_req
,
"test_dir"
, 0, NULL);
ASSERT(r == 1);
ASSERT(scandir_req.result == 1);
ASSERT(scandir_req.ptr);
while
(UV_EOF != uv_fs_scandir_next(
&scandir_req
,
&dent
)) {
ASSERT(strcmp(dent.name,
"test_file"
) == 0);
libuv/test/test-fs.c view on Meta::CPAN
22762277227822792280228122822283228422852286228722882289229022912292229322942295
*/
#ifdef _WIN32
mtime += 0.444; /* 1982-09-10 11:22:33.444 */
#endif
r = uv_fs_utime(NULL,
&req
, path, atime, mtime, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
uv_fs_req_cleanup(
&req
);
r = uv_fs_stat(NULL,
&req
, path, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
check_utime(path, atime, mtime);
uv_fs_req_cleanup(
&req
);
atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */
checkme.path = path;
checkme.atime = atime;
checkme.mtime = mtime;
libuv/test/test-fs.c view on Meta::CPAN
2306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345
MAKE_VALGRIND_HAPPY();
return
0;
}
#ifdef _WIN32
TEST_IMPL(fs_stat_root) {
int
r;
r = uv_fs_stat(NULL,
&stat_req
,
"\\"
, NULL);
ASSERT(r == 0);
r = uv_fs_stat(NULL,
&stat_req
,
"..\\..\\..\\..\\..\\..\\.."
, NULL);
ASSERT(r == 0);
r = uv_fs_stat(NULL,
&stat_req
,
".."
, NULL);
ASSERT(r == 0);
r = uv_fs_stat(NULL,
&stat_req
,
"..\\"
, NULL);
ASSERT(r == 0);
/* stats the current directory on c: */
r = uv_fs_stat(NULL,
&stat_req
,
"c:"
, NULL);
ASSERT(r == 0);
r = uv_fs_stat(NULL,
&stat_req
,
"c:\\"
, NULL);
ASSERT(r == 0);
r = uv_fs_stat(NULL,
&stat_req
,
"\\\\?\\C:\\"
, NULL);
ASSERT(r == 0);
MAKE_VALGRIND_HAPPY();
return
0;
}
#endif
TEST_IMPL(fs_futime) {
utime_check_t checkme;
libuv/test/test-fs.c view on Meta::CPAN
238223832384238523862387238823892390239123922393239423952396239723982399240024012402
r = uv_fs_futime(NULL,
&req
, file, atime, mtime, NULL);
#if defined(__CYGWIN__) || defined(__MSYS__)
ASSERT(r == UV_ENOSYS);
RETURN_SKIP(
"futime not supported on Cygwin"
);
#else
ASSERT(r == 0);
ASSERT(req.result == 0);
#endif
uv_fs_req_cleanup(
&req
);
r = uv_fs_stat(NULL,
&req
, path, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
check_utime(path, atime, mtime);
uv_fs_req_cleanup(
&req
);
atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */
checkme.atime = atime;
checkme.mtime = mtime;
checkme.path = path;
libuv/test/test-fs.c view on Meta::CPAN
241524162417241824192420242124222423242424252426242724282429243024312432243324342435
return
0;
}
TEST_IMPL(fs_stat_missing_path) {
uv_fs_t req;
int
r;
loop = uv_default_loop();
r = uv_fs_stat(NULL,
&req
,
"non_existent_file"
, NULL);
ASSERT(r == UV_ENOENT);
ASSERT(req.result == UV_ENOENT);
uv_fs_req_cleanup(
&req
);
MAKE_VALGRIND_HAPPY();
return
0;
}
TEST_IMPL(fs_scandir_empty_dir) {
libuv/test/test-fs.c view on Meta::CPAN
300930103011301230133014301530163017301830193020302130223023302430253026302730283029ASSERT((size_t)read_req.result == sizeof(test_buf) * iovcount);
for
(
index
= 0;
index
< iovcount; ++
index
)
ASSERT(strncmp(buffer +
index
* sizeof(test_buf),
test_buf,
sizeof(test_buf)) == 0);
uv_fs_req_cleanup(
&read_req
);
free(buffer);
r = uv_fs_stat(NULL,
&stat_req
,
"test_file"
, NULL);
ASSERT(r == 0);
ASSERT((int64_t)((uv_stat_t*)stat_req.ptr)->st_size ==
offset + (int64_t)write_req.result);
uv_fs_req_cleanup(
&stat_req
);
iov = uv_buf_init(buf, sizeof(buf));
r = uv_fs_read(NULL,
&read_req
,
open_req1.result,
&iov
,
libuv/test/test-fs.c view on Meta::CPAN
349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525r = uv_fs_realpath(NULL, NULL, NULL, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_chown(NULL, NULL, NULL, 0, 0, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_fchown(NULL, NULL, 0, 0, 0, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_stat(NULL, NULL, NULL, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_lstat(NULL, NULL, NULL, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_fstat(NULL, NULL, 0, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_rename(NULL, NULL, NULL, NULL, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_fsync(NULL, NULL, 0, NULL);
ASSERT(r == UV_EINVAL);
r = uv_fs_fdatasync(NULL, NULL, 0, NULL);
ASSERT(r == UV_EINVAL);
libuv/test/test-getters-setters.c view on Meta::CPAN
596061626364656667686970717273747576777879ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)
pipe
) == 0);
pipe
->write_queue_size++;
ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)
pipe
) == 1);
pipe
->write_queue_size--;
uv_close((uv_handle_t*)
pipe
, NULL);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
fs = malloc(uv_req_size(UV_FS));
uv_fs_stat(loop, fs,
"."
, NULL);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(uv_fs_get_type(fs) == UV_FS_STAT);
ASSERT(uv_fs_get_result(fs) == 0);
ASSERT(uv_fs_get_ptr(fs) == uv_fs_get_statbuf(fs));
ASSERT(uv_fs_get_statbuf(fs)->st_mode & S_IFDIR);
ASSERT(strcmp(uv_fs_get_path(fs),
"."
) == 0);
uv_fs_req_cleanup(fs);
libuv/test/test-pipe-set-fchmod.c view on Meta::CPAN
414243444546474849505152535455565758596061626364656667686970717273747576777879
/* No easy way to test
if
this works, we will only make sure that the call is
* successful. */
r = uv_pipe_chmod(
&pipe_handle
, UV_READABLE);
if
(r == UV_EPERM) {
MAKE_VALGRIND_HAPPY();
RETURN_SKIP(
"Insufficient privileges to alter pipe fmode"
);
}
ASSERT(r == 0);
#ifndef _WIN32
stat
(TEST_PIPENAME,
&stat_buf
);
ASSERT(stat_buf.st_mode & S_IRUSR);
ASSERT(stat_buf.st_mode & S_IRGRP);
ASSERT(stat_buf.st_mode & S_IROTH);
#endif
r = uv_pipe_chmod(
&pipe_handle
, UV_WRITABLE);
ASSERT(r == 0);
#ifndef _WIN32
stat
(TEST_PIPENAME,
&stat_buf
);
ASSERT(stat_buf.st_mode & S_IWUSR);
ASSERT(stat_buf.st_mode & S_IWGRP);
ASSERT(stat_buf.st_mode & S_IWOTH);
#endif
r = uv_pipe_chmod(
&pipe_handle
, UV_WRITABLE | UV_READABLE);
ASSERT(r == 0);
#ifndef _WIN32
stat
(TEST_PIPENAME,
&stat_buf
);
ASSERT(stat_buf.st_mode & S_IRUSR);
ASSERT(stat_buf.st_mode & S_IRGRP);
ASSERT(stat_buf.st_mode & S_IROTH);
ASSERT(stat_buf.st_mode & S_IWUSR);
ASSERT(stat_buf.st_mode & S_IWGRP);
ASSERT(stat_buf.st_mode & S_IWOTH);
#endif
r = uv_pipe_chmod(NULL, UV_WRITABLE | UV_READABLE);
ASSERT(r == UV_EBADF);
libuv/test/test-thread.c view on Meta::CPAN
8687888990919293949596979899100101102103104105106
uv_freeaddrinfo(res);
if
(--req->counter)
getaddrinfo_do(req);
}
static void fs_do(struct fs_req* req) {
int
r;
r = uv_fs_stat(req->loop,
&req
->handle,
"."
, fs_cb);
ASSERT(r == 0);
}
static void fs_cb(uv_fs_t* handle) {
struct fs_req* req = container_of(handle, struct fs_req, handle);
uv_fs_req_cleanup(handle);
if
(--req->counter)
libuv/test/test-threadpool-cancel.c view on Meta::CPAN
249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284iov = uv_buf_init(NULL, 0);
/* Needs to match ARRAY_SIZE(fs_reqs). */
n = 0;
ASSERT(0 == uv_fs_chmod(loop, reqs + n++,
"/"
, 0, fs_cb));
ASSERT(0 == uv_fs_chown(loop, reqs + n++,
"/"
, 0, 0, fs_cb));
ASSERT(0 == uv_fs_close(loop, reqs + n++, 0, fs_cb));
ASSERT(0 == uv_fs_fchmod(loop, reqs + n++, 0, 0, fs_cb));
ASSERT(0 == uv_fs_fchown(loop, reqs + n++, 0, 0, 0, fs_cb));
ASSERT(0 == uv_fs_fdatasync(loop, reqs + n++, 0, fs_cb));
ASSERT(0 == uv_fs_fstat(loop, reqs + n++, 0, fs_cb));
ASSERT(0 == uv_fs_fsync(loop, reqs + n++, 0, fs_cb));
ASSERT(0 == uv_fs_ftruncate(loop, reqs + n++, 0, 0, fs_cb));
ASSERT(0 == uv_fs_futime(loop, reqs + n++, 0, 0, 0, fs_cb));
ASSERT(0 == uv_fs_link(loop, reqs + n++,
"/"
,
"/"
, fs_cb));
ASSERT(0 == uv_fs_lstat(loop, reqs + n++,
"/"
, fs_cb));
ASSERT(0 == uv_fs_mkdir(loop, reqs + n++,
"/"
, 0, fs_cb));
ASSERT(0 == uv_fs_open(loop, reqs + n++,
"/"
, 0, 0, fs_cb));
ASSERT(0 == uv_fs_read(loop, reqs + n++, 0,
&iov
, 1, 0, fs_cb));
ASSERT(0 == uv_fs_scandir(loop, reqs + n++,
"/"
, 0, fs_cb));
ASSERT(0 == uv_fs_readlink(loop, reqs + n++,
"/"
, fs_cb));
ASSERT(0 == uv_fs_realpath(loop, reqs + n++,
"/"
, fs_cb));
ASSERT(0 == uv_fs_rename(loop, reqs + n++,
"/"
,
"/"
, fs_cb));
ASSERT(0 == uv_fs_mkdir(loop, reqs + n++,
"/"
, 0, fs_cb));
ASSERT(0 == uv_fs_sendfile(loop, reqs + n++, 0, 0, 0, 0, fs_cb));
ASSERT(0 == uv_fs_stat(loop, reqs + n++,
"/"
, fs_cb));
ASSERT(0 == uv_fs_symlink(loop, reqs + n++,
"/"
,
"/"
, 0, fs_cb));
ASSERT(0 == uv_fs_unlink(loop, reqs + n++,
"/"
, fs_cb));
ASSERT(0 == uv_fs_utime(loop, reqs + n++,
"/"
, 0, 0, fs_cb));
ASSERT(0 == uv_fs_write(loop, reqs + n++, 0,
&iov
, 1, 0, fs_cb));
ASSERT(n == ARRAY_SIZE(reqs));
ASSERT(0 == uv_timer_init(loop,
&ci
.timer_handle));
ASSERT(0 == uv_timer_start(
&ci
.timer_handle, timer_cb, 10, 0));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT(n == fs_cb_called);