cory/tildefriends
5
6
Fork 2
Code Issues 39 Pull Requests Actions Releases 33 Wiki Activity

libuv 1.47.0.

Browse Source 
git-svn-id: https://www.unprompted.com/svn/projects/tildefriends/trunk@4615 ed5197a5-7fde-0310-b194-c3ffbd925b24
This commit is contained in:
Cory McWilliams
2023-11-07 17:30:39 +00:00
parent 889773c38d
commit ee9cb63327
226 changed files with 6648 additions and 6444 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
deps/libuv/test/benchmark-async-pummel.c vendored
View File

@ -71,21 +71,21 @@ static int test_async_pummel(int nthreads) {
tids = calloc(nthreads, sizeof(tids[0]));
ASSERT_NOT_NULL(tids);
ASSERT(0 == uv_async_init(uv_default_loop(), &handle, async_cb));
ASSERT_OK(uv_async_init(uv_default_loop(), &handle, async_cb));
ACCESS_ONCE(const char*, handle.data) = running;
for (i = 0; i < nthreads; i++)
ASSERT(0 == uv_thread_create(tids + i, pummel, &handle));
ASSERT_OK(uv_thread_create(tids + i, pummel, &handle));
time = uv_hrtime();
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
time = uv_hrtime() - time;
done = 1;
for (i = 0; i < nthreads; i++)
ASSERT(0 == uv_thread_join(tids + i));
ASSERT_OK(uv_thread_join(tids + i));
printf("async_pummel_%d: %s callbacks in %.2f seconds (%s/sec)\n",
nthreads,

32
deps/libuv/test/benchmark-async.c vendored
View File

@ -43,7 +43,7 @@ struct ctx {
static void worker_async_cb(uv_async_t* handle) {
struct ctx* ctx = container_of(handle, struct ctx, worker_async);
ASSERT(0 == uv_async_send(&ctx->main_async));
ASSERT_OK(uv_async_send(&ctx->main_async));
ctx->worker_sent++;
ctx->worker_seen++;
@ -55,7 +55,7 @@ static void worker_async_cb(uv_async_t* handle) {
static void main_async_cb(uv_async_t* handle) {
struct ctx* ctx = container_of(handle, struct ctx, main_async);
ASSERT(0 == uv_async_send(&ctx->worker_async));
ASSERT_OK(uv_async_send(&ctx->worker_async));
ctx->main_sent++;
ctx->main_seen++;
@ -66,8 +66,8 @@ static void main_async_cb(uv_async_t* handle) {
static void worker(void* arg) {
struct ctx* ctx = arg;
ASSERT(0 == uv_async_send(&ctx->main_async));
ASSERT(0 == uv_run(&ctx->loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_async_send(&ctx->main_async));
ASSERT_OK(uv_run(&ctx->loop, UV_RUN_DEFAULT));
uv_loop_close(&ctx->loop);
}
@ -85,29 +85,29 @@ static int test_async(int nthreads) {
for (i = 0; i < nthreads; i++) {
ctx = threads + i;
ctx->nthreads = nthreads;
ASSERT(0 == uv_loop_init(&ctx->loop));
ASSERT(0 == uv_async_init(&ctx->loop, &ctx->worker_async, worker_async_cb));
ASSERT(0 == uv_async_init(uv_default_loop(),
&ctx->main_async,
main_async_cb));
ASSERT(0 == uv_thread_create(&ctx->thread, worker, ctx));
ASSERT_OK(uv_loop_init(&ctx->loop));
ASSERT_OK(uv_async_init(&ctx->loop, &ctx->worker_async, worker_async_cb));
ASSERT_OK(uv_async_init(uv_default_loop(),
&ctx->main_async,
main_async_cb));
ASSERT_OK(uv_thread_create(&ctx->thread, worker, ctx));
}
time = uv_hrtime();
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
for (i = 0; i < nthreads; i++)
ASSERT(0 == uv_thread_join(&threads[i].thread));
ASSERT_OK(uv_thread_join(&threads[i].thread));
time = uv_hrtime() - time;
for (i = 0; i < nthreads; i++) {
ctx = threads + i;
ASSERT(ctx->worker_sent == NUM_PINGS);
ASSERT(ctx->worker_seen == NUM_PINGS);
ASSERT(ctx->main_sent == (unsigned int) NUM_PINGS);
ASSERT(ctx->main_seen == (unsigned int) NUM_PINGS);
ASSERT_EQ(ctx->worker_sent, NUM_PINGS);
ASSERT_EQ(ctx->worker_seen, NUM_PINGS);
ASSERT_EQ(ctx->main_sent, (unsigned int) NUM_PINGS);
ASSERT_EQ(ctx->main_seen, (unsigned int) NUM_PINGS);
}
printf("async%d: %.2f sec (%s/sec)\n",

8
deps/libuv/test/benchmark-getaddrinfo.c vendored
View File

@ -43,7 +43,7 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle);
static void getaddrinfo_cb(uv_getaddrinfo_t* handle, int status,
struct addrinfo* res) {
ASSERT(status == 0);
ASSERT_OK(status);
calls_completed++;
if (calls_initiated < TOTAL_CALLS) {
getaddrinfo_initiate(handle);
@ -59,7 +59,7 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle) {
calls_initiated++;
r = uv_getaddrinfo(loop, handle, &getaddrinfo_cb, name, NULL, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -80,8 +80,8 @@ BENCHMARK_IMPL(getaddrinfo) {
uv_update_time(loop);
end_time = uv_now(loop);
ASSERT(calls_initiated == TOTAL_CALLS);
ASSERT(calls_completed == TOTAL_CALLS);
ASSERT_EQ(calls_initiated, TOTAL_CALLS);
ASSERT_EQ(calls_completed, TOTAL_CALLS);
fprintf(stderr, "getaddrinfo: %.0f req/s\n",
(double) calls_completed / (double) (end_time - start_time) * 1000.0);

2
deps/libuv/test/benchmark-loop-count.c vendored
View File

@ -74,7 +74,7 @@ BENCHMARK_IMPL(loop_count) {
uv_run(loop, UV_RUN_DEFAULT);
ns = uv_hrtime() - ns;
ASSERT(ticks == NUM_TICKS);
ASSERT_UINT64_EQ(ticks, NUM_TICKS);
fprintf(stderr, "loop_count: %d ticks in %.2fs (%.0f/s)\n",
NUM_TICKS,

12
deps/libuv/test/benchmark-million-async.c vendored
View File

@ -60,7 +60,7 @@ static void timer_cb(uv_timer_t* handle) {
unsigned i;
done = 1;
ASSERT(0 == uv_thread_join(&thread_id));
ASSERT_OK(uv_thread_join(&thread_id));
for (i = 0; i < ARRAY_SIZE(container->async_handles); i++) {
uv_async_t* handle = container->async_handles + i;
@ -93,14 +93,14 @@ BENCHMARK_IMPL(million_async) {
for (i = 0; i < ARRAY_SIZE(container->async_handles); i++) {
handle = container->async_handles + i;
ASSERT(0 == uv_async_init(loop, handle, async_cb));
ASSERT_OK(uv_async_init(loop, handle, async_cb));
handle->data = NULL;
}
ASSERT(0 == uv_timer_init(loop, &timer_handle));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, timeout, 0));
ASSERT(0 == uv_thread_create(&thread_id, thread_cb, NULL));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_timer_init(loop, &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, timeout, 0));
ASSERT_OK(uv_thread_create(&thread_id, thread_cb, NULL));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
printf("%s async events in %.1f seconds (%s/s, %s unique handles seen)\n",
fmt(&fmtbuf[0], container->async_events),
timeout / 1000.,

12
deps/libuv/test/benchmark-million-timers.c vendored
View File

@ -57,22 +57,22 @@ BENCHMARK_IMPL(million_timers) {
before_all = uv_hrtime();
for (i = 0; i < NUM_TIMERS; i++) {
if (i % 1000 == 0) timeout++;
ASSERT(0 == uv_timer_init(loop, timers + i));
ASSERT(0 == uv_timer_start(timers + i, timer_cb, timeout, 0));
ASSERT_OK(uv_timer_init(loop, timers + i));
ASSERT_OK(uv_timer_start(timers + i, timer_cb, timeout, 0));
}
before_run = uv_hrtime();
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
after_run = uv_hrtime();
for (i = 0; i < NUM_TIMERS; i++)
uv_close((uv_handle_t*) (timers + i), close_cb);
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
after_all = uv_hrtime();
ASSERT(timer_cb_called == NUM_TIMERS);
ASSERT(close_cb_called == NUM_TIMERS);
ASSERT_EQ(timer_cb_called, NUM_TIMERS);
ASSERT_EQ(close_cb_called, NUM_TIMERS);
free(timers);
fprintf(stderr, "%.2f seconds total\n", (after_all - before_all) / 1e9);

114
deps/libuv/test/benchmark-multi-accept.c vendored
View File

@ -117,19 +117,19 @@ static void ipc_connection_cb(uv_stream_t* ipc_pipe, int status) {
ASSERT_NOT_NULL(pc);
if (ipc_pipe->type == UV_TCP)
ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) &pc->peer_handle));
ASSERT_OK(uv_tcp_init(loop, (uv_tcp_t*) &pc->peer_handle));
else if (ipc_pipe->type == UV_NAMED_PIPE)
ASSERT(0 == uv_pipe_init(loop, (uv_pipe_t*) &pc->peer_handle, 1));
ASSERT_OK(uv_pipe_init(loop, (uv_pipe_t*) &pc->peer_handle, 1));
else
ASSERT(0);
ASSERT(0 == uv_accept(ipc_pipe, (uv_stream_t*) &pc->peer_handle));
ASSERT(0 == uv_write2(&pc->write_req,
(uv_stream_t*) &pc->peer_handle,
&buf,
1,
(uv_stream_t*) &sc->server_handle,
ipc_write_cb));
ASSERT_OK(uv_accept(ipc_pipe, (uv_stream_t*) &pc->peer_handle));
ASSERT_OK(uv_write2(&pc->write_req,
(uv_stream_t*) &pc->peer_handle,
&buf,
1,
(uv_stream_t*) &sc->server_handle,
ipc_write_cb));
if (--sc->num_connects == 0)
uv_close((uv_handle_t*) ipc_pipe, NULL);
@ -153,10 +153,10 @@ static void ipc_close_cb(uv_handle_t* handle) {
static void ipc_connect_cb(uv_connect_t* req, int status) {
struct ipc_client_ctx* ctx;
ctx = container_of(req, struct ipc_client_ctx, connect_req);
ASSERT(0 == status);
ASSERT(0 == uv_read_start((uv_stream_t*) &ctx->ipc_pipe,
ipc_alloc_cb,
ipc_read_cb));
ASSERT_OK(status);
ASSERT_OK(uv_read_start((uv_stream_t*) &ctx->ipc_pipe,
ipc_alloc_cb,
ipc_read_cb));
}
@ -182,16 +182,16 @@ static void ipc_read_cb(uv_stream_t* handle,
ctx = container_of(ipc_pipe, struct ipc_client_ctx, ipc_pipe);
loop = ipc_pipe->loop;
ASSERT(1 == uv_pipe_pending_count(ipc_pipe));
ASSERT_EQ(1, uv_pipe_pending_count(ipc_pipe));
type = uv_pipe_pending_type(ipc_pipe);
if (type == UV_TCP)
ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) ctx->server_handle));
ASSERT_OK(uv_tcp_init(loop, (uv_tcp_t*) ctx->server_handle));
else if (type == UV_NAMED_PIPE)
ASSERT(0 == uv_pipe_init(loop, (uv_pipe_t*) ctx->server_handle, 0));
ASSERT_OK(uv_pipe_init(loop, (uv_pipe_t*) ctx->server_handle, 0));
else
ASSERT(0);
ASSERT(0 == uv_accept(handle, ctx->server_handle));
ASSERT_OK(uv_accept(handle, ctx->server_handle));
uv_close((uv_handle_t*) &ctx->ipc_pipe, NULL);
}
@ -211,10 +211,10 @@ static void send_listen_handles(uv_handle_type type,
ctx.num_connects = num_servers;
if (type == UV_TCP) {
ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle));
ASSERT(0 == uv_tcp_bind((uv_tcp_t*) &ctx.server_handle,
(const struct sockaddr*) &listen_addr,
0));
ASSERT_OK(uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle));
ASSERT_OK(uv_tcp_bind((uv_tcp_t*) &ctx.server_handle,
(const struct sockaddr*) &listen_addr,
0));
}
else
ASSERT(0);
@ -223,16 +223,16 @@ static void send_listen_handles(uv_handle_type type,
* If we accept a connection then the connected pipe must be initialized
* with ipc=1.
*/
ASSERT(0 == uv_pipe_init(loop, &ctx.ipc_pipe, 0));
ASSERT(0 == uv_pipe_bind(&ctx.ipc_pipe, IPC_PIPE_NAME));
ASSERT(0 == uv_listen((uv_stream_t*) &ctx.ipc_pipe, 128, ipc_connection_cb));
ASSERT_OK(uv_pipe_init(loop, &ctx.ipc_pipe, 0));
ASSERT_OK(uv_pipe_bind(&ctx.ipc_pipe, IPC_PIPE_NAME));
ASSERT_OK(uv_listen((uv_stream_t*) &ctx.ipc_pipe, 128, ipc_connection_cb));
for (i = 0; i < num_servers; i++)
uv_sem_post(&servers[i].semaphore);
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
uv_close((uv_handle_t*) &ctx.server_handle, NULL);
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
for (i = 0; i < num_servers; i++)
uv_sem_wait(&servers[i].semaphore);
@ -245,12 +245,12 @@ static void get_listen_handle(uv_loop_t* loop, uv_stream_t* server_handle) {
ctx.server_handle = server_handle;
ctx.server_handle->data = "server handle";
ASSERT(0 == uv_pipe_init(loop, &ctx.ipc_pipe, 1));
ASSERT_OK(uv_pipe_init(loop, &ctx.ipc_pipe, 1));
uv_pipe_connect(&ctx.connect_req,
&ctx.ipc_pipe,
IPC_PIPE_NAME,
ipc_connect_cb);
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
}
@ -259,9 +259,9 @@ static void server_cb(void *arg) {
uv_loop_t loop;
ctx = arg;
ASSERT(0 == uv_loop_init(&loop));
ASSERT_OK(uv_loop_init(&loop));
ASSERT(0 == uv_async_init(&loop, &ctx->async_handle, sv_async_cb));
ASSERT_OK(uv_async_init(&loop, &ctx->async_handle, sv_async_cb));
uv_unref((uv_handle_t*) &ctx->async_handle);
/* Wait until the main thread is ready. */
@ -270,10 +270,10 @@ static void server_cb(void *arg) {
uv_sem_post(&ctx->semaphore);
/* Now start the actual benchmark. */
ASSERT(0 == uv_listen((uv_stream_t*) &ctx->server_handle,
128,
sv_connection_cb));
ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_listen((uv_stream_t*) &ctx->server_handle,
128,
sv_connection_cb));
ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
uv_loop_close(&loop);
}
@ -292,20 +292,20 @@ static void sv_connection_cb(uv_stream_t* server_handle, int status) {
struct server_ctx* ctx;
ctx = container_of(server_handle, struct server_ctx, server_handle);
ASSERT(status == 0);
ASSERT_OK(status);
storage = malloc(sizeof(*storage));
ASSERT_NOT_NULL(storage);
if (server_handle->type == UV_TCP)
ASSERT(0 == uv_tcp_init(server_handle->loop, (uv_tcp_t*) storage));
ASSERT_OK(uv_tcp_init(server_handle->loop, (uv_tcp_t*) storage));
else if (server_handle->type == UV_NAMED_PIPE)
ASSERT(0 == uv_pipe_init(server_handle->loop, (uv_pipe_t*) storage, 0));
ASSERT_OK(uv_pipe_init(server_handle->loop, (uv_pipe_t*) storage, 0));
else
ASSERT(0);
ASSERT(0 == uv_accept(server_handle, (uv_stream_t*) storage));
ASSERT(0 == uv_read_start((uv_stream_t*) storage, sv_alloc_cb, sv_read_cb));
ASSERT_OK(uv_accept(server_handle, (uv_stream_t*) storage));
ASSERT_OK(uv_read_start((uv_stream_t*) storage, sv_alloc_cb, sv_read_cb));
ctx->num_connects++;
}
@ -322,7 +322,7 @@ static void sv_alloc_cb(uv_handle_t* handle,
static void sv_read_cb(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
ASSERT(nread == UV_EOF);
ASSERT_EQ(nread, UV_EOF);
uv_close((uv_handle_t*) handle, (uv_close_cb) free);
}
@ -330,7 +330,7 @@ static void sv_read_cb(uv_stream_t* handle,
static void cl_connect_cb(uv_connect_t* req, int status) {
struct client_ctx* ctx = container_of(req, struct client_ctx, connect_req);
uv_idle_start(&ctx->idle_handle, cl_idle_cb);
ASSERT(0 == status);
ASSERT_OK(status);
}
@ -351,11 +351,11 @@ static void cl_close_cb(uv_handle_t* handle) {
return;
}
ASSERT(0 == uv_tcp_init(handle->loop, (uv_tcp_t*) &ctx->client_handle));
ASSERT(0 == uv_tcp_connect(&ctx->connect_req,
(uv_tcp_t*) &ctx->client_handle,
(const struct sockaddr*) &listen_addr,
cl_connect_cb));
ASSERT_OK(uv_tcp_init(handle->loop, (uv_tcp_t*) &ctx->client_handle));
ASSERT_OK(uv_tcp_connect(&ctx->connect_req,
(uv_tcp_t*) &ctx->client_handle,
(const struct sockaddr*) &listen_addr,
cl_connect_cb));
}
@ -367,7 +367,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
unsigned int i;
double time;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &listen_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &listen_addr));
loop = uv_default_loop();
servers = calloc(num_servers, sizeof(servers[0]));
@ -381,8 +381,8 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
*/
for (i = 0; i < num_servers; i++) {
struct server_ctx* ctx = servers + i;
ASSERT(0 == uv_sem_init(&ctx->semaphore, 0));
ASSERT(0 == uv_thread_create(&ctx->thread_id, server_cb, ctx));
ASSERT_OK(uv_sem_init(&ctx->semaphore, 0));
ASSERT_OK(uv_thread_create(&ctx->thread_id, server_cb, ctx));
}
send_listen_handles(UV_TCP, num_servers, servers);
@ -392,17 +392,17 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
ctx->num_connects = NUM_CONNECTS / num_clients;
handle = (uv_tcp_t*) &ctx->client_handle;
handle->data = "client handle";
ASSERT(0 == uv_tcp_init(loop, handle));
ASSERT(0 == uv_tcp_connect(&ctx->connect_req,
handle,
(const struct sockaddr*) &listen_addr,
cl_connect_cb));
ASSERT(0 == uv_idle_init(loop, &ctx->idle_handle));
ASSERT_OK(uv_tcp_init(loop, handle));
ASSERT_OK(uv_tcp_connect(&ctx->connect_req,
handle,
(const struct sockaddr*) &listen_addr,
cl_connect_cb));
ASSERT_OK(uv_idle_init(loop, &ctx->idle_handle));
}
{
uint64_t t = uv_hrtime();
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
t = uv_hrtime() - t;
time = t / 1e9;
}
@ -410,7 +410,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
for (i = 0; i < num_servers; i++) {
struct server_ctx* ctx = servers + i;
uv_async_send(&ctx->async_handle);
ASSERT(0 == uv_thread_join(&ctx->thread_id));
ASSERT_OK(uv_thread_join(&ctx->thread_id));
uv_sem_destroy(&ctx->semaphore);
}

26
deps/libuv/test/benchmark-ping-pongs.c vendored
View File

@ -90,7 +90,7 @@ static void pinger_close_cb(uv_handle_t* handle) {
static void pinger_write_cb(uv_write_t* req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
free(req);
}
@ -110,14 +110,14 @@ static void pinger_write_ping(pinger_t* pinger) {
static void pinger_shutdown_cb(uv_shutdown_t* req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
pinger_shutdown_cb_called++;
/*
* The close callback has not been triggered yet. We must wait for EOF
* until we close the connection.
*/
ASSERT(completed_pingers == 0);
ASSERT_OK(completed_pingers);
}
@ -130,13 +130,13 @@ static void pinger_read_cb(uv_stream_t* tcp,
pinger = (pinger_t*)tcp->data;
if (nread < 0) {
ASSERT(nread == UV_EOF);
ASSERT_EQ(nread, UV_EOF);
if (buf->base) {
buf_free(buf);
}
ASSERT(pinger_shutdown_cb_called == 1);
ASSERT_EQ(1, pinger_shutdown_cb_called);
uv_close((uv_handle_t*)tcp, pinger_close_cb);
return;
@ -144,7 +144,7 @@ static void pinger_read_cb(uv_stream_t* tcp,
/* Now we count the pings */
for (i = 0; i < nread; i++) {
ASSERT(buf->base[i] == PING[pinger->state]);
ASSERT_EQ(buf->base[i], PING[pinger->state]);
pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
if (pinger->state == 0) {
pinger->pongs++;
@ -166,7 +166,7 @@ static void pinger_read_cb(uv_stream_t* tcp,
static void pinger_connect_cb(uv_connect_t* req, int status) {
pinger_t *pinger = (pinger_t*)req->handle->data;
ASSERT(status == 0);
ASSERT_OK(status);
pinger_write_ping(pinger);
@ -182,8 +182,8 @@ static void pinger_new(void) {
pinger_t *pinger;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", 0, &client_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;
@ -194,9 +194,9 @@ static void pinger_new(void) {
pinger->tcp.data = pinger;
ASSERT(0 == uv_tcp_bind(&pinger->tcp,
(const struct sockaddr*) &client_addr,
0));
ASSERT_OK(uv_tcp_bind(&pinger->tcp,
(const struct sockaddr*) &client_addr,
0));
r = uv_tcp_connect(&pinger->connect_req,
&pinger->tcp,
@ -214,7 +214,7 @@ BENCHMARK_IMPL(ping_pongs) {
pinger_new();
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(completed_pingers == 1);
ASSERT_EQ(1, completed_pingers);
MAKE_VALGRIND_HAPPY(loop);
return 0;

12
deps/libuv/test/benchmark-ping-udp.c vendored
View File

@ -95,11 +95,11 @@ static void pinger_read_cb(uv_udp_t* udp,
pinger = (pinger_t*)udp->data;
/* No data here means something went wrong */
ASSERT(nread > 0);
ASSERT_GT(nread, 0);
/* Now we count the pings */
for (i = 0; i < nread; i++) {
ASSERT(buf->base[i] == PING[pinger->state]);
ASSERT_EQ(buf->base[i], PING[pinger->state]);
pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
if (pinger->state == 0) {
pinger->pongs++;
@ -119,15 +119,15 @@ static void udp_pinger_new(void) {
pinger_t* pinger = malloc(sizeof(*pinger));
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &pinger->server_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &pinger->server_addr));
pinger->state = 0;
pinger->pongs = 0;
/* Try to do NUM_PINGS ping-pongs (connection-less). */
r = uv_udp_init(loop, &pinger->udp);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_udp_bind(&pinger->udp, (const struct sockaddr*) &pinger->server_addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
pinger->udp.data = pinger;
@ -148,7 +148,7 @@ static int ping_udp(unsigned pingers) {
udp_pinger_new();
}
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(completed_pingers >= 1);
ASSERT_GE(completed_pingers, 1);
fprintf(stderr, "ping_pongs: %d pingers, ~ %lu roundtrips/s\n",
completed_pingers, completed_pings / (TIME/1000));

12
deps/libuv/test/benchmark-pound.c vendored
View File

@ -115,7 +115,7 @@ static void connect_cb(uv_connect_t* req, int status) {
}
ASSERT_NOT_NULL(req);
ASSERT(status == 0);
ASSERT_OK(status);
conn = (conn_rec*)req->data;
ASSERT_NOT_NULL(conn);
@ -125,13 +125,13 @@ static void connect_cb(uv_connect_t* req, int status) {
#endif
r = uv_read_start(&conn->stream, alloc_cb, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
buf.base = buffer;
buf.len = sizeof(buffer) - 1;
r = uv_write(&conn->write_req, &conn->stream, &buf, 1, after_write);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -200,9 +200,9 @@ static void tcp_make_connect(conn_rec* p) {
tp = (tcp_conn_rec*) p;
r = uv_tcp_init(loop, (uv_tcp_t*)&p->stream);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&tp->conn_req,
(uv_tcp_t*) &p->stream,
@ -227,7 +227,7 @@ static void pipe_make_connect(conn_rec* p) {
int r;
r = uv_pipe_init(loop, (uv_pipe_t*)&p->stream, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_pipe_connect(&((pipe_conn_rec*) p)->conn_req,
(uv_pipe_t*) &p->stream,

50
deps/libuv/test/benchmark-pump.c vendored
View File

@ -159,9 +159,9 @@ static void start_stats_collection(void) {
/* Show-stats timer */
stats_left = STATS_COUNT;
r = uv_timer_init(loop, &timer_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer_handle, show_stats, STATS_INTERVAL, STATS_INTERVAL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_update_time(loop);
start_time = uv_now(loop);
@ -170,7 +170,7 @@ static void start_stats_collection(void) {
static void read_cb(uv_stream_t* stream, ssize_t bytes, const uv_buf_t* buf) {
if (nrecv_total == 0) {
ASSERT(start_time == 0);
ASSERT_OK(start_time);
uv_update_time(loop);
start_time = uv_now(loop);
}
@ -188,7 +188,7 @@ static void read_cb(uv_stream_t* stream, ssize_t bytes, const uv_buf_t* buf) {
static void write_cb(uv_write_t* req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
req_free((uv_req_t*) req);
@ -209,7 +209,7 @@ static void do_write(uv_stream_t* stream) {
req = (uv_write_t*) req_alloc();
r = uv_write(req, stream, &buf, 1, write_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -220,7 +220,7 @@ static void connect_cb(uv_connect_t* req, int status) {
fprintf(stderr, "%s", uv_strerror(status));
fflush(stderr);
}
ASSERT(status == 0);
ASSERT_OK(status);
write_sockets++;
req_free((uv_req_t*) req);
@ -253,19 +253,19 @@ static void maybe_connect_some(void) {
tcp = &tcp_write_handles[max_connect_socket++];
r = uv_tcp_init(loop, tcp);
ASSERT(r == 0);
ASSERT_OK(r);
req = (uv_connect_t*) req_alloc();
r = uv_tcp_connect(req,
tcp,
(const struct sockaddr*) &connect_addr,
connect_cb);
ASSERT(r == 0);
ASSERT_OK(r);
} else {
pipe = &pipe_write_handles[max_connect_socket++];
r = uv_pipe_init(loop, pipe, 0);
ASSERT(r == 0);
ASSERT_OK(r);
req = (uv_connect_t*) req_alloc();
uv_pipe_connect(req, pipe, TEST_PIPENAME, connect_cb);
@ -278,24 +278,24 @@ static void connection_cb(uv_stream_t* s, int status) {
uv_stream_t* stream;
int r;
ASSERT(server == s);
ASSERT(status == 0);
ASSERT_PTR_EQ(server, s);
ASSERT_OK(status);
if (type == TCP) {
stream = (uv_stream_t*)malloc(sizeof(uv_tcp_t));
r = uv_tcp_init(loop, (uv_tcp_t*)stream);
ASSERT(r == 0);
ASSERT_OK(r);
} else {
stream = (uv_stream_t*)malloc(sizeof(uv_pipe_t));
r = uv_pipe_init(loop, (uv_pipe_t*)stream, 0);
ASSERT(r == 0);
ASSERT_OK(r);
}
r = uv_accept(s, stream);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_read_start(stream, buf_alloc, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
read_sockets++;
max_read_sockets++;
@ -379,16 +379,16 @@ HELPER_IMPL(tcp_pump_server) {
type = TCP;
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &listen_addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &listen_addr));
/* Server */
server = (uv_stream_t*)&tcpServer;
r = uv_tcp_init(loop, &tcpServer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_bind(&tcpServer, (const struct sockaddr*) &listen_addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&tcpServer, MAX_WRITE_HANDLES, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
notify_parent_process();
uv_run(loop, UV_RUN_DEFAULT);
@ -406,11 +406,11 @@ HELPER_IMPL(pipe_pump_server) {
/* Server */
server = (uv_stream_t*)&pipeServer;
r = uv_pipe_init(loop, &pipeServer, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&pipeServer, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&pipeServer, MAX_WRITE_HANDLES, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
notify_parent_process();
uv_run(loop, UV_RUN_DEFAULT);
@ -421,13 +421,13 @@ HELPER_IMPL(pipe_pump_server) {
static void tcp_pump(int n) {
ASSERT(n <= MAX_WRITE_HANDLES);
ASSERT_LE(n, MAX_WRITE_HANDLES);
TARGET_CONNECTIONS = n;
type = TCP;
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr));
/* Start making connections */
maybe_connect_some();
@ -439,7 +439,7 @@ static void tcp_pump(int n) {
static void pipe_pump(int n) {
ASSERT(n <= MAX_WRITE_HANDLES);
ASSERT_LE(n, MAX_WRITE_HANDLES);
TARGET_CONNECTIONS = n;
type = PIPE;

10
deps/libuv/test/benchmark-queue-work.c vendored
View File

@ -40,7 +40,7 @@ static void work_cb(uv_work_t* req) {
static void after_work_cb(uv_work_t* req, int status) {
events++;
if (!done)
ASSERT_EQ(0, uv_queue_work(req->loop, req, work_cb, after_work_cb));
ASSERT_OK(uv_queue_work(req->loop, req, work_cb, after_work_cb));
}
static void timer_cb(uv_timer_t* handle) { done = 1; }
@ -55,11 +55,11 @@ BENCHMARK_IMPL(queue_work) {
loop = uv_default_loop();
timeout = 5000;
ASSERT_EQ(0, uv_timer_init(loop, &timer_handle));
ASSERT_EQ(0, uv_timer_start(&timer_handle, timer_cb, timeout, 0));
ASSERT_OK(uv_timer_init(loop, &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, timeout, 0));
ASSERT_EQ(0, uv_queue_work(loop, &work, work_cb, after_work_cb));
ASSERT_EQ(0, uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_queue_work(loop, &work, work_cb, after_work_cb));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
printf("%s async jobs in %.1f seconds (%s/s)\n",
fmt(&fmtbuf[0], events),

22
deps/libuv/test/benchmark-spawn.c vendored
View File

@ -58,7 +58,7 @@ static void maybe_spawn(void) {
static void process_close_cb(uv_handle_t* handle) {
ASSERT(process_open == 1);
ASSERT_EQ(1, process_open);
process_open = 0;
maybe_spawn();
}
@ -67,8 +67,8 @@ static void process_close_cb(uv_handle_t* handle) {
static void exit_cb(uv_process_t* process,
int64_t exit_status,
int term_signal) {
ASSERT(exit_status == 42);
ASSERT(term_signal == 0);
ASSERT_EQ(42, exit_status);
ASSERT_OK(term_signal);
uv_close((uv_handle_t*)process, process_close_cb);
}
@ -82,7 +82,7 @@ static void on_alloc(uv_handle_t* handle,
static void pipe_close_cb(uv_handle_t* pipe) {
ASSERT(pipe_open == 1);
ASSERT_EQ(1, pipe_open);
pipe_open = 0;
maybe_spawn();
}
@ -90,7 +90,7 @@ static void pipe_close_cb(uv_handle_t* pipe) {
static void on_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* buf) {
if (nread > 0) {
ASSERT(pipe_open == 1);
ASSERT_EQ(1, pipe_open);
output_used += nread;
} else if (nread < 0) {
if (nread == UV_EOF) {
@ -104,8 +104,8 @@ static void spawn(void) {
uv_stdio_container_t stdio[2];
int r;
ASSERT(process_open == 0);
ASSERT(pipe_open == 0);
ASSERT_OK(process_open);
ASSERT_OK(pipe_open);
args[0] = exepath;
args[1] = "spawn_helper";
@ -123,14 +123,14 @@ static void spawn(void) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
r = uv_spawn(loop, &process, &options);
ASSERT(r == 0);
ASSERT_OK(r);
process_open = 1;
pipe_open = 1;
output_used = 0;
r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -141,7 +141,7 @@ BENCHMARK_IMPL(spawn) {
loop = uv_default_loop();
r = uv_exepath(exepath, &exepath_size);
ASSERT(r == 0);
ASSERT_OK(r);
exepath[exepath_size] = '\0';
uv_update_time(loop);
@ -150,7 +150,7 @@ BENCHMARK_IMPL(spawn) {
spawn();
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
uv_update_time(loop);
end_time = uv_now(loop);

30
deps/libuv/test/benchmark-tcp-write-batch.c vendored
View File

@ -55,16 +55,16 @@ static void connect_cb(uv_connect_t* req, int status) {
int i;
int r;
ASSERT(req->handle == (uv_stream_t*)&tcp_client);
ASSERT_PTR_EQ(req->handle, (uv_stream_t*)&tcp_client);
for (i = 0; i < NUM_WRITE_REQS; i++) {
w = &write_reqs[i];
r = uv_write(&w->req, req->handle, &w->buf, 1, write_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
r = uv_shutdown(&shutdown_req, req->handle, shutdown_cb);
ASSERT(r == 0);
ASSERT_OK(r);
connect_cb_called++;
}
@ -72,14 +72,14 @@ static void connect_cb(uv_connect_t* req, int status) {
static void write_cb(uv_write_t* req, int status) {
ASSERT_NOT_NULL(req);
ASSERT(status == 0);
ASSERT_OK(status);
write_cb_called++;
}
static void shutdown_cb(uv_shutdown_t* req, int status) {
ASSERT(req->handle == (uv_stream_t*)&tcp_client);
ASSERT(req->handle->write_queue_size == 0);
ASSERT_PTR_EQ(req->handle, (uv_stream_t*)&tcp_client);
ASSERT_OK(req->handle->write_queue_size);
uv_close((uv_handle_t*)req->handle, close_cb);
free(write_reqs);
@ -89,7 +89,7 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
static void close_cb(uv_handle_t* handle) {
ASSERT(handle == (uv_handle_t*)&tcp_client);
ASSERT_PTR_EQ(handle, (uv_handle_t*)&tcp_client);
close_cb_called++;
}
@ -112,28 +112,28 @@ BENCHMARK_IMPL(tcp_write_batch) {
}
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(loop, &tcp_client);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_connect(&connect_req,
&tcp_client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
ASSERT_OK(r);
start = uv_hrtime();
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
stop = uv_hrtime();
ASSERT(connect_cb_called == 1);
ASSERT(write_cb_called == NUM_WRITE_REQS);
ASSERT(shutdown_cb_called == 1);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, connect_cb_called);
ASSERT_EQ(write_cb_called, NUM_WRITE_REQS);
ASSERT_EQ(1, shutdown_cb_called);
ASSERT_EQ(1, close_cb_called);
printf("%ld write requests in %.2fs.\n",
(long)NUM_WRITE_REQS,

8
deps/libuv/test/benchmark-thread.c vendored
View File

@ -31,7 +31,7 @@ static volatile int num_threads;
static void thread_entry(void* arg) {
ASSERT(arg == (void *) 42);
ASSERT_PTR_EQ(arg, (void *) 42);
num_threads++;
/* FIXME write barrier? */
}
@ -47,15 +47,15 @@ BENCHMARK_IMPL(thread_create) {
for (i = 0; i < NUM_THREADS; i++) {
r = uv_thread_create(&tid, thread_entry, (void *) 42);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_thread_join(&tid);
ASSERT(r == 0);
ASSERT_OK(r);
}
duration = (uv_hrtime() - start_time) / 1e9;
ASSERT(num_threads == NUM_THREADS);
ASSERT_EQ(num_threads, NUM_THREADS);
printf("%d threads created in %.2f seconds (%.0f/s)\n",
NUM_THREADS, duration, NUM_THREADS / duration);

60
deps/libuv/test/benchmark-udp-pummel.c vendored
View File

@ -63,7 +63,7 @@ static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
ASSERT(suggested_size <= sizeof(slab));
ASSERT_LE(suggested_size, sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}
@ -75,7 +75,7 @@ static void send_cb(uv_udp_send_t* req, int status) {
ASSERT_NOT_NULL(req);
if (status != 0) {
ASSERT(status == UV_ECANCELED);
ASSERT_EQ(status, UV_ECANCELED);
return;
}
@ -83,7 +83,7 @@ static void send_cb(uv_udp_send_t* req, int status) {
return;
s = container_of(req, struct sender_state, send_req);
ASSERT(req->handle == &s->udp_handle);
ASSERT_PTR_EQ(req->handle, &s->udp_handle);
if (timed)
goto send;
@ -96,12 +96,12 @@ static void send_cb(uv_udp_send_t* req, int status) {
packet_counter--;
send:
ASSERT(0 == uv_udp_send(&s->send_req,
&s->udp_handle,
bufs,
ARRAY_SIZE(bufs),
(const struct sockaddr*) &s->addr,
send_cb));
ASSERT_OK(uv_udp_send(&s->send_req,
&s->udp_handle,
bufs,
ARRAY_SIZE(bufs),
(const struct sockaddr*) &s->addr,
send_cb));
send_cb_called++;
}
@ -115,11 +115,11 @@ static void recv_cb(uv_udp_t* handle,
return;
if (nread < 0) {
ASSERT(nread == UV_ECANCELED);
ASSERT_EQ(nread, UV_ECANCELED);
return;
}
ASSERT(addr->sa_family == AF_INET);
ASSERT_EQ(addr->sa_family, AF_INET);
ASSERT(!memcmp(buf->base, EXPECTED, nread));
recv_cb_called++;
@ -153,8 +153,8 @@ static int pummel(unsigned int n_senders,
uv_loop_t* loop;
unsigned int i;
ASSERT(n_senders <= ARRAY_SIZE(senders));
ASSERT(n_receivers <= ARRAY_SIZE(receivers));
ASSERT_LE(n_senders, ARRAY_SIZE(senders));
ASSERT_LE(n_receivers, ARRAY_SIZE(receivers));
loop = uv_default_loop();
@ -162,8 +162,8 @@ static int pummel(unsigned int n_senders,
n_receivers_ = n_receivers;
if (timeout) {
ASSERT(0 == uv_timer_init(loop, &timer_handle));
ASSERT(0 == uv_timer_start(&timer_handle, timeout_cb, timeout, 0));
ASSERT_OK(uv_timer_init(loop, &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, timeout_cb, timeout, 0));
/* Timer should not keep loop alive. */
uv_unref((uv_handle_t*)&timer_handle);
timed = 1;
@ -172,10 +172,10 @@ static int pummel(unsigned int n_senders,
for (i = 0; i < n_receivers; i++) {
struct receiver_state* s = receivers + i;
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr));
ASSERT(0 == uv_udp_init(loop, &s->udp_handle));
ASSERT(0 == uv_udp_bind(&s->udp_handle, (const struct sockaddr*) &addr, 0));
ASSERT(0 == uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb));
ASSERT_OK(uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr));
ASSERT_OK(uv_udp_init(loop, &s->udp_handle));
ASSERT_OK(uv_udp_bind(&s->udp_handle, (const struct sockaddr*) &addr, 0));
ASSERT_OK(uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb));
uv_unref((uv_handle_t*)&s->udp_handle);
}
@ -187,20 +187,20 @@ static int pummel(unsigned int n_senders,
for (i = 0; i < n_senders; i++) {
struct sender_state* s = senders + i;
ASSERT(0 == uv_ip4_addr("127.0.0.1",
BASE_PORT + (i % n_receivers),
&s->addr));
ASSERT(0 == uv_udp_init(loop, &s->udp_handle));
ASSERT(0 == uv_udp_send(&s->send_req,
&s->udp_handle,
bufs,
ARRAY_SIZE(bufs),
(const struct sockaddr*) &s->addr,
send_cb));
ASSERT_OK(uv_ip4_addr("127.0.0.1",
BASE_PORT + (i % n_receivers),
&s->addr));
ASSERT_OK(uv_udp_init(loop, &s->udp_handle));
ASSERT_OK(uv_udp_send(&s->send_req,
&s->udp_handle,
bufs,
ARRAY_SIZE(bufs),
(const struct sockaddr*) &s->addr,
send_cb));
}
duration = uv_hrtime();
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
duration = uv_hrtime() - duration;
/* convert from nanoseconds to milliseconds */
duration = duration / (uint64_t) 1e6;

22
deps/libuv/test/blackhole-server.c vendored
View File

@ -43,20 +43,20 @@ static void connection_cb(uv_stream_t* stream, int status) {
conn_rec* conn;
int r;
ASSERT(status == 0);
ASSERT(stream == (uv_stream_t*)&tcp_server);
ASSERT_OK(status);
ASSERT_PTR_EQ(stream, (uv_stream_t*)&tcp_server);
conn = malloc(sizeof *conn);
ASSERT_NOT_NULL(conn);
r = uv_tcp_init(stream->loop, &conn->handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_accept(stream, (uv_stream_t*)&conn->handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_read_start((uv_stream_t*)&conn->handle, alloc_cb, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -76,12 +76,12 @@ static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
if (nread >= 0)
return;
ASSERT(nread == UV_EOF);
ASSERT_EQ(nread, UV_EOF);
conn = container_of(stream, conn_rec, handle);
r = uv_shutdown(&conn->shutdown_req, stream, shutdown_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -103,16 +103,16 @@ HELPER_IMPL(tcp4_blackhole_server) {
int r;
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(loop, &tcp_server);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&tcp_server, 128, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
notify_parent_process();
r = uv_run(loop, UV_RUN_DEFAULT);

36
deps/libuv/test/echo-server.c vendored
View File

@ -65,14 +65,14 @@ static void after_write(uv_write_t* req, int status) {
static void after_shutdown(uv_shutdown_t* req, int status) {
ASSERT_EQ(status, 0);
ASSERT_OK(status);
uv_close((uv_handle_t*) req->handle, on_close);
free(req);
}
static void on_shutdown(uv_shutdown_t* req, int status) {
ASSERT_EQ(status, 0);
ASSERT_OK(status);
free(req);
}
@ -92,7 +92,7 @@ static void after_read(uv_stream_t* handle,
free(buf->base);
sreq = malloc(sizeof* sreq);
if (uv_is_writable(handle)) {
ASSERT_EQ(0, uv_shutdown(sreq, handle, after_shutdown));
ASSERT_OK(uv_shutdown(sreq, handle, after_shutdown));
}
return;
}
@ -118,7 +118,7 @@ static void after_read(uv_stream_t* handle,
if (i + 2 < nread && buf->base[i + 2] == 'H')
reset = 1;
if (reset && handle->type == UV_TCP)
ASSERT_EQ(0, uv_tcp_close_reset((uv_tcp_t*) handle, on_close));
ASSERT_OK(uv_tcp_close_reset((uv_tcp_t*) handle, on_close));
else if (shutdown)
break;
else
@ -141,7 +141,7 @@ static void after_read(uv_stream_t* handle,
}
if (shutdown)
ASSERT_EQ(0, uv_shutdown(malloc(sizeof* sreq), handle, on_shutdown));
ASSERT_OK(uv_shutdown(malloc(sizeof* sreq), handle, on_shutdown));
}
@ -173,21 +173,21 @@ static void on_connection(uv_stream_t* server, int status) {
if (status != 0) {
fprintf(stderr, "Connect error %s\n", uv_err_name(status));
}
ASSERT(status == 0);
ASSERT_OK(status);
switch (serverType) {
case TCP:
stream = malloc(sizeof(uv_tcp_t));
ASSERT_NOT_NULL(stream);
r = uv_tcp_init(loop, (uv_tcp_t*)stream);
ASSERT(r == 0);
ASSERT_OK(r);
break;
case PIPE:
stream = malloc(sizeof(uv_pipe_t));
ASSERT_NOT_NULL(stream);
r = uv_pipe_init(loop, (uv_pipe_t*)stream, 0);
ASSERT(r == 0);
ASSERT_OK(r);
break;
default:
@ -199,15 +199,15 @@ static void on_connection(uv_stream_t* server, int status) {
stream->data = server;
r = uv_accept(server, stream);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_read_start(stream, echo_alloc, after_read);
ASSERT(r == 0);
ASSERT_OK(r);
}
static void on_server_close(uv_handle_t* handle) {
ASSERT(handle == server);
ASSERT_PTR_EQ(handle, server);
}
static uv_udp_send_t* send_alloc(void) {
@ -221,7 +221,7 @@ static uv_udp_send_t* send_alloc(void) {
static void on_send(uv_udp_send_t* req, int status) {
ASSERT_NOT_NULL(req);
ASSERT(status == 0);
ASSERT_OK(status);
req->data = send_freelist;
send_freelist = req;
}
@ -239,20 +239,20 @@ static void on_recv(uv_udp_t* handle,
return;
}
ASSERT(nread > 0);
ASSERT(addr->sa_family == AF_INET);
ASSERT_GT(nread, 0);
ASSERT_EQ(addr->sa_family, AF_INET);
req = send_alloc();
ASSERT_NOT_NULL(req);
sndbuf = uv_buf_init(rcvbuf->base, nread);
ASSERT(0 <= uv_udp_send(req, handle, &sndbuf, 1, addr, on_send));
ASSERT_LE(0, uv_udp_send(req, handle, &sndbuf, 1, addr, on_send));
}
static int tcp4_echo_start(int port) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", port, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", port, &addr));
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
@ -286,7 +286,7 @@ static int tcp6_echo_start(int port) {
struct sockaddr_in6 addr6;
int r;
ASSERT(0 == uv_ip6_addr("::1", port, &addr6));
ASSERT_OK(uv_ip6_addr("::1", port, &addr6));
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
@ -321,7 +321,7 @@ static int udp4_echo_start(int port) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", port, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", port, &addr));
server = (uv_handle_t*)&udpServer;
serverType = UDP;

33
deps/libuv/test/run-tests.c vendored
View File

@ -145,7 +145,7 @@ static int maybe_run_test(int argc, char **argv) {
if (strcmp(argv[1], "spawn_helper3") == 0) {
char buffer[256];
notify_parent_process();
ASSERT(buffer == fgets(buffer, sizeof(buffer) - 1, stdin));
ASSERT_PTR_EQ(buffer, fgets(buffer, sizeof(buffer) - 1, stdin));
buffer[sizeof(buffer) - 1] = '\0';
fputs(buffer, stdout);
return 1;
@ -183,10 +183,10 @@ static int maybe_run_test(int argc, char **argv) {
notify_parent_process();
r = fprintf(stdout, "hello world\n");
ASSERT(r > 0);
ASSERT_GT(r, 0);
r = fprintf(stderr, "hello errworld\n");
ASSERT(r > 0);
ASSERT_GT(r, 0);
return 1;
}
@ -202,7 +202,7 @@ static int maybe_run_test(int argc, char **argv) {
ASSERT_NOT_NULL(test);
r = fprintf(stdout, "%s", test);
ASSERT(r > 0);
ASSERT_GT(r, 0);
return 1;
}
@ -216,23 +216,24 @@ static int maybe_run_test(int argc, char **argv) {
sCompareObjectHandles pCompareObjectHandles; /* function introduced in Windows 10 */
#endif
notify_parent_process();
ASSERT(sizeof(closed_fd) == read(0, &closed_fd, sizeof(closed_fd)));
ASSERT(sizeof(open_fd) == read(0, &open_fd, sizeof(open_fd)));
ASSERT_EQ(sizeof(closed_fd), read(0, &closed_fd, sizeof(closed_fd)));
ASSERT_EQ(sizeof(open_fd), read(0, &open_fd, sizeof(open_fd)));
#ifdef _WIN32
ASSERT((intptr_t) closed_fd > 0);
ASSERT((intptr_t) open_fd > 0);
ASSERT(0 != GetHandleInformation(open_fd, &flags));
ASSERT_GT((intptr_t) closed_fd, 0);
ASSERT_GT((intptr_t) open_fd, 0);
ASSERT_NE(0, GetHandleInformation(open_fd, &flags));
kernelbase_module = GetModuleHandleA("kernelbase.dll");
pCompareObjectHandles = (sCompareObjectHandles)
GetProcAddress(kernelbase_module, "CompareObjectHandles");
ASSERT(pCompareObjectHandles == NULL || !pCompareObjectHandles(open_fd, closed_fd));
ASSERT_NE(pCompareObjectHandles == NULL || \
!pCompareObjectHandles(open_fd, closed_fd), 0);
#else
ASSERT(open_fd > 2);
ASSERT(closed_fd > 2);
ASSERT_GT(open_fd, 2);
ASSERT_GT(closed_fd, 2);
# if defined(__PASE__) /* On IBMi PASE, write() returns 1 */
ASSERT(1 == write(closed_fd, "x", 1));
ASSERT_EQ(1, write(closed_fd, "x", 1));
# else
ASSERT(-1 == write(closed_fd, "x", 1));
ASSERT_EQ(-1, write(closed_fd, "x", 1));
# endif /* !__PASE__ */
#endif
return 1;
@ -249,8 +250,8 @@ static int maybe_run_test(int argc, char **argv) {
uv_uid_t uid = atoi(argv[2]);
uv_gid_t gid = atoi(argv[3]);
ASSERT(uid == getuid());
ASSERT(gid == getgid());
ASSERT_EQ(uid, getuid());
ASSERT_EQ(gid, getgid());
notify_parent_process();
return 1;

4
deps/libuv/test/runner-win.c vendored
View File

@ -185,7 +185,7 @@ int process_wait(process_info_t *vec, int n, int timeout) {
if (n == 0)
return 0;
ASSERT(n <= MAXIMUM_WAIT_OBJECTS);
ASSERT_LE(n, MAXIMUM_WAIT_OBJECTS);
for (i = 0; i < n; i++)
handles[i] = vec[i].process;
@ -245,7 +245,7 @@ int process_read_last_line(process_info_t *p,
DWORD start;
OVERLAPPED overlapped;
ASSERT(buffer_len > 0);
ASSERT_GT(buffer_len, 0);
size = GetFileSize(p->stdio_out, NULL);
if (size == INVALID_FILE_SIZE)

5
deps/libuv/test/task.h vendored
View File

@ -244,13 +244,16 @@ typedef enum {
#define ASSERT_PTR_NE(a, b) \
ASSERT_BASE(a, !=, b, void*, "p")
#define ASSERT_PTR_LT(a, b) \
ASSERT_BASE(a, <, b, void*, "p")
/* This macro cleans up the event loop. This is used to avoid valgrind
* warnings about memory being "leaked" by the event loop.
*/
#define MAKE_VALGRIND_HAPPY(loop) \
do { \
close_loop(loop); \
ASSERT(0 == uv_loop_close(loop)); \
ASSERT_EQ(0, uv_loop_close(loop)); \
uv_library_shutdown(); \
} while (0)

32
deps/libuv/test/test-active.c vendored
View File

@ -45,39 +45,39 @@ TEST_IMPL(active) {
uv_timer_t timer;
r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);
ASSERT_OK(r);
/* uv_is_active() and uv_is_closing() should always return either 0 or 1. */
ASSERT(0 == uv_is_active((uv_handle_t*) &timer));
ASSERT(0 == uv_is_closing((uv_handle_t*) &timer));
ASSERT_OK(uv_is_active((uv_handle_t*) &timer));
ASSERT_OK(uv_is_closing((uv_handle_t*) &timer));
r = uv_timer_start(&timer, timer_cb, 1000, 0);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(1 == uv_is_active((uv_handle_t*) &timer));
ASSERT(0 == uv_is_closing((uv_handle_t*) &timer));
ASSERT_EQ(1, uv_is_active((uv_handle_t*) &timer));
ASSERT_OK(uv_is_closing((uv_handle_t*) &timer));
r = uv_timer_stop(&timer);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(0 == uv_is_active((uv_handle_t*) &timer));
ASSERT(0 == uv_is_closing((uv_handle_t*) &timer));
ASSERT_OK(uv_is_active((uv_handle_t*) &timer));
ASSERT_OK(uv_is_closing((uv_handle_t*) &timer));
r = uv_timer_start(&timer, timer_cb, 1000, 0);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(1 == uv_is_active((uv_handle_t*) &timer));
ASSERT(0 == uv_is_closing((uv_handle_t*) &timer));
ASSERT_EQ(1, uv_is_active((uv_handle_t*) &timer));
ASSERT_OK(uv_is_closing((uv_handle_t*) &timer));
uv_close((uv_handle_t*) &timer, close_cb);
ASSERT(0 == uv_is_active((uv_handle_t*) &timer));
ASSERT(1 == uv_is_closing((uv_handle_t*) &timer));
ASSERT_OK(uv_is_active((uv_handle_t*) &timer));
ASSERT_EQ(1, uv_is_closing((uv_handle_t*) &timer));
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

16
deps/libuv/test/test-async-null-cb.c vendored
View File

@ -36,7 +36,7 @@ static void thread_cb(void* dummy) {
static void check_cb(uv_check_t* handle) {
ASSERT(check_cb_called == 0);
ASSERT_OK(check_cb_called);
uv_close((uv_handle_t*) &async_handle, NULL);
uv_close((uv_handle_t*) &check_handle, NULL);
check_cb_called++;
@ -52,13 +52,13 @@ TEST_IMPL(async_null_cb) {
*/
memset(&async_handle, 0xff, sizeof(async_handle));
ASSERT(0 == uv_async_init(uv_default_loop(), &async_handle, NULL));
ASSERT(0 == uv_check_init(uv_default_loop(), &check_handle));
ASSERT(0 == uv_check_start(&check_handle, check_cb));
ASSERT(0 == uv_thread_create(&thread, thread_cb, NULL));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(0 == uv_thread_join(&thread));
ASSERT(1 == check_cb_called);
ASSERT_OK(uv_async_init(uv_default_loop(), &async_handle, NULL));
ASSERT_OK(uv_check_init(uv_default_loop(), &check_handle));
ASSERT_OK(uv_check_start(&check_handle, check_cb));
ASSERT_OK(uv_thread_create(&thread, thread_cb, NULL));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_thread_join(&thread));
ASSERT_EQ(1, check_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
}

26
deps/libuv/test/test-async.c vendored
View File

@ -49,7 +49,7 @@ static void thread_cb(void *arg) {
}
r = uv_async_send(&async);
ASSERT(r == 0);
ASSERT_OK(r);
/* Work around a bug in Valgrind.
*
@ -78,7 +78,7 @@ static void close_cb(uv_handle_t* handle) {
static void async_cb(uv_async_t* handle) {
int n;
ASSERT(handle == &async);
ASSERT_PTR_EQ(handle, &async);
uv_mutex_lock(&mutex);
n = ++async_cb_called;
@ -94,13 +94,13 @@ static void async_cb(uv_async_t* handle) {
static void prepare_cb(uv_prepare_t* handle) {
int r;
ASSERT(handle == &prepare);
ASSERT_PTR_EQ(handle, &prepare);
if (prepare_cb_called++)
return;
r = uv_thread_create(&thread, thread_cb, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_mutex_unlock(&mutex);
}
@ -109,25 +109,25 @@ TEST_IMPL(async) {
int r;
r = uv_mutex_init(&mutex);
ASSERT(r == 0);
ASSERT_OK(r);
uv_mutex_lock(&mutex);
r = uv_prepare_init(uv_default_loop(), &prepare);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_prepare_start(&prepare, prepare_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_async_init(uv_default_loop(), &async, async_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(prepare_cb_called > 0);
ASSERT(async_cb_called == 3);
ASSERT(close_cb_called == 2);
ASSERT_GT(prepare_cb_called, 0);
ASSERT_EQ(3, async_cb_called);
ASSERT_EQ(2, close_cb_called);
ASSERT(0 == uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

26
deps/libuv/test/test-barrier.c vendored
View File

@ -53,13 +53,13 @@ TEST_IMPL(barrier_1) {
memset(&wc, 0, sizeof(wc));
wc.niter = 1;
ASSERT_EQ(0, uv_barrier_init(&wc.barrier, 2));
ASSERT_EQ(0, uv_thread_create(&thread, worker, &wc));
ASSERT_OK(uv_barrier_init(&wc.barrier, 2));
ASSERT_OK(uv_thread_create(&thread, worker, &wc));
uv_sleep(100);
wc.main_barrier_wait_rval = uv_barrier_wait(&wc.barrier);
ASSERT_EQ(0, uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
uv_barrier_destroy(&wc.barrier);
ASSERT_EQ(1, (wc.main_barrier_wait_rval ^ wc.worker_barrier_wait_rval));
@ -76,12 +76,12 @@ TEST_IMPL(barrier_2) {
wc.delay = 100;
wc.niter = 1;
ASSERT_EQ(0, uv_barrier_init(&wc.barrier, 2));
ASSERT_EQ(0, uv_thread_create(&thread, worker, &wc));
ASSERT_OK(uv_barrier_init(&wc.barrier, 2));
ASSERT_OK(uv_thread_create(&thread, worker, &wc));
wc.main_barrier_wait_rval = uv_barrier_wait(&wc.barrier);
ASSERT_EQ(0, uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
uv_barrier_destroy(&wc.barrier);
ASSERT_EQ(1, (wc.main_barrier_wait_rval ^ wc.worker_barrier_wait_rval));
@ -98,13 +98,13 @@ TEST_IMPL(barrier_3) {
memset(&wc, 0, sizeof(wc));
wc.niter = 5;
ASSERT_EQ(0, uv_barrier_init(&wc.barrier, 2));
ASSERT_EQ(0, uv_thread_create(&thread, worker, &wc));
ASSERT_OK(uv_barrier_init(&wc.barrier, 2));
ASSERT_OK(uv_thread_create(&thread, worker, &wc));
for (i = 0; i < wc.niter; i++)
wc.main_barrier_wait_rval += uv_barrier_wait(&wc.barrier);
ASSERT_EQ(0, uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
uv_barrier_destroy(&wc.barrier);
ASSERT_EQ(wc.niter, wc.main_barrier_wait_rval + wc.worker_barrier_wait_rval);
@ -133,10 +133,10 @@ TEST_IMPL(barrier_serial_thread) {
uv_barrier_t barrier;
unsigned i;
ASSERT_EQ(0, uv_barrier_init(&barrier, ARRAY_SIZE(threads) + 1));
ASSERT_OK(uv_barrier_init(&barrier, ARRAY_SIZE(threads) + 1));
for (i = 0; i < ARRAY_SIZE(threads); ++i)
ASSERT_EQ(0, uv_thread_create(&threads[i], serial_worker, &barrier));
ASSERT_OK(uv_thread_create(&threads[i], serial_worker, &barrier));
for (i = 0; i < 5; i++)
uv_barrier_wait(&barrier);
@ -144,7 +144,7 @@ TEST_IMPL(barrier_serial_thread) {
uv_barrier_destroy(&barrier);
for (i = 0; i < ARRAY_SIZE(threads); ++i)
ASSERT_EQ(0, uv_thread_join(&threads[i]));
ASSERT_OK(uv_thread_join(&threads[i]));
return 0;
}
@ -153,7 +153,7 @@ TEST_IMPL(barrier_serial_thread) {
TEST_IMPL(barrier_serial_thread_single) {
uv_barrier_t barrier;
ASSERT_EQ(0, uv_barrier_init(&barrier, 1));
ASSERT_OK(uv_barrier_init(&barrier, 1));
ASSERT_LT(0, uv_barrier_wait(&barrier));
uv_barrier_destroy(&barrier);
return 0;

35
deps/libuv/test/test-callback-stack.c vendored
View File

@ -60,7 +60,7 @@ static void close_cb(uv_handle_t* handle) {
static void shutdown_cb(uv_shutdown_t* req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
ASSERT(nested == 0 && "shutdown_cb must be called from a fresh stack");
shutdown_cb_called++;
@ -77,7 +77,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
return;
} else if (nread < 0) {
ASSERT(nread == UV_EOF);
ASSERT_EQ(nread, UV_EOF);
nested++;
uv_close((uv_handle_t*)tcp, close_cb);
@ -105,7 +105,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
static void timer_cb(uv_timer_t* handle) {
ASSERT(handle == &timer);
ASSERT_PTR_EQ(handle, &timer);
ASSERT(nested == 0 && "timer_cb must be called from a fresh stack");
puts("Timeout complete. Now read data...");
@ -125,7 +125,7 @@ static void timer_cb(uv_timer_t* handle) {
static void write_cb(uv_write_t* req, int status) {
int r;
ASSERT(status == 0);
ASSERT_OK(status);
ASSERT(nested == 0 && "write_cb must be called from a fresh stack");
puts("Data written. 500ms timeout...");
@ -136,9 +136,9 @@ static void write_cb(uv_write_t* req, int status) {
* for the backend to use dirty stack for calling read_cb. */
nested++;
r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, timer_cb, 500, 0);
ASSERT(r == 0);
ASSERT_OK(r);
nested--;
write_cb_called++;
@ -150,7 +150,7 @@ static void connect_cb(uv_connect_t* req, int status) {
puts("Connected. Write some data to echo server...");
ASSERT(status == 0);
ASSERT_OK(status);
ASSERT(nested == 0 && "connect_cb must be called from a fresh stack");
nested++;
@ -171,7 +171,7 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(callback_stack) {
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
if (uv_tcp_init(uv_default_loop(), &client)) {
FATAL("uv_tcp_init failed");
@ -191,13 +191,18 @@ TEST_IMPL(callback_stack) {
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(nested == 0);
ASSERT(connect_cb_called == 1 && "connect_cb must be called exactly once");
ASSERT(write_cb_called == 1 && "write_cb must be called exactly once");
ASSERT(timer_cb_called == 1 && "timer_cb must be called exactly once");
ASSERT(bytes_received == sizeof MESSAGE);
ASSERT(shutdown_cb_called == 1 && "shutdown_cb must be called exactly once");
ASSERT(close_cb_called == 2 && "close_cb must be called exactly twice");
ASSERT_OK(nested);
ASSERT_NE(connect_cb_called == 1 && \
"connect_cb must be called exactly once", 0);
ASSERT_NE(write_cb_called == 1 && "write_cb must be called exactly once",
0);
ASSERT_NE(timer_cb_called == 1 && "timer_cb must be called exactly once",
0);
ASSERT_EQ(bytes_received, sizeof MESSAGE);
ASSERT_NE(shutdown_cb_called == 1 && \
"shutdown_cb must be called exactly once", 0);
ASSERT_NE(close_cb_called == 2 && "close_cb must be called exactly twice",
0);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

34
deps/libuv/test/test-close-fd.c vendored
View File

@ -36,11 +36,11 @@ static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
switch (++read_cb_called) {
case 1:
ASSERT(nread == 1);
ASSERT_EQ(1, nread);
uv_read_stop(handle);
break;
case 2:
ASSERT(nread == UV_EOF);
ASSERT_EQ(nread, UV_EOF);
uv_close((uv_handle_t *) handle, NULL);
break;
default:
@ -55,29 +55,29 @@ TEST_IMPL(close_fd) {
uv_file fd[2];
bufs[0] = uv_buf_init("", 1);
ASSERT(0 == uv_pipe(fd, 0, 0));
ASSERT(0 == uv_pipe_init(uv_default_loop(), &pipe_handle, 0));
ASSERT(0 == uv_pipe_open(&pipe_handle, fd[0]));
ASSERT_OK(uv_pipe(fd, 0, 0));
ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_handle, 0));
ASSERT_OK(uv_pipe_open(&pipe_handle, fd[0]));
/* uv_pipe_open() takes ownership of the file descriptor. */
fd[0] = -1;
ASSERT(1 == uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL));
ASSERT(1 == req.result);
ASSERT_EQ(1, uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL));
ASSERT_EQ(1, req.result);
uv_fs_req_cleanup(&req);
#ifdef _WIN32
ASSERT(0 == _close(fd[1]));
ASSERT_OK(_close(fd[1]));
#else
ASSERT(0 == close(fd[1]));
ASSERT_OK(close(fd[1]));
#endif
fd[1] = -1;
ASSERT(0 == uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(1 == read_cb_called);
ASSERT(0 == uv_is_active((const uv_handle_t *) &pipe_handle));
ASSERT(0 == uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(2 == read_cb_called);
ASSERT(0 != uv_is_closing((const uv_handle_t *) &pipe_handle));
ASSERT_OK(uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(1, read_cb_called);
ASSERT_OK(uv_is_active((const uv_handle_t *) &pipe_handle));
ASSERT_OK(uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(2, read_cb_called);
ASSERT_NE(0, uv_is_closing((const uv_handle_t *) &pipe_handle));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

18
deps/libuv/test/test-close-order.c vendored
View File

@ -39,9 +39,9 @@ static void close_cb(uv_handle_t* handle) {
/* check_cb should run before any close_cb */
static void check_cb(uv_check_t* handle) {
ASSERT(check_cb_called == 0);
ASSERT(timer_cb_called == 1);
ASSERT(close_cb_called == 0);
ASSERT_OK(check_cb_called);
ASSERT_EQ(1, timer_cb_called);
ASSERT_OK(close_cb_called);
uv_close((uv_handle_t*) handle, close_cb);
uv_close((uv_handle_t*) &timer_handle2, close_cb);
check_cb_called++;
@ -65,15 +65,15 @@ TEST_IMPL(close_order) {
uv_timer_init(loop, &timer_handle2);
uv_timer_start(&timer_handle2, timer_cb, 100000, 0);
ASSERT(check_cb_called == 0);
ASSERT(close_cb_called == 0);
ASSERT(timer_cb_called == 0);
ASSERT_OK(check_cb_called);
ASSERT_OK(close_cb_called);
ASSERT_OK(timer_cb_called);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(check_cb_called == 1);
ASSERT(close_cb_called == 3);
ASSERT(timer_cb_called == 1);
ASSERT_EQ(1, check_cb_called);
ASSERT_EQ(3, close_cb_called);
ASSERT_EQ(1, timer_cb_called);
MAKE_VALGRIND_HAPPY(loop);
return 0;

36
deps/libuv/test/test-condvar.c vendored
View File

@ -55,10 +55,10 @@ void worker_config_init(worker_config* wc,
wc->use_broadcast = use_broadcast;
/* Init. */
ASSERT(0 == uv_sem_init(&wc->sem_waiting, 0));
ASSERT(0 == uv_sem_init(&wc->sem_signaled, 0));
ASSERT(0 == uv_cond_init(&wc->cond));
ASSERT(0 == uv_mutex_init(&wc->mutex));
ASSERT_OK(uv_sem_init(&wc->sem_waiting, 0));
ASSERT_OK(uv_sem_init(&wc->sem_signaled, 0));
ASSERT_OK(uv_cond_init(&wc->cond));
ASSERT_OK(uv_mutex_init(&wc->mutex));
}
void worker_config_destroy(worker_config* wc) {
@ -87,7 +87,7 @@ static void condvar_signal(worker_config* c, int* flag) {
uv_mutex_lock(&c->mutex);
/* Help waiter differentiate between spurious and legitimate wakeup. */
ASSERT(*flag == 0);
ASSERT_OK(*flag);
*flag = 1;
if (c->use_broadcast)
@ -113,7 +113,7 @@ static int condvar_wait(worker_config* c, const int* flag) {
do {
uv_cond_wait(&c->cond, &c->mutex);
} while (*flag == 0);
ASSERT(*flag == 1);
ASSERT_EQ(1, *flag);
uv_mutex_unlock(&c->mutex);
@ -130,13 +130,13 @@ TEST_IMPL(condvar_1) {
/* Helper signal-then-wait. */
worker_config_init(&wc, 0, condvar_signal, condvar_wait);
ASSERT(0 == uv_thread_create(&thread, worker, &wc));
ASSERT_OK(uv_thread_create(&thread, worker, &wc));
/* We wait-then-signal. */
ASSERT(0 == wc.wait_cond(&wc, &wc.posted_1));
ASSERT_OK(wc.wait_cond(&wc, &wc.posted_1));
wc.signal_cond(&wc, &wc.posted_2);
ASSERT(0 == uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
worker_config_destroy(&wc);
return 0;
@ -149,13 +149,13 @@ TEST_IMPL(condvar_2) {
/* Helper to signal-then-wait. */
worker_config_init(&wc, 1, condvar_signal, condvar_wait);
ASSERT(0 == uv_thread_create(&thread, worker, &wc));
ASSERT_OK(uv_thread_create(&thread, worker, &wc));
/* We wait-then-signal. */
ASSERT(0 == wc.wait_cond(&wc, &wc.posted_1));
ASSERT_OK(wc.wait_cond(&wc, &wc.posted_1));
wc.signal_cond(&wc, &wc.posted_2);
ASSERT(0 == uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
worker_config_destroy(&wc);
return 0;
@ -176,9 +176,9 @@ static int condvar_timedwait(worker_config* c, const int* flag) {
/* Wait until I get a non-spurious signal. */
do {
r = uv_cond_timedwait(&c->cond, &c->mutex, (uint64_t)(1 * 1e9)); /* 1 s */
ASSERT(r == 0); /* Should not time out. */
ASSERT_OK(r); /* Should not time out. */
} while (*flag == 0);
ASSERT(*flag == 1);
ASSERT_EQ(1, *flag);
uv_mutex_unlock(&c->mutex);
@ -194,13 +194,13 @@ TEST_IMPL(condvar_3) {
/* Helper to signal-then-wait. */
worker_config_init(&wc, 0, condvar_signal, condvar_timedwait);
ASSERT(0 == uv_thread_create(&thread, worker, &wc));
ASSERT_OK(uv_thread_create(&thread, worker, &wc));
/* We wait-then-signal. */
wc.wait_cond(&wc, &wc.posted_1);
wc.signal_cond(&wc, &wc.posted_2);
ASSERT(0 == uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
worker_config_destroy(&wc);
return 0;
@ -213,13 +213,13 @@ TEST_IMPL(condvar_4) {
/* Helper to signal-then-wait. */
worker_config_init(&wc, 1, condvar_signal, condvar_timedwait);
ASSERT(0 == uv_thread_create(&thread, worker, &wc));
ASSERT_OK(uv_thread_create(&thread, worker, &wc));
/* We wait-then-signal. */
wc.wait_cond(&wc, &wc.posted_1);
wc.signal_cond(&wc, &wc.posted_2);
ASSERT(0 == uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
worker_config_destroy(&wc);
return 0;

30
deps/libuv/test/test-connect-unspecified.c vendored
View File

@ -23,11 +23,11 @@
#include "task.h"
static void connect_4(uv_connect_t* req, int status) {
ASSERT(status != UV_EADDRNOTAVAIL);
ASSERT_NE(status, UV_EADDRNOTAVAIL);
}
static void connect_6(uv_connect_t* req, int status) {
ASSERT(status != UV_EADDRNOTAVAIL);
ASSERT_NE(status, UV_EADDRNOTAVAIL);
}
TEST_IMPL(connect_unspecified) {
@ -41,23 +41,23 @@ TEST_IMPL(connect_unspecified) {
loop = uv_default_loop();
ASSERT(uv_tcp_init(loop, &socket4) == 0);
ASSERT(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr4) == 0);
ASSERT(uv_tcp_connect(&connect4,
&socket4,
(const struct sockaddr*) &addr4,
connect_4) == 0);
ASSERT_OK(uv_tcp_init(loop, &socket4));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr4));
ASSERT_OK(uv_tcp_connect(&connect4,
&socket4,
(const struct sockaddr*) &addr4,
connect_4));
if (can_ipv6()) {
ASSERT(uv_tcp_init(loop, &socket6) == 0);
ASSERT(uv_ip6_addr("::", TEST_PORT, &addr6) == 0);
ASSERT(uv_tcp_connect(&connect6,
&socket6,
(const struct sockaddr*) &addr6,
connect_6) == 0);
ASSERT_OK(uv_tcp_init(loop, &socket6));
ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &addr6));
ASSERT_OK(uv_tcp_connect(&connect6,
&socket6,
(const struct sockaddr*) &addr6,
connect_6));
}
ASSERT(uv_run(loop, UV_RUN_DEFAULT) == 0);
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
MAKE_VALGRIND_HAPPY(loop);
return 0;

34
deps/libuv/test/test-connection-fail.c vendored
View File

@ -54,8 +54,8 @@ static void timer_cb(uv_timer_t* handle) {
* but libuv hasn't automatically closed the socket. The user must
* uv_close the handle manually.
*/
ASSERT(close_cb_calls == 0);
ASSERT(connect_cb_calls == 1);
ASSERT_OK(close_cb_calls);
ASSERT_EQ(1, connect_cb_calls);
/* Close the tcp handle. */
uv_close((uv_handle_t*)&tcp, on_close);
@ -66,22 +66,22 @@ static void timer_cb(uv_timer_t* handle) {
static void on_connect_with_close(uv_connect_t *req, int status) {
ASSERT((uv_stream_t*) &tcp == req->handle);
ASSERT(status == UV_ECONNREFUSED);
ASSERT_PTR_EQ((uv_stream_t*) &tcp, req->handle);
ASSERT_EQ(status, UV_ECONNREFUSED);
connect_cb_calls++;
ASSERT(close_cb_calls == 0);
ASSERT_OK(close_cb_calls);
uv_close((uv_handle_t*)req->handle, on_close);
}
static void on_connect_without_close(uv_connect_t *req, int status) {
ASSERT(status == UV_ECONNREFUSED);
ASSERT_EQ(status, UV_ECONNREFUSED);
connect_cb_calls++;
uv_timer_start(&timer, timer_cb, 100, 0);
ASSERT(close_cb_calls == 0);
ASSERT_OK(close_cb_calls);
}
@ -89,10 +89,10 @@ static void connection_fail(uv_connect_cb connect_cb) {
struct sockaddr_in client_addr, server_addr;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", 0, &client_addr));
/* There should be no servers listening on this port. */
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
/* Try to connect to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(uv_default_loop(), &tcp);
@ -100,7 +100,7 @@ static void connection_fail(uv_connect_cb connect_cb) {
/* We are never doing multiple reads/connects at a time anyway. so these
* handles can be pre-initialized. */
ASSERT(0 == uv_tcp_bind(&tcp, (const struct sockaddr*) &client_addr, 0));
ASSERT_OK(uv_tcp_bind(&tcp, (const struct sockaddr*) &client_addr, 0));
r = uv_tcp_connect(&req,
&tcp,
@ -110,8 +110,8 @@ static void connection_fail(uv_connect_cb connect_cb) {
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connect_cb_calls == 1);
ASSERT(close_cb_calls == 1);
ASSERT_EQ(1, connect_cb_calls);
ASSERT_EQ(1, close_cb_calls);
}
@ -127,8 +127,8 @@ TEST_IMPL(connection_fail) {
connection_fail(on_connect_with_close);
ASSERT(timer_close_cb_calls == 0);
ASSERT(timer_cb_calls == 0);
ASSERT_OK(timer_close_cb_calls);
ASSERT_OK(timer_cb_calls);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -149,12 +149,12 @@ TEST_IMPL(connection_fail_doesnt_auto_close) {
int r;
r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);
ASSERT_OK(r);
connection_fail(on_connect_without_close);
ASSERT(timer_close_cb_calls == 1);
ASSERT(timer_cb_calls == 1);
ASSERT_EQ(1, timer_close_cb_calls);
ASSERT_EQ(1, timer_cb_calls);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

18
deps/libuv/test/test-cwd-and-chdir.c vendored
View File

@ -34,24 +34,24 @@ TEST_IMPL(cwd_and_chdir) {
size1 = 1;
err = uv_cwd(buffer_orig, &size1);
ASSERT(err == UV_ENOBUFS);
ASSERT(size1 > 1);
ASSERT_EQ(err, UV_ENOBUFS);
ASSERT_GT(size1, 1);
size1 = sizeof buffer_orig;
err = uv_cwd(buffer_orig, &size1);
ASSERT(err == 0);
ASSERT(size1 > 0);
ASSERT(buffer_orig[size1] != '/');
ASSERT_OK(err);
ASSERT_GT(size1, 0);
ASSERT_NE(buffer_orig[size1], '/');
err = uv_chdir(buffer_orig);
ASSERT(err == 0);
ASSERT_OK(err);
size2 = sizeof buffer_new;
err = uv_cwd(buffer_new, &size2);
ASSERT(err == 0);
ASSERT_OK(err);
ASSERT(size1 == size2);
ASSERT(strcmp(buffer_orig, buffer_new) == 0);
ASSERT_EQ(size1, size2);
ASSERT_OK(strcmp(buffer_orig, buffer_new));
return 0;
}

18
deps/libuv/test/test-default-loop-close.c vendored
View File

@ -39,19 +39,19 @@ TEST_IMPL(default_loop_close) {
loop = uv_default_loop();
ASSERT_NOT_NULL(loop);
ASSERT(0 == uv_timer_init(loop, &timer_handle));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 1, 0));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT(1 == timer_cb_called);
ASSERT(0 == uv_loop_close(loop));
ASSERT_OK(uv_timer_init(loop, &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1, 0));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
ASSERT_EQ(1, timer_cb_called);
ASSERT_OK(uv_loop_close(loop));
loop = uv_default_loop();
ASSERT_NOT_NULL(loop);
ASSERT(0 == uv_timer_init(loop, &timer_handle));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 1, 0));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT(2 == timer_cb_called);
ASSERT_OK(uv_timer_init(loop, &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1, 0));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
ASSERT_EQ(2, timer_cb_called);
MAKE_VALGRIND_HAPPY(loop);
return 0;

40
deps/libuv/test/test-delayed-accept.c vendored
View File

@ -54,11 +54,11 @@ static void do_accept(uv_timer_t* timer_handle) {
ASSERT_NOT_NULL(accepted_handle);
r = uv_tcp_init(uv_default_loop(), accepted_handle);
ASSERT(r == 0);
ASSERT_OK(r);
server = (uv_tcp_t*)timer_handle->data;
r = uv_accept((uv_stream_t*)server, (uv_stream_t*)accepted_handle);
ASSERT(r == 0);
ASSERT_OK(r);
do_accept_called++;
@ -79,19 +79,19 @@ static void connection_cb(uv_stream_t* tcp, int status) {
int r;
uv_timer_t* timer_handle;
ASSERT(status == 0);
ASSERT_OK(status);
timer_handle = (uv_timer_t*)malloc(sizeof *timer_handle);
ASSERT_NOT_NULL(timer_handle);
/* Accept the client after 1 second */
r = uv_timer_init(uv_default_loop(), timer_handle);
ASSERT(r == 0);
ASSERT_OK(r);
timer_handle->data = tcp;
r = uv_timer_start(timer_handle, do_accept, 1000, 0);
ASSERT(r == 0);
ASSERT_OK(r);
connection_cb_called++;
}
@ -102,16 +102,16 @@ static void start_server(void) {
uv_tcp_t* server = (uv_tcp_t*)malloc(sizeof *server);
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_NOT_NULL(server);
r = uv_tcp_init(uv_default_loop(), server);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_bind(server, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)server, 128, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -123,10 +123,10 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
}
if (nread >= 0) {
ASSERT(nread == 0);
ASSERT_OK(nread);
} else {
ASSERT_NOT_NULL(tcp);
ASSERT(nread == UV_EOF);
ASSERT_EQ(nread, UV_EOF);
uv_close((uv_handle_t*)tcp, close_cb);
}
}
@ -136,12 +136,12 @@ static void connect_cb(uv_connect_t* req, int status) {
int r;
ASSERT_NOT_NULL(req);
ASSERT(status == 0);
ASSERT_OK(status);
/* Not that the server will send anything, but otherwise we'll never know
* when the server closes the connection. */
r = uv_read_start((uv_stream_t*)(req->handle), alloc_cb, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
connect_cb_called++;
@ -155,18 +155,18 @@ static void client_connect(void) {
uv_connect_t* connect_req = malloc(sizeof *connect_req);
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_NOT_NULL(client);
ASSERT_NOT_NULL(connect_req);
r = uv_tcp_init(uv_default_loop(), client);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_connect(connect_req,
client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -179,10 +179,10 @@ TEST_IMPL(delayed_accept) {
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connection_cb_called == 2);
ASSERT(do_accept_called == 2);
ASSERT(connect_cb_called == 2);
ASSERT(close_cb_called == 7);
ASSERT_EQ(2, connection_cb_called);
ASSERT_EQ(2, do_accept_called);
ASSERT_EQ(2, connect_cb_called);
ASSERT_EQ(7, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

2
deps/libuv/test/test-dlerror.c vendored
View File

@ -38,7 +38,7 @@ TEST_IMPL(dlerror) {
ASSERT_NOT_NULL(strstr(msg, dlerror_no_error));
r = uv_dlopen(path, &lib);
ASSERT(r == -1);
ASSERT_EQ(r, -1);
msg = uv_dlerror(&lib);
ASSERT_NOT_NULL(msg);

24
deps/libuv/test/test-eintr-handling.c vendored
View File

@ -48,13 +48,13 @@ struct thread_ctx {
static void thread_main(void* arg) {
int nwritten;
ASSERT(0 == kill(getpid(), SIGUSR1));
ASSERT_OK(kill(getpid(), SIGUSR1));
do
nwritten = write(pipe_fds[1], test_buf, sizeof(test_buf));
while (nwritten == -1 && errno == EINTR);
ASSERT(nwritten == sizeof(test_buf));
ASSERT_EQ(nwritten, sizeof(test_buf));
}
static void sig_func(uv_signal_t* handle, int signum) {
@ -70,24 +70,24 @@ TEST_IMPL(eintr_handling) {
iov = uv_buf_init(buf, sizeof(buf));
loop = uv_default_loop();
ASSERT(0 == uv_signal_init(loop, &signal));
ASSERT(0 == uv_signal_start(&signal, sig_func, SIGUSR1));
ASSERT_OK(uv_signal_init(loop, &signal));
ASSERT_OK(uv_signal_start(&signal, sig_func, SIGUSR1));
ASSERT(0 == pipe(pipe_fds));
ASSERT(0 == uv_thread_create(&thread, thread_main, &ctx));
ASSERT_OK(pipe(pipe_fds));
ASSERT_OK(uv_thread_create(&thread, thread_main, &ctx));
nread = uv_fs_read(loop, &read_req, pipe_fds[0], &iov, 1, -1, NULL);
ASSERT(nread == sizeof(test_buf));
ASSERT(0 == strcmp(buf, test_buf));
ASSERT_EQ(nread, sizeof(test_buf));
ASSERT_OK(strcmp(buf, test_buf));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
ASSERT(0 == close(pipe_fds[0]));
ASSERT(0 == close(pipe_fds[1]));
ASSERT_OK(close(pipe_fds[0]));
ASSERT_OK(close(pipe_fds[1]));
uv_close((uv_handle_t*) &signal, NULL);
ASSERT_EQ(0, uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
MAKE_VALGRIND_HAPPY(loop);
return 0;

10
deps/libuv/test/test-embed.c vendored
View File

@ -36,7 +36,7 @@ static uv_barrier_t barrier;
static void thread_main(void* arg) {
ASSERT_LE(0, uv_barrier_wait(&barrier));
uv_sleep(250);
ASSERT_EQ(0, uv_async_send(&async));
ASSERT_OK(uv_async_send(&async));
}
@ -50,9 +50,9 @@ TEST_IMPL(embed) {
uv_loop_t* loop;
loop = uv_default_loop();
ASSERT_EQ(0, uv_async_init(loop, &async, async_cb));
ASSERT_EQ(0, uv_barrier_init(&barrier, 2));
ASSERT_EQ(0, uv_thread_create(&thread, thread_main, NULL));
ASSERT_OK(uv_async_init(loop, &async, async_cb));
ASSERT_OK(uv_barrier_init(&barrier, 2));
ASSERT_OK(uv_thread_create(&thread, thread_main, NULL));
ASSERT_LE(0, uv_barrier_wait(&barrier));
while (uv_loop_alive(loop)) {
@ -71,7 +71,7 @@ TEST_IMPL(embed) {
#endif
}
ASSERT_EQ(0, uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
uv_barrier_destroy(&barrier);
MAKE_VALGRIND_HAPPY(loop);

30
deps/libuv/test/test-emfile.c vendored
View File

@ -54,37 +54,37 @@ TEST_IMPL(emfile) {
/* Lower the file descriptor limit and use up all fds save one. */
limits.rlim_cur = limits.rlim_max = maxfd + 1;
if (setrlimit(RLIMIT_NOFILE, &limits)) {
ASSERT(errno == EPERM); /* Valgrind blocks the setrlimit() call. */
ASSERT_EQ(errno, EPERM); /* Valgrind blocks the setrlimit() call. */
RETURN_SKIP("setrlimit(RLIMIT_NOFILE) failed, running under valgrind?");
}
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(0 == uv_tcp_init(loop, &server_handle));
ASSERT(0 == uv_tcp_init(loop, &client_handle));
ASSERT(0 == uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0));
ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 8, connection_cb));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_tcp_init(loop, &server_handle));
ASSERT_OK(uv_tcp_init(loop, &client_handle));
ASSERT_OK(uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0));
ASSERT_OK(uv_listen((uv_stream_t*) &server_handle, 8, connection_cb));
/* Remember the first one so we can clean up afterwards. */
do
first_fd = dup(0);
while (first_fd == -1 && errno == EINTR);
ASSERT(first_fd > 0);
ASSERT_GT(first_fd, 0);
while (dup(0) != -1 || errno == EINTR);
ASSERT(errno == EMFILE);
ASSERT_EQ(errno, EMFILE);
close(maxfd);
/* Now connect and use up the last available file descriptor. The EMFILE
* handling logic in src/unix/stream.c should ensure that connect_cb() runs
* whereas connection_cb() should *not* run.
*/
ASSERT(0 == uv_tcp_connect(&connect_req,
&client_handle,
(const struct sockaddr*) &addr,
connect_cb));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT(1 == connect_cb_called);
ASSERT_OK(uv_tcp_connect(&connect_req,
&client_handle,
(const struct sockaddr*) &addr,
connect_cb));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
ASSERT_EQ(1, connect_cb_called);
/* Close the dups again. Ignore errors in the unlikely event that the
* file descriptors were not contiguous.
@ -108,7 +108,7 @@ static void connect_cb(uv_connect_t* req, int status) {
/* |status| should equal 0 because the connection should have been accepted,
* it's just that the server immediately closes it again.
*/
ASSERT(0 == status);
ASSERT_OK(status);
connect_cb_called += 1;
uv_close((uv_handle_t*) &server_handle, NULL);
uv_close((uv_handle_t*) &client_handle, NULL);

68
deps/libuv/test/test-env-vars.c vendored
View File

@ -35,83 +35,83 @@ TEST_IMPL(env_vars) {
/* Reject invalid inputs when setting an environment variable */
r = uv_os_setenv(NULL, "foo");
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_os_setenv(name, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_os_setenv(NULL, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
/* Reject invalid inputs when retrieving an environment variable */
size = BUF_SIZE;
r = uv_os_getenv(NULL, buf, &size);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_os_getenv(name, NULL, &size);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_os_getenv(name, buf, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
size = 0;
r = uv_os_getenv(name, buf, &size);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
/* Reject invalid inputs when deleting an environment variable */
r = uv_os_unsetenv(NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
/* Successfully set an environment variable */
r = uv_os_setenv(name, "123456789");
ASSERT(r == 0);
ASSERT_OK(r);
/* Successfully read an environment variable */
size = BUF_SIZE;
buf[0] = '\0';
r = uv_os_getenv(name, buf, &size);
ASSERT(r == 0);
ASSERT(strcmp(buf, "123456789") == 0);
ASSERT(size == BUF_SIZE - 1);
ASSERT_OK(r);
ASSERT_OK(strcmp(buf, "123456789"));
ASSERT_EQ(size, BUF_SIZE - 1);
/* Return UV_ENOBUFS if the buffer cannot hold the environment variable */
size = BUF_SIZE - 1;
buf[0] = '\0';
r = uv_os_getenv(name, buf, &size);
ASSERT(r == UV_ENOBUFS);
ASSERT(size == BUF_SIZE);
ASSERT_EQ(r, UV_ENOBUFS);
ASSERT_EQ(size, BUF_SIZE);
/* Successfully delete an environment variable */
r = uv_os_unsetenv(name);
ASSERT(r == 0);
ASSERT_OK(r);
/* Return UV_ENOENT retrieving an environment variable that does not exist */
r = uv_os_getenv(name, buf, &size);
ASSERT(r == UV_ENOENT);
ASSERT_EQ(r, UV_ENOENT);
/* Successfully delete an environment variable that does not exist */
r = uv_os_unsetenv(name);
ASSERT(r == 0);
ASSERT_OK(r);
/* Setting an environment variable to the empty string does not delete it. */
r = uv_os_setenv(name, "");
ASSERT(r == 0);
ASSERT_OK(r);
size = BUF_SIZE;
r = uv_os_getenv(name, buf, &size);
ASSERT(r == 0);
ASSERT(size == 0);
ASSERT(strlen(buf) == 0);
ASSERT_OK(r);
ASSERT_OK(size);
ASSERT_OK(strlen(buf));
/* Check getting all env variables. */
r = uv_os_setenv(name, "123456789");
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_os_setenv(name2, "");
ASSERT(r == 0);
ASSERT_OK(r);
#ifdef _WIN32
/* Create a special environment variable on Windows in case there are no
naturally occurring ones. */
r = uv_os_setenv("=Z:", "\\");
ASSERT(r == 0);
ASSERT_OK(r);
#endif
r = uv_os_environ(&envitems, &envcount);
ASSERT(r == 0);
ASSERT(envcount > 0);
ASSERT_OK(r);
ASSERT_GT(envcount, 0);
found = 0;
found_win_special = 0;
@ -120,16 +120,16 @@ TEST_IMPL(env_vars) {
/* printf("Env: %s = %s\n", envitems[i].name, envitems[i].value); */
if (strcmp(envitems[i].name, name) == 0) {
found++;
ASSERT(strcmp(envitems[i].value, "123456789") == 0);
ASSERT_OK(strcmp(envitems[i].value, "123456789"));
} else if (strcmp(envitems[i].name, name2) == 0) {
found++;
ASSERT(strlen(envitems[i].value) == 0);
ASSERT_OK(strlen(envitems[i].value));
} else if (envitems[i].name[0] == '=') {
found_win_special++;
}
}
ASSERT(found == 2);
ASSERT_EQ(2, found);
#ifdef _WIN32
ASSERT_GT(found_win_special, 0);
#else
@ -140,10 +140,10 @@ TEST_IMPL(env_vars) {
uv_os_free_environ(envitems, envcount);
r = uv_os_unsetenv(name);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_os_unsetenv(name2);
ASSERT(r == 0);
ASSERT_OK(r);
for (i = 1; i <= 4; i++) {
size_t n;
@ -158,14 +158,14 @@ TEST_IMPL(env_vars) {
memset(p, 'x', n);
p[n] = '\0';
ASSERT_EQ(0, uv_os_setenv(name, p));
ASSERT_EQ(0, uv_os_getenv(name, p, &size));
ASSERT_OK(uv_os_setenv(name, p));
ASSERT_OK(uv_os_getenv(name, p, &size));
ASSERT_EQ(n, size);
for (n = 0; n < size; n++)
ASSERT_EQ('x', p[n]);
ASSERT_EQ(0, uv_os_unsetenv(name));
ASSERT_OK(uv_os_unsetenv(name));
free(p);
}

26
deps/libuv/test/test-error.c vendored
View File

@ -51,8 +51,8 @@ TEST_IMPL(error_message) {
}
ASSERT_NULL(strstr(uv_strerror(UV_EINVAL), "Success"));
ASSERT(strcmp(uv_strerror(1337), "Unknown error") == 0);
ASSERT(strcmp(uv_strerror(-1337), "Unknown error") == 0);
ASSERT_OK(strcmp(uv_strerror(1337), "Unknown error"));
ASSERT_OK(strcmp(uv_strerror(-1337), "Unknown error"));
ASSERT_NULL(strstr(uv_strerror_r(UV_EINVAL, buf, sizeof(buf)), "Success"));
ASSERT_NOT_NULL(strstr(uv_strerror_r(1337, buf, sizeof(buf)), "1337"));
@ -64,19 +64,19 @@ TEST_IMPL(error_message) {
TEST_IMPL(sys_error) {
#if defined(_WIN32)
ASSERT(uv_translate_sys_error(ERROR_NOACCESS) == UV_EACCES);
ASSERT(uv_translate_sys_error(ERROR_ELEVATION_REQUIRED) == UV_EACCES);
ASSERT(uv_translate_sys_error(WSAEADDRINUSE) == UV_EADDRINUSE);
ASSERT(uv_translate_sys_error(ERROR_BAD_PIPE) == UV_EPIPE);
ASSERT_EQ(uv_translate_sys_error(ERROR_NOACCESS), UV_EACCES);
ASSERT_EQ(uv_translate_sys_error(ERROR_ELEVATION_REQUIRED), UV_EACCES);
ASSERT_EQ(uv_translate_sys_error(WSAEADDRINUSE), UV_EADDRINUSE);
ASSERT_EQ(uv_translate_sys_error(ERROR_BAD_PIPE), UV_EPIPE);
#else
ASSERT(uv_translate_sys_error(EPERM) == UV_EPERM);
ASSERT(uv_translate_sys_error(EPIPE) == UV_EPIPE);
ASSERT(uv_translate_sys_error(EINVAL) == UV_EINVAL);
ASSERT_EQ(uv_translate_sys_error(EPERM), UV_EPERM);
ASSERT_EQ(uv_translate_sys_error(EPIPE), UV_EPIPE);
ASSERT_EQ(uv_translate_sys_error(EINVAL), UV_EINVAL);
#endif
ASSERT(uv_translate_sys_error(UV_EINVAL) == UV_EINVAL);
ASSERT(uv_translate_sys_error(UV_ERANGE) == UV_ERANGE);
ASSERT(uv_translate_sys_error(UV_EACCES) == UV_EACCES);
ASSERT(uv_translate_sys_error(0) == 0);
ASSERT_EQ(uv_translate_sys_error(UV_EINVAL), UV_EINVAL);
ASSERT_EQ(uv_translate_sys_error(UV_ERANGE), UV_ERANGE);
ASSERT_EQ(uv_translate_sys_error(UV_EACCES), UV_EACCES);
ASSERT_OK(uv_translate_sys_error(0));
return 0;
}

257
deps/libuv/test/test-fork.c vendored
View File

@ -51,12 +51,12 @@ static char socket_cb_read_buf[1024];
static void socket_cb(uv_poll_t* poll, int status, int events) {
ssize_t cnt;
socket_cb_called++;
ASSERT(0 == status);
ASSERT_OK(status);
printf("Socket cb got events %d\n", events);
ASSERT(UV_READABLE == (events & UV_READABLE));
ASSERT_EQ(UV_READABLE, (events & UV_READABLE));
if (socket_cb_read_fd) {
cnt = read(socket_cb_read_fd, socket_cb_read_buf, socket_cb_read_size);
ASSERT(cnt == socket_cb_read_size);
ASSERT_EQ(cnt, socket_cb_read_size);
}
uv_close((uv_handle_t*) poll, NULL);
}
@ -66,15 +66,15 @@ static void run_timer_loop_once(void) {
uv_loop_t loop;
uv_timer_t timer_handle;
ASSERT_EQ(0, uv_loop_init(&loop));
ASSERT_OK(uv_loop_init(&loop));
timer_cb_called = 0; /* Reset for the child. */
ASSERT(0 == uv_timer_init(&loop, &timer_handle));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 1, 0));
ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT));
ASSERT(1 == timer_cb_called);
ASSERT_EQ(0, uv_loop_close(&loop));
ASSERT_OK(uv_timer_init(&loop, &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1, 0));
ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
ASSERT_EQ(1, timer_cb_called);
ASSERT_OK(uv_loop_close(&loop));
}
@ -87,10 +87,10 @@ static void assert_wait_child(pid_t child_pid) {
if (waited_pid == -1) {
perror("Failed to wait");
}
ASSERT(child_pid == waited_pid);
ASSERT_EQ(child_pid, waited_pid);
ASSERT(WIFEXITED(child_stat)); /* Clean exit, not a signal. */
ASSERT(!WIFSIGNALED(child_stat));
ASSERT(0 == WEXITSTATUS(child_stat));
ASSERT_OK(WEXITSTATUS(child_stat));
}
@ -109,14 +109,14 @@ TEST_IMPL(fork_timer) {
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* parent */
assert_wait_child(child_pid);
} else {
/* child */
ASSERT(0 == uv_loop_fork(uv_default_loop()));
ASSERT_OK(uv_loop_fork(uv_default_loop()));
run_timer_loop_once();
}
@ -135,30 +135,30 @@ TEST_IMPL(fork_socketpair) {
/* Prime the loop. */
run_timer_loop_once();
ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds));
ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds));
/* Create the server watcher in the parent, use it in the child. */
ASSERT(0 == uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0]));
ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0]));
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
child_pid = -1;
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* parent */
ASSERT(3 == send(socket_fds[1], "hi\n", 3, 0));
ASSERT_EQ(3, send(socket_fds[1], "hi\n", 3, 0));
assert_wait_child(child_pid);
} else {
/* child */
ASSERT(0 == uv_loop_fork(uv_default_loop()));
ASSERT(0 == socket_cb_called);
ASSERT(0 == uv_poll_start(&poll_handle, UV_READABLE, socket_cb));
ASSERT_OK(uv_loop_fork(uv_default_loop()));
ASSERT_OK(socket_cb_called);
ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, socket_cb));
printf("Going to run the loop in the child\n");
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(1 == socket_cb_called);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(1, socket_cb_called);
}
MAKE_VALGRIND_HAPPY(uv_default_loop());
@ -176,57 +176,57 @@ TEST_IMPL(fork_socketpair_started) {
char sync_buf[1];
uv_poll_t poll_handle;
ASSERT(0 == pipe(sync_pipe));
ASSERT_OK(pipe(sync_pipe));
/* Prime the loop. */
run_timer_loop_once();
ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds));
ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds));
/* Create and start the server watcher in the parent, use it in the child. */
ASSERT(0 == uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0]));
ASSERT(0 == uv_poll_start(&poll_handle, UV_READABLE, socket_cb));
ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0]));
ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, socket_cb));
/* Run the loop AFTER the poll watcher is registered to make sure it
gets passed to the kernel. Use NOWAIT and expect a non-zero
return to prove the poll watcher is active.
*/
ASSERT(1 == uv_run(uv_default_loop(), UV_RUN_NOWAIT));
ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_NOWAIT));
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
child_pid = -1;
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* parent */
ASSERT(0 == uv_poll_stop(&poll_handle));
ASSERT_OK(uv_poll_stop(&poll_handle));
uv_close((uv_handle_t*)&poll_handle, NULL);
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(0 == socket_cb_called);
ASSERT(1 == write(sync_pipe[1], "1", 1)); /* alert child */
ASSERT(3 == send(socket_fds[1], "hi\n", 3, 0));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(socket_cb_called);
ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert child */
ASSERT_EQ(3, send(socket_fds[1], "hi\n", 3, 0));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(0 == socket_cb_called);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(socket_cb_called);
assert_wait_child(child_pid);
} else {
/* child */
printf("Child is %d\n", getpid());
ASSERT(1 == read(sync_pipe[0], sync_buf, 1)); /* wait for parent */
ASSERT(0 == uv_loop_fork(uv_default_loop()));
ASSERT(0 == socket_cb_called);
ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for parent */
ASSERT_OK(uv_loop_fork(uv_default_loop()));
ASSERT_OK(socket_cb_called);
printf("Going to run the loop in the child\n");
socket_cb_read_fd = socket_fds[0];
socket_cb_read_size = 3;
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(1 == socket_cb_called);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(1, socket_cb_called);
printf("Buf %s\n", socket_cb_read_buf);
ASSERT(0 == strcmp("hi\n", socket_cb_read_buf));
ASSERT_OK(strcmp("hi\n", socket_cb_read_buf));
}
MAKE_VALGRIND_HAPPY(uv_default_loop());
@ -253,41 +253,43 @@ TEST_IMPL(fork_signal_to_child) {
fork_signal_cb_called = 0; /* reset */
ASSERT(0 == pipe(sync_pipe));
ASSERT_OK(pipe(sync_pipe));
/* Prime the loop. */
run_timer_loop_once();
ASSERT(0 == uv_signal_init(uv_default_loop(), &signal_handle));
ASSERT(0 == uv_signal_start(&signal_handle, fork_signal_to_child_cb, SIGUSR1));
ASSERT_OK(uv_signal_init(uv_default_loop(), &signal_handle));
ASSERT_OK(uv_signal_start(&signal_handle,
fork_signal_to_child_cb,
SIGUSR1));
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
child_pid = -1;
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* parent */
ASSERT(1 == read(sync_pipe[0], sync_buf, 1)); /* wait for child */
ASSERT(0 == kill(child_pid, SIGUSR1));
ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for child */
ASSERT_OK(kill(child_pid, SIGUSR1));
/* Run the loop, make sure we don't get the signal. */
printf("Running loop in parent\n");
uv_unref((uv_handle_t*)&signal_handle);
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_NOWAIT));
ASSERT(0 == fork_signal_cb_called);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_NOWAIT));
ASSERT_OK(fork_signal_cb_called);
printf("Waiting for child in parent\n");
assert_wait_child(child_pid);
} else {
/* child */
ASSERT(0 == uv_loop_fork(uv_default_loop()));
ASSERT(1 == write(sync_pipe[1], "1", 1)); /* alert parent */
ASSERT_OK(uv_loop_fork(uv_default_loop()));
ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert parent */
/* Get the signal. */
ASSERT(0 != uv_loop_alive(uv_default_loop()));
ASSERT_NE(0, uv_loop_alive(uv_default_loop()));
printf("Running loop in child\n");
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT(SIGUSR1 == fork_signal_cb_called);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT_EQ(SIGUSR1, fork_signal_cb_called);
}
MAKE_VALGRIND_HAPPY(uv_default_loop());
@ -308,47 +310,49 @@ TEST_IMPL(fork_signal_to_child_closed) {
fork_signal_cb_called = 0; /* reset */
ASSERT(0 == pipe(sync_pipe));
ASSERT(0 == pipe(sync_pipe2));
ASSERT_OK(pipe(sync_pipe));
ASSERT_OK(pipe(sync_pipe2));
/* Prime the loop. */
run_timer_loop_once();
ASSERT(0 == uv_signal_init(uv_default_loop(), &signal_handle));
ASSERT(0 == uv_signal_start(&signal_handle, fork_signal_to_child_cb, SIGUSR1));
ASSERT_OK(uv_signal_init(uv_default_loop(), &signal_handle));
ASSERT_OK(uv_signal_start(&signal_handle,
fork_signal_to_child_cb,
SIGUSR1));
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
child_pid = -1;
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* parent */
printf("Wating on child in parent\n");
ASSERT(1 == read(sync_pipe[0], sync_buf, 1)); /* wait for child */
ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for child */
printf("Parent killing child\n");
ASSERT(0 == kill(child_pid, SIGUSR1));
ASSERT_OK(kill(child_pid, SIGUSR1));
/* Run the loop, make sure we don't get the signal. */
printf("Running loop in parent\n");
uv_unref((uv_handle_t*)&signal_handle); /* so the loop can exit;
we *shouldn't* get any signals */
run_timer_loop_once(); /* but while we share a pipe, we do, so
have something active. */
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
printf("Signal in parent %d\n", fork_signal_cb_called);
ASSERT(0 == fork_signal_cb_called);
ASSERT(1 == write(sync_pipe2[1], "1", 1)); /* alert child */
ASSERT_OK(fork_signal_cb_called);
ASSERT_EQ(1, write(sync_pipe2[1], "1", 1)); /* alert child */
printf("Waiting for child in parent\n");
assert_wait_child(child_pid);
} else {
/* Child. Our signal handler should still be installed. */
ASSERT(0 == uv_loop_fork(uv_default_loop()));
ASSERT_OK(uv_loop_fork(uv_default_loop()));
printf("Checking loop in child\n");
ASSERT(0 != uv_loop_alive(uv_default_loop()));
ASSERT_NE(0, uv_loop_alive(uv_default_loop()));
printf("Alerting parent in child\n");
ASSERT(1 == write(sync_pipe[1], "1", 1)); /* alert parent */
ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert parent */
/* Don't run the loop. Wait for the parent to call us */
printf("Waiting on parent in child\n");
/* Wait for parent. read may fail if the parent tripped an ASSERT
@ -356,7 +360,7 @@ TEST_IMPL(fork_signal_to_child_closed) {
*/
r = read(sync_pipe2[0], sync_buf, 1);
ASSERT(-1 <= r && r <= 1);
ASSERT(0 == fork_signal_cb_called);
ASSERT_OK(fork_signal_cb_called);
printf("Exiting child \n");
/* Note that we're deliberately not running the loop
* in the child, and also not closing the loop's handles,
@ -371,6 +375,47 @@ TEST_IMPL(fork_signal_to_child_closed) {
return 0;
}
static void fork_signal_cb(uv_signal_t* h, int s) {
fork_signal_cb_called = s;
}
static void empty_close_cb(uv_handle_t* h){}
TEST_IMPL(fork_close_signal_in_child) {
uv_loop_t loop;
uv_signal_t signal_handle;
pid_t child_pid;
ASSERT_OK(uv_loop_init(&loop));
ASSERT_OK(uv_signal_init(&loop, &signal_handle));
ASSERT_OK(uv_signal_start(&signal_handle, &fork_signal_cb, SIGHUP));
ASSERT_OK(kill(getpid(), SIGHUP));
child_pid = fork();
ASSERT_NE(child_pid, -1);
ASSERT_OK(fork_signal_cb_called);
if (!child_pid) {
uv_loop_fork(&loop);
uv_close((uv_handle_t*)&signal_handle, &empty_close_cb);
uv_run(&loop, UV_RUN_DEFAULT);
/* Child doesn't receive the signal */
ASSERT_OK(fork_signal_cb_called);
} else {
/* Parent. Runing once to receive the signal */
uv_run(&loop, UV_RUN_ONCE);
ASSERT_EQ(SIGHUP, fork_signal_cb_called);
/* loop should stop after closing the only handle */
uv_close((uv_handle_t*)&signal_handle, &empty_close_cb);
ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
assert_wait_child(child_pid);
}
MAKE_VALGRIND_HAPPY(&loop);
return 0;
}
static void create_file(const char* name) {
int r;
@ -378,11 +423,11 @@ static void create_file(const char* name) {
uv_fs_t req;
r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
file = r;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, file, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
@ -394,17 +439,17 @@ static void touch_file(const char* name) {
uv_buf_t buf;
r = uv_fs_open(NULL, &req, name, O_RDWR, 0, NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
file = r;
uv_fs_req_cleanup(&req);
buf = uv_buf_init("foo", 4);
r = uv_fs_write(NULL, &req, file, &buf, 1, -1, NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, file, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
@ -424,11 +469,11 @@ static void fs_event_cb_file_current_dir(uv_fs_event_t* handle,
const char* filename,
int events,
int status) {
ASSERT(fs_event_cb_called == 0);
ASSERT_OK(fs_event_cb_called);
++fs_event_cb_called;
ASSERT(status == 0);
ASSERT_OK(status);
#if defined(__APPLE__) || defined(__linux__)
ASSERT(strcmp(filename, "watch_file") == 0);
ASSERT_OK(strcmp(filename, "watch_file"));
#else
ASSERT(filename == NULL || strcmp(filename, "watch_file") == 0);
#endif
@ -446,28 +491,28 @@ static void assert_watch_file_current_dir(uv_loop_t* const loop, int file_or_dir
create_file("watch_file");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
/* watching a dir is the only way to get fsevents involved on apple
platforms */
r = uv_fs_event_start(&fs_event,
fs_event_cb_file_current_dir,
file_or_dir == 1 ? "." : "watch_file",
0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, timer_cb_touch, 100, 0);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(timer_cb_touch_called == 0);
ASSERT(fs_event_cb_called == 0);
ASSERT_OK(timer_cb_touch_called);
ASSERT_OK(fs_event_cb_called);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(timer_cb_touch_called == 1);
ASSERT(fs_event_cb_called == 1);
ASSERT_EQ(1, timer_cb_touch_called);
ASSERT_EQ(1, fs_event_cb_called);
/* Cleanup */
remove("watch_file");
@ -492,7 +537,7 @@ static int _do_fork_fs_events_child(int file_or_dir) {
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* parent */
@ -508,10 +553,10 @@ static int _do_fork_fs_events_child(int file_or_dir) {
uv_loop_init(&loop);
printf("Child first watch\n");
assert_watch_file_current_dir(&loop, file_or_dir);
ASSERT(0 == uv_loop_close(&loop));
ASSERT_OK(uv_loop_close(&loop));
printf("Child second watch default loop\n");
/* Ee can watch in the default loop. */
ASSERT(0 == uv_loop_fork(uv_default_loop()));
ASSERT_OK(uv_loop_fork(uv_default_loop()));
/* On some platforms (OS X), if we don't update the time now,
* the timer cb fires before the event loop enters uv__io_poll,
* instead of after, meaning we don't see the change! This may be
@ -524,7 +569,7 @@ static int _do_fork_fs_events_child(int file_or_dir) {
especially important on Apple platforms where if we're not
careful trying to touch the CFRunLoop, even just to shut it
down, that we allocated in the FS_TEST_DIR case would crash. */
ASSERT(0 == uv_loop_close(uv_default_loop()));
ASSERT_OK(uv_loop_close(uv_default_loop()));
printf("Exiting child \n");
}
@ -587,40 +632,40 @@ TEST_IMPL(fork_fs_events_file_parent_child) {
create_file("watch_file");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event,
fs_event_cb_file_current_dir,
"watch_file",
0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
child_pid = -1;
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* parent */
assert_wait_child(child_pid);
} else {
/* child */
printf("Running child\n");
ASSERT(0 == uv_loop_fork(loop));
ASSERT_OK(uv_loop_fork(loop));
r = uv_timer_start(&timer, timer_cb_touch, 100, 0);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(timer_cb_touch_called == 0);
ASSERT(fs_event_cb_called == 0);
ASSERT_OK(timer_cb_touch_called);
ASSERT_OK(fs_event_cb_called);
printf("Running loop in child \n");
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(timer_cb_touch_called == 1);
ASSERT(fs_event_cb_called == 1);
ASSERT_EQ(1, timer_cb_touch_called);
ASSERT_EQ(1, fs_event_cb_called);
/* Cleanup */
remove("watch_file");
@ -646,7 +691,7 @@ static void work_cb(uv_work_t* req) {
static void after_work_cb(uv_work_t* req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
after_work_cb_count++;
}
@ -655,16 +700,16 @@ static void assert_run_work(uv_loop_t* const loop) {
uv_work_t work_req;
int r;
ASSERT(work_cb_count == 0);
ASSERT(after_work_cb_count == 0);
ASSERT_OK(work_cb_count);
ASSERT_OK(after_work_cb_count);
printf("Queue in %d\n", getpid());
r = uv_queue_work(loop, &work_req, work_cb, after_work_cb);
ASSERT(r == 0);
ASSERT_OK(r);
printf("Running in %d\n", getpid());
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(work_cb_count == 1);
ASSERT(after_work_cb_count == 1);
ASSERT_EQ(1, work_cb_count);
ASSERT_EQ(1, after_work_cb_count);
/* cleanup */
work_cb_count = 0;
@ -691,7 +736,7 @@ TEST_IMPL(fork_threadpool_queue_work_simple) {
#else
child_pid = fork();
#endif
ASSERT(child_pid != -1);
ASSERT_NE(child_pid, -1);
if (child_pid != 0) {
/* Parent. We can still run work. */
@ -706,7 +751,7 @@ TEST_IMPL(fork_threadpool_queue_work_simple) {
uv_loop_close(&loop);
printf("Child second watch default loop\n");
/* We can work in the default loop. */
ASSERT(0 == uv_loop_fork(uv_default_loop()));
ASSERT_OK(uv_loop_fork(uv_default_loop()));
assert_run_work(uv_default_loop());
printf("Exiting child \n");
}

66
deps/libuv/test/test-fs-copyfile.c vendored
View File

@ -48,19 +48,19 @@ static void handle_result(uv_fs_t* req) {
uint64_t mode;
int r;
ASSERT(req->fs_type == UV_FS_COPYFILE);
ASSERT(req->result == 0);
ASSERT_EQ(req->fs_type, UV_FS_COPYFILE);
ASSERT_OK(req->result);
/* Verify that the file size and mode are the same. */
r = uv_fs_stat(NULL, &stat_req, req->path, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
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);
ASSERT_OK(r);
ASSERT_EQ(stat_req.statbuf.st_size, size);
ASSERT_EQ(stat_req.statbuf.st_mode, mode);
uv_fs_req_cleanup(&stat_req);
uv_fs_req_cleanup(req);
result_check_count++;
@ -77,7 +77,7 @@ static void touch_file(const char* name, unsigned int size) {
r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT | O_TRUNC,
S_IWUSR | S_IRUSR, NULL);
uv_fs_req_cleanup(&req);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
file = r;
buf = uv_buf_init("a", 1);
@ -86,12 +86,12 @@ static void touch_file(const char* name, unsigned int size) {
for (i = 0; i < size; i++) {
r = uv_fs_write(NULL, &req, file, &buf, 1, i, NULL);
uv_fs_req_cleanup(&req);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
}
r = uv_fs_close(NULL, &req, file, NULL);
uv_fs_req_cleanup(&req);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -105,102 +105,102 @@ TEST_IMPL(fs_copyfile) {
/* Fails with EINVAL if bad flags are passed. */
r = uv_fs_copyfile(NULL, &req, src, dst, -1, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
uv_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);
ASSERT_EQ(req.result, UV_ENOENT);
ASSERT_EQ(r, UV_ENOENT);
uv_fs_req_cleanup(&req);
/* The destination should not exist. */
r = uv_fs_stat(NULL, &req, dst, NULL);
ASSERT(r != 0);
ASSERT(r);
uv_fs_req_cleanup(&req);
/* Succeeds if src and dst files are identical. */
touch_file(src, 12);
r = uv_fs_copyfile(NULL, &req, src, src, 0, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
/* Verify that the src file did not get truncated. */
r = uv_fs_stat(NULL, &req, src, NULL);
ASSERT_EQ(r, 0);
ASSERT_EQ(req.statbuf.st_size, 12);
ASSERT_OK(r);
ASSERT_EQ(12, req.statbuf.st_size);
uv_fs_req_cleanup(&req);
unlink(src);
/* Copies file synchronously. Creates new file. */
unlink(dst);
r = uv_fs_copyfile(NULL, &req, fixture, dst, 0, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
handle_result(&req);
/* Copies a file of size zero. */
unlink(dst);
touch_file(src, 0);
r = uv_fs_copyfile(NULL, &req, src, dst, 0, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
handle_result(&req);
/* Copies file synchronously. Overwrites existing file. */
r = uv_fs_copyfile(NULL, &req, fixture, dst, 0, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
handle_result(&req);
/* Fails to overwrites existing file. */
ASSERT_EQ(uv_fs_chmod(NULL, &req, dst, 0644, NULL), 0);
ASSERT_OK(uv_fs_chmod(NULL, &req, dst, 0644, NULL));
uv_fs_req_cleanup(&req);
r = uv_fs_copyfile(NULL, &req, fixture, dst, UV_FS_COPYFILE_EXCL, NULL);
ASSERT(r == UV_EEXIST);
ASSERT_EQ(r, UV_EEXIST);
uv_fs_req_cleanup(&req);
/* Truncates when an existing destination is larger than the source file. */
ASSERT_EQ(uv_fs_chmod(NULL, &req, dst, 0644, NULL), 0);
ASSERT_OK(uv_fs_chmod(NULL, &req, dst, 0644, NULL));
uv_fs_req_cleanup(&req);
touch_file(src, 1);
r = uv_fs_copyfile(NULL, &req, src, dst, 0, NULL);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
handle_result(&req);
/* Copies a larger file. */
unlink(dst);
touch_file(src, 4096 * 2);
r = uv_fs_copyfile(NULL, &req, src, dst, 0, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
handle_result(&req);
unlink(src);
/* Copies file asynchronously */
unlink(dst);
r = uv_fs_copyfile(loop, &req, fixture, dst, 0, handle_result);
ASSERT(r == 0);
ASSERT(result_check_count == 5);
ASSERT_OK(r);
ASSERT_EQ(5, result_check_count);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(result_check_count == 6);
ASSERT_EQ(6, result_check_count);
/* Ensure file is user-writable (not copied from src). */
ASSERT_EQ(uv_fs_chmod(NULL, &req, dst, 0644, NULL), 0);
ASSERT_OK(uv_fs_chmod(NULL, &req, dst, 0644, NULL));
uv_fs_req_cleanup(&req);
/* If the flags are invalid, the loop should not be kept open */
unlink(dst);
r = uv_fs_copyfile(loop, &req, fixture, dst, -1, fail_cb);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
uv_run(loop, UV_RUN_DEFAULT);
/* Copies file using UV_FS_COPYFILE_FICLONE. */
unlink(dst);
r = uv_fs_copyfile(NULL, &req, fixture, dst, UV_FS_COPYFILE_FICLONE, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
handle_result(&req);
/* Copies file using UV_FS_COPYFILE_FICLONE_FORCE. */
unlink(dst);
r = uv_fs_copyfile(NULL, &req, fixture, dst, UV_FS_COPYFILE_FICLONE_FORCE,
NULL);
ASSERT(r <= 0);
ASSERT_LE(r, 0);
if (r == 0)
handle_result(&req);
@ -213,8 +213,8 @@ TEST_IMPL(fs_copyfile) {
r = uv_fs_copyfile(NULL, &req, fixture, dst, 0, NULL);
/* On IBMi PASE, qsecofr users can overwrite read-only files */
# ifndef __PASE__
ASSERT(req.result == UV_EACCES);
ASSERT(r == UV_EACCES);
ASSERT_EQ(req.result, UV_EACCES);
ASSERT_EQ(r, UV_EACCES);
# endif
uv_fs_req_cleanup(&req);
#endif

355
deps/libuv/test/test-fs-event.c vendored
View File

@ -81,11 +81,11 @@ static void create_file(const char* name) {
uv_fs_t req;
r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
file = r;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, file, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
@ -96,17 +96,17 @@ static void touch_file(const char* name) {
uv_buf_t buf;
r = uv_fs_open(NULL, &req, name, O_RDWR, 0, NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
file = r;
uv_fs_req_cleanup(&req);
buf = uv_buf_init("foo", 4);
r = uv_fs_write(NULL, &req, file, &buf, 1, -1, NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, file, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
@ -125,15 +125,15 @@ static void fail_cb(uv_fs_event_t* handle,
static void fs_event_cb_dir(uv_fs_event_t* handle, const char* filename,
int events, int status) {
++fs_event_cb_called;
ASSERT(handle == &fs_event);
ASSERT(status == 0);
ASSERT(events == UV_CHANGE);
ASSERT_PTR_EQ(handle, &fs_event);
ASSERT_OK(status);
ASSERT_EQ(events, UV_CHANGE);
#if defined(__APPLE__) || defined(_WIN32) || defined(__linux__)
ASSERT(strcmp(filename, "file1") == 0);
ASSERT_OK(strcmp(filename, "file1"));
#else
ASSERT(filename == NULL || strcmp(filename, "file1") == 0);
#endif
ASSERT(0 == uv_fs_event_stop(handle));
ASSERT_OK(uv_fs_event_stop(handle));
uv_close((uv_handle_t*)handle, close_cb);
}
@ -148,7 +148,7 @@ static const char* fs_event_get_filename(int i) {
static void fs_event_create_files(uv_timer_t* handle) {
/* Make sure we're not attempting to create files we do not intend */
ASSERT(fs_event_created < fs_event_file_count);
ASSERT_LT(fs_event_created, fs_event_file_count);
/* Create the file */
create_file(fs_event_get_filename(fs_event_created));
@ -156,7 +156,7 @@ static void fs_event_create_files(uv_timer_t* handle) {
if (++fs_event_created < fs_event_file_count) {
/* Create another file on a different event loop tick. We do it this way
* to avoid fs events coalescing into one fs event. */
ASSERT_EQ(0, uv_timer_start(&timer, fs_event_create_files, 100, 0));
ASSERT_OK(uv_timer_start(&timer, fs_event_create_files, 100, 0));
}
}
@ -170,19 +170,19 @@ static void fs_event_unlink_files(uv_timer_t* handle) {
for (i = 0; i < 16; i++) {
r = remove(fs_event_get_filename(i));
if (handle != NULL)
ASSERT(r == 0);
ASSERT_OK(r);
}
} else {
/* Make sure we're not attempting to remove files we do not intend */
ASSERT(fs_event_removed < fs_event_file_count);
ASSERT_LT(fs_event_removed, fs_event_file_count);
/* Remove the file */
ASSERT(0 == remove(fs_event_get_filename(fs_event_removed)));
ASSERT_OK(remove(fs_event_get_filename(fs_event_removed)));
if (++fs_event_removed < fs_event_file_count) {
/* Remove another file on a different event loop tick. We do it this way
* to avoid fs events coalescing into one fs event. */
ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files, 1, 0));
ASSERT_OK(uv_timer_start(&timer, fs_event_unlink_files, 1, 0));
}
}
}
@ -192,19 +192,19 @@ static void fs_event_cb_dir_multi_file(uv_fs_event_t* handle,
int events,
int status) {
fs_event_cb_called++;
ASSERT(handle == &fs_event);
ASSERT(status == 0);
ASSERT_PTR_EQ(handle, &fs_event);
ASSERT_OK(status);
ASSERT(events == UV_CHANGE || events == UV_RENAME);
#if defined(__APPLE__) || defined(_WIN32) || defined(__linux__)
ASSERT(strncmp(filename, file_prefix, sizeof(file_prefix) - 1) == 0);
ASSERT_OK(strncmp(filename, file_prefix, sizeof(file_prefix) - 1));
#else
ASSERT(filename == NULL ||
strncmp(filename, file_prefix, sizeof(file_prefix) - 1) == 0);
ASSERT_NE(filename == NULL ||
strncmp(filename, file_prefix, sizeof(file_prefix) - 1) == 0, 0);
#endif
if (fs_event_created + fs_event_removed == fs_event_file_count) {
/* Once we've processed all create events, delete all files */
ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files, 1, 0));
ASSERT_OK(uv_timer_start(&timer, fs_event_unlink_files, 1, 0));
} else if (fs_event_cb_called == 2 * fs_event_file_count) {
/* Once we've processed all create and delete events, stop watching */
uv_close((uv_handle_t*) &timer, close_cb);
@ -224,7 +224,7 @@ static const char* fs_event_get_filename_in_subdir(int i) {
static void fs_event_create_files_in_subdir(uv_timer_t* handle) {
/* Make sure we're not attempting to create files we do not intend */
ASSERT(fs_event_created < fs_event_file_count);
ASSERT_LT(fs_event_created, fs_event_file_count);
/* Create the file */
create_file(fs_event_get_filename_in_subdir(fs_event_created));
@ -232,8 +232,7 @@ static void fs_event_create_files_in_subdir(uv_timer_t* handle) {
if (++fs_event_created < fs_event_file_count) {
/* Create another file on a different event loop tick. We do it this way
* to avoid fs events coalescing into one fs event. */
ASSERT_EQ(0,
uv_timer_start(&timer, fs_event_create_files_in_subdir, 100, 0));
ASSERT_OK(uv_timer_start(&timer, fs_event_create_files_in_subdir, 100, 0));
}
}
@ -247,19 +246,22 @@ static void fs_event_unlink_files_in_subdir(uv_timer_t* handle) {
for (i = 0; i < 16; i++) {
r = remove(fs_event_get_filename_in_subdir(i));
if (handle != NULL)
ASSERT(r == 0);
ASSERT_OK(r);
}
} else {
/* Make sure we're not attempting to remove files we do not intend */
ASSERT(fs_event_removed < fs_event_file_count);
ASSERT_LT(fs_event_removed, fs_event_file_count);
/* Remove the file */
ASSERT(0 == remove(fs_event_get_filename_in_subdir(fs_event_removed)));
ASSERT_OK(remove(fs_event_get_filename_in_subdir(fs_event_removed)));
if (++fs_event_removed < fs_event_file_count) {
/* Remove another file on a different event loop tick. We do it this way
* to avoid fs events coalescing into one fs event. */
ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files_in_subdir, 1, 0));
ASSERT_OK(uv_timer_start(&timer,
fs_event_unlink_files_in_subdir,
1,
0));
}
}
}
@ -283,27 +285,30 @@ static void fs_event_cb_dir_multi_file_in_subdir(uv_fs_event_t* handle,
return;
fs_multievent_cb_called++;
ASSERT(handle == &fs_event);
ASSERT(status == 0);
ASSERT_PTR_EQ(handle, &fs_event);
ASSERT_OK(status);
ASSERT(events == UV_CHANGE || events == UV_RENAME);
#if defined(__APPLE__) || defined(_WIN32) || defined(__linux__)
ASSERT(strncmp(filename,
file_prefix_in_subdir,
sizeof(file_prefix_in_subdir) - 1) == 0);
ASSERT_OK(strncmp(filename,
file_prefix_in_subdir,
sizeof(file_prefix_in_subdir) - 1));
#else
ASSERT(filename == NULL ||
strncmp(filename,
file_prefix_in_subdir,
sizeof(file_prefix_in_subdir) - 1) == 0);
ASSERT_NE(filename == NULL ||
strncmp(filename,
file_prefix_in_subdir,
sizeof(file_prefix_in_subdir) - 1) == 0, 0);
#endif
if (fs_event_created == fs_event_file_count &&
fs_multievent_cb_called == fs_event_created) {
/* Once we've processed all create events, delete all files */
ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files_in_subdir, 1, 0));
ASSERT_OK(uv_timer_start(&timer,
fs_event_unlink_files_in_subdir,
1,
0));
} else if (fs_multievent_cb_called == 2 * fs_event_file_count) {
/* Once we've processed all create and delete events, stop watching */
ASSERT(fs_event_removed == fs_event_file_count);
ASSERT_EQ(fs_event_removed, fs_event_file_count);
uv_close((uv_handle_t*) &timer, close_cb);
uv_close((uv_handle_t*) handle, close_cb);
}
@ -313,15 +318,15 @@ static void fs_event_cb_dir_multi_file_in_subdir(uv_fs_event_t* handle,
static void fs_event_cb_file(uv_fs_event_t* handle, const char* filename,
int events, int status) {
++fs_event_cb_called;
ASSERT(handle == &fs_event);
ASSERT(status == 0);
ASSERT(events == UV_CHANGE);
ASSERT_PTR_EQ(handle, &fs_event);
ASSERT_OK(status);
ASSERT_EQ(events, UV_CHANGE);
#if defined(__APPLE__) || defined(_WIN32) || defined(__linux__)
ASSERT(strcmp(filename, "file2") == 0);
ASSERT_OK(strcmp(filename, "file2"));
#else
ASSERT(filename == NULL || strcmp(filename, "file2") == 0);
#endif
ASSERT(0 == uv_fs_event_stop(handle));
ASSERT_OK(uv_fs_event_stop(handle));
uv_close((uv_handle_t*)handle, close_cb);
}
@ -329,11 +334,11 @@ static void fs_event_cb_file_current_dir(uv_fs_event_t* handle,
const char* filename, int events, int status) {
++fs_event_cb_called;
ASSERT(handle == &fs_event);
ASSERT(status == 0);
ASSERT(events == UV_CHANGE);
ASSERT_PTR_EQ(handle, &fs_event);
ASSERT_OK(status);
ASSERT_EQ(events, UV_CHANGE);
#if defined(__APPLE__) || defined(_WIN32) || defined(__linux__)
ASSERT(strcmp(filename, "watch_file") == 0);
ASSERT_OK(strcmp(filename, "watch_file"));
#else
ASSERT(filename == NULL || strcmp(filename, "watch_file") == 0);
#endif
@ -366,7 +371,7 @@ static void timer_cb_exact(uv_timer_t* handle) {
} else {
uv_close((uv_handle_t*)handle, NULL);
r = uv_fs_event_stop(&fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &fs_event, NULL);
}
@ -384,9 +389,9 @@ static void fs_event_cb_close(uv_fs_event_t* handle,
const char* filename,
int events,
int status) {
ASSERT(status == 0);
ASSERT_OK(status);
ASSERT(fs_event_cb_called < 3);
ASSERT_LT(fs_event_cb_called, 3);
++fs_event_cb_called;
if (fs_event_cb_called == 3) {
@ -400,6 +405,8 @@ TEST_IMPL(fs_event_watch_dir) {
RETURN_SKIP(NO_FS_EVENTS);
#elif defined(__MVS__)
RETURN_SKIP("Directory watching not supported on this platform.");
#elif defined(__APPLE__) && defined(__TSAN__)
RETURN_SKIP("Times out under TSAN.");
#endif
uv_loop_t* loop = uv_default_loop();
@ -413,18 +420,18 @@ TEST_IMPL(fs_event_watch_dir) {
create_dir("watch_dir");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_cb_dir_multi_file, "watch_dir", 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, fs_event_create_files, 100, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(fs_event_cb_called == fs_event_created + fs_event_removed);
ASSERT(close_cb_called == 2);
ASSERT_EQ(fs_event_cb_called, fs_event_created + fs_event_removed);
ASSERT_EQ(2, close_cb_called);
/* Cleanup */
fs_event_unlink_files(NULL);
@ -438,7 +445,9 @@ TEST_IMPL(fs_event_watch_dir) {
TEST_IMPL(fs_event_watch_dir_recursive) {
#if defined(__APPLE__) || defined(_WIN32)
#if defined(__APPLE__) && defined(__TSAN__)
RETURN_SKIP("Times out under TSAN.");
#elif defined(__APPLE__) || defined(_WIN32)
uv_loop_t* loop;
int r;
uv_fs_event_t fs_event_root;
@ -454,27 +463,27 @@ TEST_IMPL(fs_event_watch_dir_recursive) {
create_dir("watch_dir/subdir");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event,
fs_event_cb_dir_multi_file_in_subdir,
"watch_dir",
UV_FS_EVENT_RECURSIVE);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, fs_event_create_files_in_subdir, 100, 0);
ASSERT(r == 0);
ASSERT_OK(r);
#ifndef _WIN32
/* Also try to watch the root directory.
* This will be noisier, so we're just checking for any couple events to happen. */
r = uv_fs_event_init(loop, &fs_event_root);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event_root,
fs_event_cb_close,
"/",
UV_FS_EVENT_RECURSIVE);
ASSERT(r == 0);
ASSERT_OK(r);
#else
fs_event_cb_called += 3;
close_cb_called += 1;
@ -483,9 +492,9 @@ TEST_IMPL(fs_event_watch_dir_recursive) {
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(fs_multievent_cb_called == fs_event_created + fs_event_removed);
ASSERT(fs_event_cb_called == 3);
ASSERT(close_cb_called == 3);
ASSERT_EQ(fs_multievent_cb_called, fs_event_created + fs_event_removed);
ASSERT_EQ(3, fs_event_cb_called);
ASSERT_EQ(3, close_cb_called);
/* Cleanup */
fs_event_unlink_files_in_subdir(NULL);
@ -522,19 +531,19 @@ TEST_IMPL(fs_event_watch_dir_short_path) {
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);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_cb_dir, "watch_~1", 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, timer_cb_file, 100, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(fs_event_cb_called == 1);
ASSERT(timer_cb_called == 1);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, fs_event_cb_called);
ASSERT_EQ(1, timer_cb_called);
ASSERT_EQ(1, close_cb_called);
}
/* Cleanup */
@ -568,19 +577,19 @@ TEST_IMPL(fs_event_watch_file) {
create_file("watch_dir/file2");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_cb_file, "watch_dir/file2", 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, timer_cb_file, 100, 100);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(fs_event_cb_called == 1);
ASSERT(timer_cb_called == 2);
ASSERT(close_cb_called == 2);
ASSERT_EQ(1, fs_event_cb_called);
ASSERT_EQ(2, timer_cb_called);
ASSERT_EQ(2, close_cb_called);
/* Cleanup */
remove("watch_dir/file2");
@ -624,16 +633,16 @@ TEST_IMPL(fs_event_watch_file_exact_path) {
#endif
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_fail, "watch_dir/file.jsx", 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, timer_cb_exact, 100, 100);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(timer_cb_exact_called == 2);
ASSERT_OK(r);
ASSERT_EQ(2, timer_cb_exact_called);
/* Cleanup */
remove("watch_dir/file.js");
@ -656,13 +665,13 @@ TEST_IMPL(fs_event_watch_file_twice) {
loop = uv_default_loop();
timer.data = watchers;
ASSERT(0 == uv_fs_event_init(loop, watchers + 0));
ASSERT(0 == uv_fs_event_start(watchers + 0, fail_cb, path, 0));
ASSERT(0 == uv_fs_event_init(loop, watchers + 1));
ASSERT(0 == uv_fs_event_start(watchers + 1, fail_cb, path, 0));
ASSERT(0 == uv_timer_init(loop, &timer));
ASSERT(0 == uv_timer_start(&timer, timer_cb_watch_twice, 10, 0));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_fs_event_init(loop, watchers + 0));
ASSERT_OK(uv_fs_event_start(watchers + 0, fail_cb, path, 0));
ASSERT_OK(uv_fs_event_init(loop, watchers + 1));
ASSERT_OK(uv_fs_event_start(watchers + 1, fail_cb, path, 0));
ASSERT_OK(uv_timer_init(loop, &timer));
ASSERT_OK(uv_timer_start(&timer, timer_cb_watch_twice, 10, 0));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
MAKE_VALGRIND_HAPPY(loop);
return 0;
@ -690,31 +699,31 @@ TEST_IMPL(fs_event_watch_file_current_dir) {
#endif
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event,
fs_event_cb_file_current_dir,
"watch_file",
0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
timer.data = "watch_file";
r = uv_timer_start(&timer, timer_cb_touch, 1100, 0);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(timer_cb_touch_called == 0);
ASSERT(fs_event_cb_called == 0);
ASSERT(close_cb_called == 0);
ASSERT_OK(timer_cb_touch_called);
ASSERT_OK(fs_event_cb_called);
ASSERT_OK(close_cb_called);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(timer_cb_touch_called == 1);
ASSERT_EQ(1, timer_cb_touch_called);
/* FSEvents on macOS sometimes sends one change event, sometimes two. */
ASSERT_NE(0, fs_event_cb_called);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
/* Cleanup */
remove("watch_file");
@ -737,11 +746,11 @@ TEST_IMPL(fs_event_watch_file_root_dir) {
loop = uv_default_loop();
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fail_cb, path, 0);
if (r == UV_ENOENT)
RETURN_SKIP("bootsect.bak doesn't exist in system root.\n");
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &fs_event, NULL);
@ -765,20 +774,20 @@ TEST_IMPL(fs_event_no_callback_after_close) {
create_file("watch_dir/file1");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event,
fs_event_cb_file,
"watch_dir/file1",
0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)&fs_event, close_cb);
touch_file("watch_dir/file1");
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(fs_event_cb_called == 0);
ASSERT(close_cb_called == 1);
ASSERT_OK(fs_event_cb_called);
ASSERT_EQ(1, close_cb_called);
/* Cleanup */
remove("watch_dir/file1");
@ -803,19 +812,19 @@ TEST_IMPL(fs_event_no_callback_on_close) {
create_file("watch_dir/file1");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event,
fs_event_cb_file,
"watch_dir/file1",
0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)&fs_event, close_cb);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(fs_event_cb_called == 0);
ASSERT(close_cb_called == 1);
ASSERT_OK(fs_event_cb_called);
ASSERT_EQ(1, close_cb_called);
/* Cleanup */
remove("watch_dir/file1");
@ -830,9 +839,9 @@ static void timer_cb(uv_timer_t* handle) {
int r;
r = uv_fs_event_init(handle->loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_fail, ".", 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)&fs_event, close_cb);
uv_close((uv_handle_t*)handle, close_cb);
@ -850,14 +859,14 @@ TEST_IMPL(fs_event_immediate_close) {
loop = uv_default_loop();
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, timer_cb, 1, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(close_cb_called == 2);
ASSERT_EQ(2, close_cb_called);
MAKE_VALGRIND_HAPPY(loop);
return 0;
@ -877,9 +886,9 @@ TEST_IMPL(fs_event_close_with_pending_event) {
create_file("watch_dir/file");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_fail, "watch_dir", 0);
ASSERT(r == 0);
ASSERT_OK(r);
/* Generate an fs event. */
touch_file("watch_dir/file");
@ -888,7 +897,7 @@ TEST_IMPL(fs_event_close_with_pending_event) {
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
/* Clean up */
remove("watch_dir/file");
@ -911,9 +920,9 @@ TEST_IMPL(fs_event_close_with_pending_delete_event) {
create_file("watch_dir/file");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_fail, "watch_dir/file", 0);
ASSERT(r == 0);
ASSERT_OK(r);
/* Generate an fs event. */
remove("watch_dir/file");
@ -927,7 +936,7 @@ TEST_IMPL(fs_event_close_with_pending_delete_event) {
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
/* Clean up */
remove("watch_dir/");
@ -941,6 +950,8 @@ TEST_IMPL(fs_event_close_in_callback) {
RETURN_SKIP(NO_FS_EVENTS);
#elif defined(__MVS__)
RETURN_SKIP("Directory watching not supported on this platform.");
#elif defined(__APPLE__) && defined(__TSAN__)
RETURN_SKIP("Times out under TSAN.");
#endif
uv_loop_t* loop;
int r;
@ -951,14 +962,14 @@ TEST_IMPL(fs_event_close_in_callback) {
create_dir("watch_dir");
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_cb_close, "watch_dir", 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(loop, &timer);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer, fs_event_create_files, 100, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(loop, UV_RUN_DEFAULT);
@ -966,8 +977,8 @@ TEST_IMPL(fs_event_close_in_callback) {
uv_run(loop, UV_RUN_ONCE);
ASSERT(close_cb_called == 2);
ASSERT(fs_event_cb_called == 3);
ASSERT_EQ(2, close_cb_called);
ASSERT_EQ(3, fs_event_cb_called);
/* Clean up */
fs_event_unlink_files(NULL);
@ -991,21 +1002,21 @@ TEST_IMPL(fs_event_start_and_close) {
create_dir("watch_dir");
r = uv_fs_event_init(loop, &fs_event1);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event1, fs_event_cb_dir, "watch_dir", 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_init(loop, &fs_event2);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event2, fs_event_cb_dir, "watch_dir", 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &fs_event2, close_cb);
uv_close((uv_handle_t*) &fs_event1, close_cb);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(close_cb_called == 2);
ASSERT_EQ(2, close_cb_called);
remove("watch_dir/");
MAKE_VALGRIND_HAPPY(loop);
@ -1035,28 +1046,28 @@ TEST_IMPL(fs_event_getpath) {
for (i = 0; i < ARRAY_SIZE(watch_dir); i++) {
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
len = sizeof buf;
r = uv_fs_event_getpath(&fs_event, buf, &len);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_fs_event_start(&fs_event, fail_cb, watch_dir[i], 0);
ASSERT(r == 0);
ASSERT_OK(r);
len = 0;
r = uv_fs_event_getpath(&fs_event, buf, &len);
ASSERT(r == UV_ENOBUFS);
ASSERT(len < sizeof buf); /* sanity check */
ASSERT(len == strlen(watch_dir[i]) + 1);
ASSERT_EQ(r, UV_ENOBUFS);
ASSERT_LT(len, sizeof buf); /* sanity check */
ASSERT_EQ(len, strlen(watch_dir[i]) + 1);
r = uv_fs_event_getpath(&fs_event, buf, &len);
ASSERT(r == 0);
ASSERT(len == strlen(watch_dir[i]));
ASSERT_OK(r);
ASSERT_EQ(len, strlen(watch_dir[i]));
ASSERT(strcmp(buf, watch_dir[i]) == 0);
r = uv_fs_event_stop(&fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &fs_event, close_cb);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
close_cb_called = 0;
}
@ -1108,43 +1119,43 @@ TEST_IMPL(fs_event_error_reporting) {
*/
for (i = 0; i < ARRAY_SIZE(loops); i++) {
loop = &loops[i];
ASSERT(0 == uv_loop_init(loop));
ASSERT_OK(uv_loop_init(loop));
event = &events[i];
timer_cb_called = 0;
close_cb_called = 0;
ASSERT(0 == uv_fs_event_init(loop, event));
ASSERT(0 == uv_fs_event_start(event,
fs_event_error_report_cb,
"watch_dir",
0));
ASSERT_OK(uv_fs_event_init(loop, event));
ASSERT_OK(uv_fs_event_start(event,
fs_event_error_report_cb,
"watch_dir",
0));
uv_unref((uv_handle_t*) event);
/* Let loop run for some time */
ASSERT(0 == uv_timer_init(loop, &timer));
ASSERT(0 == uv_timer_start(&timer, timer_cb_nop, 2, 0));
ASSERT_OK(uv_timer_init(loop, &timer));
ASSERT_OK(uv_timer_start(&timer, timer_cb_nop, 2, 0));
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(1 == timer_cb_called);
ASSERT(1 == close_cb_called);
ASSERT_EQ(1, timer_cb_called);
ASSERT_EQ(1, close_cb_called);
if (fs_event_error_reported != 0)
break;
}
/* At least one loop should fail */
ASSERT(fs_event_error_reported == UV_EMFILE);
ASSERT_EQ(fs_event_error_reported, UV_EMFILE);
/* Stop and close all events, and destroy loops */
do {
loop = &loops[i];
event = &events[i];
ASSERT(0 == uv_fs_event_stop(event));
ASSERT_OK(uv_fs_event_stop(event));
uv_ref((uv_handle_t*) event);
uv_close((uv_handle_t*) event, fs_event_error_report_close_cb);
close_cb_called = 0;
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
uv_loop_close(loop);
} while (i-- != 0);
@ -1175,13 +1186,13 @@ TEST_IMPL(fs_event_watch_invalid_path) {
loop = uv_default_loop();
r = uv_fs_event_init(loop, &fs_event);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fs_event_start(&fs_event, fs_event_cb_file, "<:;", 0);
ASSERT(r != 0);
ASSERT(uv_is_active((uv_handle_t*) &fs_event) == 0);
ASSERT(r);
ASSERT_OK(uv_is_active((uv_handle_t*) &fs_event));
r = uv_fs_event_start(&fs_event, fs_event_cb_file, "", 0);
ASSERT(r != 0);
ASSERT(uv_is_active((uv_handle_t*) &fs_event) == 0);
ASSERT(r);
ASSERT_OK(uv_is_active((uv_handle_t*) &fs_event));
MAKE_VALGRIND_HAPPY(loop);
return 0;
}
@ -1206,24 +1217,24 @@ TEST_IMPL(fs_event_stop_in_cb) {
remove(path);
create_file(path);
ASSERT_EQ(0, uv_fs_event_init(uv_default_loop(), &fs));
ASSERT_EQ(0, uv_fs_event_start(&fs, fs_event_cb_stop, path, 0));
ASSERT_OK(uv_fs_event_init(uv_default_loop(), &fs));
ASSERT_OK(uv_fs_event_start(&fs, fs_event_cb_stop, path, 0));
/* Note: timer_cb_touch() closes the handle. */
timer.data = path;
ASSERT_EQ(0, uv_timer_init(uv_default_loop(), &timer));
ASSERT_EQ(0, uv_timer_start(&timer, timer_cb_touch, 100, 0));
ASSERT_OK(uv_timer_init(uv_default_loop(), &timer));
ASSERT_OK(uv_timer_start(&timer, timer_cb_touch, 100, 0));
ASSERT_EQ(0, fs_event_cb_stop_calls);
ASSERT_EQ(0, timer_cb_touch_called);
ASSERT_OK(fs_event_cb_stop_calls);
ASSERT_OK(timer_cb_touch_called);
ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(1, fs_event_cb_stop_calls);
ASSERT_EQ(1, timer_cb_touch_called);
uv_close((uv_handle_t*) &fs, NULL);
ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(1, fs_event_cb_stop_calls);
remove(path);

6
deps/libuv/test/test-fs-fd-hash.c vendored
View File

@ -43,7 +43,7 @@ void assert_nonexistent(int fd) {
void assert_existent(int fd) {
struct uv__fd_info_s info = { 0 };
ASSERT(uv__fd_hash_get(fd, &info));
ASSERT(info.flags == fd + FD_DIFF);
ASSERT_EQ(info.flags, fd + FD_DIFF);
}
void assert_insertion(int fd) {
@ -58,7 +58,7 @@ void assert_removal(int fd) {
struct uv__fd_info_s info = { 0 };
assert_existent(fd);
uv__fd_hash_remove(fd, &info);
ASSERT(info.flags == fd + FD_DIFF);
ASSERT_EQ(info.flags, fd + FD_DIFF);
assert_nonexistent(fd);
}
@ -106,7 +106,7 @@ TEST_IMPL(fs_fd_hash) {
{
struct uv__fd_info_s info = { 0 };
ASSERT(uv__fd_hash_get(0, &info));
ASSERT(info.flags == FD_DIFF + FD_DIFF);
ASSERT_EQ(info.flags, FD_DIFF + FD_DIFF);
}
{
/* Leave as it was, will be again tested below */

96
deps/libuv/test/test-fs-open-flags.c vendored
View File

@ -68,8 +68,8 @@ static void setup(void) {
uv_fs_req_cleanup(&rmdir_req);
r = uv_fs_mkdir(NULL, &mkdir_req, empty_dir, 0755, NULL);
ASSERT(r == 0);
ASSERT(mkdir_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(mkdir_req.result);
uv_fs_req_cleanup(&mkdir_req);
}
@ -89,13 +89,13 @@ static void refresh(void) {
r = uv_fs_open(NULL, &open_req, empty_file,
UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_WRONLY, S_IWUSR | S_IRUSR, NULL);
ASSERT(r >= 0);
ASSERT(open_req.result >= 0);
ASSERT_GE(r, 0);
ASSERT_GE(open_req.result, 0);
uv_fs_req_cleanup(&open_req);
r = uv_fs_close(NULL, &close_req, open_req.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(close_req.result);
uv_fs_req_cleanup(&close_req);
/* dummy_file */
@ -103,19 +103,19 @@ static void refresh(void) {
r = uv_fs_open(NULL, &open_req, dummy_file,
UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_WRONLY, S_IWUSR | S_IRUSR, NULL);
ASSERT(r >= 0);
ASSERT(open_req.result >= 0);
ASSERT_GE(r, 0);
ASSERT_GE(open_req.result, 0);
uv_fs_req_cleanup(&open_req);
iov = uv_buf_init("a", 1);
r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == 1);
ASSERT(write_req.result == 1);
ASSERT_EQ(1, r);
ASSERT_EQ(1, write_req.result);
uv_fs_req_cleanup(&write_req);
r = uv_fs_close(NULL, &close_req, open_req.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(close_req.result);
uv_fs_req_cleanup(&close_req);
}
@ -131,14 +131,14 @@ static void openFail(char *file, int error) {
refresh();
r = uv_fs_open(NULL, &open_req, file, flags, S_IWUSR | S_IRUSR, NULL);
ASSERT(r == error);
ASSERT(open_req.result == error);
ASSERT_EQ(r, error);
ASSERT_EQ(open_req.result, error);
uv_fs_req_cleanup(&open_req);
/* Ensure the first call does not create the file */
r = uv_fs_open(NULL, &open_req, file, flags, S_IWUSR | S_IRUSR, NULL);
ASSERT(r == error);
ASSERT(open_req.result == error);
ASSERT_EQ(r, error);
ASSERT_EQ(open_req.result, error);
uv_fs_req_cleanup(&open_req);
cleanup();
@ -150,8 +150,8 @@ static void refreshOpen(char *file) {
refresh();
r = uv_fs_open(NULL, &open_req, file, flags, S_IWUSR | S_IRUSR, NULL);
ASSERT(r >= 0);
ASSERT(open_req.result >= 0);
ASSERT_GE(r, 0);
ASSERT_GE(open_req.result, 0);
uv_fs_req_cleanup(&open_req);
}
@ -162,37 +162,37 @@ static void writeExpect(char *file, char *expected, int size) {
iov = uv_buf_init("b", 1);
r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == 1);
ASSERT(write_req.result == 1);
ASSERT_EQ(1, r);
ASSERT_EQ(1, write_req.result);
uv_fs_req_cleanup(&write_req);
iov = uv_buf_init("c", 1);
r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == 1);
ASSERT(write_req.result == 1);
ASSERT_EQ(1, r);
ASSERT_EQ(1, write_req.result);
uv_fs_req_cleanup(&write_req);
r = uv_fs_close(NULL, &close_req, open_req.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(close_req.result);
uv_fs_req_cleanup(&close_req);
/* Check contents */
r = uv_fs_open(NULL, &open_req, file, UV_FS_O_RDONLY, S_IWUSR | S_IRUSR, NULL);
ASSERT(r >= 0);
ASSERT(open_req.result >= 0);
ASSERT_GE(r, 0);
ASSERT_GE(open_req.result, 0);
uv_fs_req_cleanup(&open_req);
iov = uv_buf_init(buf, sizeof(buf));
r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == size);
ASSERT(read_req.result == size);
ASSERT(strncmp(buf, expected, size) == 0);
ASSERT_EQ(r, size);
ASSERT_EQ(read_req.result, size);
ASSERT_OK(strncmp(buf, expected, size));
uv_fs_req_cleanup(&read_req);
r = uv_fs_close(NULL, &close_req, open_req.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(close_req.result);
uv_fs_req_cleanup(&close_req);
cleanup();
@ -205,19 +205,19 @@ static void writeFail(char *file, int error) {
iov = uv_buf_init("z", 1);
r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == error);
ASSERT(write_req.result == error);
ASSERT_EQ(r, error);
ASSERT_EQ(write_req.result, error);
uv_fs_req_cleanup(&write_req);
iov = uv_buf_init("z", 1);
r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == error);
ASSERT(write_req.result == error);
ASSERT_EQ(r, error);
ASSERT_EQ(write_req.result, error);
uv_fs_req_cleanup(&write_req);
r = uv_fs_close(NULL, &close_req, open_req.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(close_req.result);
uv_fs_req_cleanup(&close_req);
cleanup();
@ -230,14 +230,14 @@ static void readExpect(char *file, char *expected, int size) {
iov = uv_buf_init(buf, sizeof(buf));
r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == size);
ASSERT(read_req.result == size);
ASSERT(strncmp(buf, expected, size) == 0);
ASSERT_EQ(r, size);
ASSERT_EQ(read_req.result, size);
ASSERT_OK(strncmp(buf, expected, size));
uv_fs_req_cleanup(&read_req);
r = uv_fs_close(NULL, &close_req, open_req.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(close_req.result);
uv_fs_req_cleanup(&close_req);
cleanup();
@ -250,19 +250,19 @@ static void readFail(char *file, int error) {
iov = uv_buf_init(buf, sizeof(buf));
r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == error);
ASSERT(read_req.result == error);
ASSERT_EQ(r, error);
ASSERT_EQ(read_req.result, error);
uv_fs_req_cleanup(&read_req);
iov = uv_buf_init(buf, sizeof(buf));
r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL);
ASSERT(r == error);
ASSERT(read_req.result == error);
ASSERT_EQ(r, error);
ASSERT_EQ(read_req.result, error);
uv_fs_req_cleanup(&read_req);
r = uv_fs_close(NULL, &close_req, open_req.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result == 0);
ASSERT_OK(r);
ASSERT_OK(close_req.result);
uv_fs_req_cleanup(&close_req);
cleanup();

108
deps/libuv/test/test-fs-poll.c vendored
View File

@ -103,44 +103,44 @@ static void poll_cb(uv_fs_poll_t* handle,
memset(&zero_statbuf, 0, sizeof(zero_statbuf));
ASSERT(handle == &poll_handle);
ASSERT(1 == uv_is_active((uv_handle_t*) handle));
ASSERT_PTR_EQ(handle, &poll_handle);
ASSERT_EQ(1, uv_is_active((uv_handle_t*) handle));
ASSERT_NOT_NULL(prev);
ASSERT_NOT_NULL(curr);
switch (poll_cb_called++) {
case 0:
ASSERT(status == UV_ENOENT);
ASSERT(0 == memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_EQ(status, UV_ENOENT);
ASSERT_OK(memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_OK(memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
touch_file(FIXTURE);
break;
case 1:
ASSERT(status == 0);
ASSERT(0 == memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 20, 0));
ASSERT_OK(status);
ASSERT_OK(memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 20, 0));
break;
case 2:
ASSERT(status == 0);
ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 200, 0));
ASSERT_OK(status);
ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 200, 0));
break;
case 3:
ASSERT(status == 0);
ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_OK(status);
ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
remove(FIXTURE);
break;
case 4:
ASSERT(status == UV_ENOENT);
ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_EQ(status, UV_ENOENT);
ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT_OK(memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
uv_close((uv_handle_t*)handle, close_cb);
break;
@ -155,14 +155,14 @@ TEST_IMPL(fs_poll) {
remove(FIXTURE);
ASSERT(0 == uv_timer_init(loop, &timer_handle));
ASSERT(0 == uv_fs_poll_init(loop, &poll_handle));
ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb, FIXTURE, 100));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_timer_init(loop, &timer_handle));
ASSERT_OK(uv_fs_poll_init(loop, &poll_handle));
ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb, FIXTURE, 100));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
ASSERT(poll_cb_called == 5);
ASSERT(timer_cb_called == 2);
ASSERT(close_cb_called == 1);
ASSERT_EQ(5, poll_cb_called);
ASSERT_EQ(2, timer_cb_called);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(loop);
return 0;
@ -176,21 +176,21 @@ TEST_IMPL(fs_poll_getpath) {
remove(FIXTURE);
ASSERT(0 == uv_fs_poll_init(loop, &poll_handle));
ASSERT_OK(uv_fs_poll_init(loop, &poll_handle));
len = sizeof buf;
ASSERT(UV_EINVAL == uv_fs_poll_getpath(&poll_handle, buf, &len));
ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
ASSERT_EQ(UV_EINVAL, uv_fs_poll_getpath(&poll_handle, buf, &len));
ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
len = sizeof buf;
ASSERT(0 == uv_fs_poll_getpath(&poll_handle, buf, &len));
ASSERT(buf[len - 1] != 0);
ASSERT(buf[len] == '\0');
ASSERT(0 == memcmp(buf, FIXTURE, len));
ASSERT_OK(uv_fs_poll_getpath(&poll_handle, buf, &len));
ASSERT_NE(0, buf[len - 1]);
ASSERT_EQ(buf[len], '\0');
ASSERT_OK(memcmp(buf, FIXTURE, len));
uv_close((uv_handle_t*) &poll_handle, close_cb);
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(loop);
return 0;
@ -203,14 +203,14 @@ TEST_IMPL(fs_poll_close_request) {
remove(FIXTURE);
ASSERT(0 == uv_loop_init(&loop));
ASSERT_OK(uv_loop_init(&loop));
ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle));
ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle));
ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
uv_close((uv_handle_t*) &poll_handle, close_cb);
while (close_cb_called == 0)
uv_run(&loop, UV_RUN_ONCE);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(&loop);
return 0;
@ -223,18 +223,18 @@ TEST_IMPL(fs_poll_close_request_multi_start_stop) {
remove(FIXTURE);
ASSERT(0 == uv_loop_init(&loop));
ASSERT_OK(uv_loop_init(&loop));
ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle));
ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle));
for (i = 0; i < 10; ++i) {
ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
ASSERT(0 == uv_fs_poll_stop(&poll_handle));
ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
ASSERT_OK(uv_fs_poll_stop(&poll_handle));
}
uv_close((uv_handle_t*) &poll_handle, close_cb);
while (close_cb_called == 0)
uv_run(&loop, UV_RUN_ONCE);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(&loop);
return 0;
@ -247,18 +247,18 @@ TEST_IMPL(fs_poll_close_request_multi_stop_start) {
remove(FIXTURE);
ASSERT(0 == uv_loop_init(&loop));
ASSERT_OK(uv_loop_init(&loop));
ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle));
ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle));
for (i = 0; i < 10; ++i) {
ASSERT(0 == uv_fs_poll_stop(&poll_handle));
ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
ASSERT_OK(uv_fs_poll_stop(&poll_handle));
ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100));
}
uv_close((uv_handle_t*) &poll_handle, close_cb);
while (close_cb_called == 0)
uv_run(&loop, UV_RUN_ONCE);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(&loop);
return 0;
@ -271,21 +271,21 @@ TEST_IMPL(fs_poll_close_request_stop_when_active) {
remove(FIXTURE);
ASSERT(0 == uv_loop_init(&loop));
ASSERT_OK(uv_loop_init(&loop));
/* Set up all handles. */
ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle));
ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_noop, FIXTURE, 100));
ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle));
ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_noop, FIXTURE, 100));
uv_run(&loop, UV_RUN_ONCE);
/* Close the timer handle, and do not crash. */
ASSERT(0 == uv_fs_poll_stop(&poll_handle));
ASSERT_OK(uv_fs_poll_stop(&poll_handle));
uv_run(&loop, UV_RUN_ONCE);
/* Clean up after the test. */
uv_close((uv_handle_t*) &poll_handle, close_cb);
uv_run(&loop, UV_RUN_ONCE);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(&loop);
return 0;

152
deps/libuv/test/test-fs-readdir.c vendored
View File

@ -47,9 +47,9 @@ static void cleanup_test_files(void) {
}
static void empty_closedir_cb(uv_fs_t* req) {
ASSERT(req == &closedir_req);
ASSERT(req->fs_type == UV_FS_CLOSEDIR);
ASSERT(req->result == 0);
ASSERT_PTR_EQ(req, &closedir_req);
ASSERT_EQ(req->fs_type, UV_FS_CLOSEDIR);
ASSERT_OK(req->result);
++empty_closedir_cb_count;
uv_fs_req_cleanup(req);
}
@ -58,25 +58,25 @@ 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);
ASSERT_PTR_EQ(req, &readdir_req);
ASSERT_EQ(req->fs_type, UV_FS_READDIR);
ASSERT_OK(req->result);
dir = req->ptr;
uv_fs_req_cleanup(req);
r = uv_fs_closedir(uv_default_loop(),
&closedir_req,
dir,
empty_closedir_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
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_PTR_EQ(req, &opendir_req);
ASSERT_EQ(req->fs_type, UV_FS_OPENDIR);
ASSERT_OK(req->result);
ASSERT_NOT_NULL(req->ptr);
dir = req->ptr;
dir->dirents = dirents;
@ -85,7 +85,7 @@ static void empty_opendir_cb(uv_fs_t* req) {
&readdir_req,
dir,
empty_readdir_cb);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(req);
++empty_opendir_cb_count;
}
@ -115,9 +115,9 @@ TEST_IMPL(fs_readdir_empty_dir) {
&opendir_req,
path,
NULL);
ASSERT(r == 0);
ASSERT(opendir_req.fs_type == UV_FS_OPENDIR);
ASSERT(opendir_req.result == 0);
ASSERT_OK(r);
ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR);
ASSERT_OK(opendir_req.result);
ASSERT_NOT_NULL(opendir_req.ptr);
dir = opendir_req.ptr;
uv_fs_req_cleanup(&opendir_req);
@ -130,13 +130,13 @@ TEST_IMPL(fs_readdir_empty_dir) {
&readdir_req,
dir,
NULL);
ASSERT(nb_entries_read == 0);
ASSERT_OK(nb_entries_read);
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);
ASSERT_OK(closedir_req.result);
uv_fs_req_cleanup(&closedir_req);
/* Testing the asynchronous flavor. */
@ -147,13 +147,13 @@ TEST_IMPL(fs_readdir_empty_dir) {
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);
ASSERT_OK(r);
ASSERT_OK(empty_opendir_cb_count);
ASSERT_OK(empty_closedir_cb_count);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(empty_opendir_cb_count == 1);
ASSERT(empty_closedir_cb_count == 1);
ASSERT_OK(r);
ASSERT_EQ(1, empty_opendir_cb_count);
ASSERT_EQ(1, empty_closedir_cb_count);
uv_fs_rmdir(uv_default_loop(), &rmdir_req, path, NULL);
uv_fs_req_cleanup(&rmdir_req);
MAKE_VALGRIND_HAPPY(uv_default_loop());
@ -168,9 +168,9 @@ TEST_IMPL(fs_readdir_empty_dir) {
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_PTR_EQ(req, &opendir_req);
ASSERT_EQ(req->fs_type, UV_FS_OPENDIR);
ASSERT_EQ(req->result, UV_ENOENT);
ASSERT_NULL(req->ptr);
uv_fs_req_cleanup(req);
@ -188,9 +188,9 @@ TEST_IMPL(fs_readdir_non_existing_dir) {
/* 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_EQ(r, UV_ENOENT);
ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR);
ASSERT_EQ(opendir_req.result, UV_ENOENT);
ASSERT_NULL(opendir_req.ptr);
uv_fs_req_cleanup(&opendir_req);
@ -202,11 +202,11 @@ TEST_IMPL(fs_readdir_non_existing_dir) {
&opendir_req,
path,
non_existing_opendir_cb);
ASSERT(r == 0);
ASSERT(non_existing_opendir_cb_count == 0);
ASSERT_OK(r);
ASSERT_OK(non_existing_opendir_cb_count);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(non_existing_opendir_cb_count == 1);
ASSERT_OK(r);
ASSERT_EQ(1, non_existing_opendir_cb_count);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -220,9 +220,9 @@ TEST_IMPL(fs_readdir_non_existing_dir) {
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_PTR_EQ(req, &opendir_req);
ASSERT_EQ(req->fs_type, UV_FS_OPENDIR);
ASSERT_EQ(req->result, UV_ENOTDIR);
ASSERT_NULL(req->ptr);
uv_fs_req_cleanup(req);
@ -241,9 +241,9 @@ TEST_IMPL(fs_readdir_file) {
/* 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_EQ(r, UV_ENOTDIR);
ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR);
ASSERT_EQ(opendir_req.result, UV_ENOTDIR);
ASSERT_NULL(opendir_req.ptr);
uv_fs_req_cleanup(&opendir_req);
@ -253,11 +253,11 @@ TEST_IMPL(fs_readdir_file) {
/* 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);
ASSERT_OK(r);
ASSERT_OK(file_opendir_cb_count);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(file_opendir_cb_count == 1);
ASSERT_OK(r);
ASSERT_EQ(1, file_opendir_cb_count);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
}
@ -273,8 +273,8 @@ 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);
ASSERT_PTR_EQ(req, &closedir_req);
ASSERT_OK(req->result);
uv_fs_req_cleanup(req);
++non_empty_closedir_cb_count;
}
@ -282,30 +282,30 @@ static void non_empty_closedir_cb(uv_fs_t* req) {
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);
ASSERT_PTR_EQ(req, &readdir_req);
ASSERT_EQ(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);
ASSERT_EQ(3, non_empty_readdir_cb_count);
uv_fs_closedir(uv_default_loop(),
&closedir_req,
dir,
non_empty_closedir_cb);
} else {
ASSERT(req->result == 1);
ASSERT(dir->dirents == dirents);
ASSERT_EQ(1, req->result);
ASSERT_PTR_EQ(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);
ASSERT_EQ(dirents[0].type, UV_DIRENT_DIR);
else
ASSERT(dirents[0].type == UV_DIRENT_FILE);
ASSERT_EQ(dirents[0].type, UV_DIRENT_FILE);
#else
ASSERT(dirents[0].type == UV_DIRENT_UNKNOWN);
ASSERT_EQ(dirents[0].type, UV_DIRENT_UNKNOWN);
#endif /* HAVE_DIRENT_TYPES */
++non_empty_readdir_cb_count;
@ -323,9 +323,9 @@ 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_PTR_EQ(req, &opendir_req);
ASSERT_EQ(req->fs_type, UV_FS_OPENDIR);
ASSERT_OK(req->result);
ASSERT_NOT_NULL(req->ptr);
dir = req->ptr;
@ -336,7 +336,7 @@ static void non_empty_opendir_cb(uv_fs_t* req) {
&readdir_req,
dir,
non_empty_readdir_cb);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(req);
++non_empty_opendir_cb_count;
}
@ -353,7 +353,7 @@ TEST_IMPL(fs_readdir_non_empty_dir) {
cleanup_test_files();
r = uv_fs_mkdir(uv_default_loop(), &mkdir_req, "test_dir", 0755, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
/* Create two files synchronously. */
r = uv_fs_open(uv_default_loop(),
@ -361,13 +361,13 @@ TEST_IMPL(fs_readdir_non_empty_dir) {
"test_dir/file1",
O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR,
NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
uv_fs_req_cleanup(&create_req);
r = uv_fs_close(uv_default_loop(),
&close_req,
create_req.result,
NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&close_req);
r = uv_fs_open(uv_default_loop(),
@ -375,13 +375,13 @@ TEST_IMPL(fs_readdir_non_empty_dir) {
"test_dir/file2",
O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR,
NULL);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
uv_fs_req_cleanup(&create_req);
r = uv_fs_close(uv_default_loop(),
&close_req,
create_req.result,
NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&close_req);
r = uv_fs_mkdir(uv_default_loop(),
@ -389,7 +389,7 @@ TEST_IMPL(fs_readdir_non_empty_dir) {
"test_dir/test_subdir",
0755,
NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_fs_req_cleanup(&mkdir_req);
/* Fill the req to ensure that required fields are cleaned up. */
@ -397,9 +397,9 @@ TEST_IMPL(fs_readdir_non_empty_dir) {
/* 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_OK(r);
ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR);
ASSERT_OK(opendir_req.result);
ASSERT_NOT_NULL(opendir_req.ptr);
entries_count = 0;
@ -417,23 +417,23 @@ TEST_IMPL(fs_readdir_non_empty_dir) {
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);
ASSERT_EQ(dirents[0].type, UV_DIRENT_DIR);
else
ASSERT(dirents[0].type == UV_DIRENT_FILE);
ASSERT_EQ(dirents[0].type, UV_DIRENT_FILE);
#else
ASSERT(dirents[0].type == UV_DIRENT_UNKNOWN);
ASSERT_EQ(dirents[0].type, UV_DIRENT_UNKNOWN);
#endif /* HAVE_DIRENT_TYPES */
uv_fs_req_cleanup(&readdir_req);
++entries_count;
}
ASSERT(entries_count == 3);
ASSERT_EQ(3, entries_count);
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);
ASSERT_OK(closedir_req.result);
uv_fs_req_cleanup(&closedir_req);
/* Testing the asynchronous flavor. */
@ -445,13 +445,13 @@ TEST_IMPL(fs_readdir_non_empty_dir) {
&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);
ASSERT_OK(r);
ASSERT_OK(non_empty_opendir_cb_count);
ASSERT_OK(non_empty_closedir_cb_count);
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);
ASSERT_OK(r);
ASSERT_EQ(1, non_empty_opendir_cb_count);
ASSERT_EQ(1, non_empty_closedir_cb_count);
uv_fs_rmdir(uv_default_loop(), &rmdir_req, "test_subdir", NULL);
uv_fs_req_cleanup(&rmdir_req);

1725
deps/libuv/test/test-fs.c vendored
View File

File diff suppressed because it is too large Load Diff

26
deps/libuv/test/test-get-currentexe.c vendored
View File

@ -60,43 +60,43 @@ TEST_IMPL(get_currentexe) {
* executable_path.
*/
ASSERT(match && !strcmp(match, path));
ASSERT(size == strlen(buffer));
ASSERT_EQ(size, strlen(buffer));
/* Negative tests */
size = sizeof(buffer) / sizeof(buffer[0]);
r = uv_exepath(NULL, &size);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_exepath(buffer, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
size = 0;
r = uv_exepath(buffer, &size);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
memset(buffer, -1, sizeof(buffer));
size = 1;
r = uv_exepath(buffer, &size);
ASSERT(r == 0);
ASSERT(size == 0);
ASSERT(buffer[0] == '\0');
ASSERT_OK(r);
ASSERT_OK(size);
ASSERT_EQ(buffer[0], '\0');
memset(buffer, -1, sizeof(buffer));
size = 2;
r = uv_exepath(buffer, &size);
ASSERT(r == 0);
ASSERT(size == 1);
ASSERT(buffer[0] != '\0');
ASSERT(buffer[1] == '\0');
ASSERT_OK(r);
ASSERT_EQ(1, size);
ASSERT_NE(buffer[0], '\0');
ASSERT_EQ(buffer[1], '\0');
/* Verify uv_exepath is not affected by uv_set_process_title(). */
r = uv_set_process_title("foobar");
ASSERT_EQ(r, 0);
ASSERT_OK(r);
size = sizeof(buffer);
r = uv_exepath(buffer, &size);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
match = strstr(buffer, path);
/* Verify that the path returned from uv_exepath is a subdirectory of

6
deps/libuv/test/test-get-loadavg.c vendored
View File

@ -27,9 +27,9 @@ TEST_IMPL(get_loadavg) {
double avg[3] = {-1, -1, -1};
uv_loadavg(avg);
ASSERT(avg[0] >= 0);
ASSERT(avg[1] >= 0);
ASSERT(avg[2] >= 0);
ASSERT_GE(avg[0], 0);
ASSERT_GE(avg[1], 0);
ASSERT_GE(avg[2], 0);
return 0;
}

8
deps/libuv/test/test-get-memory.c vendored
View File

@ -35,13 +35,13 @@ TEST_IMPL(get_memory) {
(unsigned long long) constrained_mem,
(unsigned long long) available_mem);
ASSERT(free_mem > 0);
ASSERT(total_mem > 0);
ASSERT_GT(free_mem, 0);
ASSERT_GT(total_mem, 0);
/* On IBMi PASE, the amount of memory in use is always zero. */
#ifdef __PASE__
ASSERT(total_mem == free_mem);
ASSERT_EQ(total_mem, free_mem);
#else
ASSERT(total_mem > free_mem);
ASSERT_GT(total_mem, free_mem);
#endif
ASSERT_LE(available_mem, total_mem);
/* we'd really want to test if available <= free, but that is fragile:

21
deps/libuv/test/test-get-passwd.c vendored
View File

@ -39,7 +39,7 @@ TEST_IMPL(get_passwd) {
/* Test the normal case */
r = uv_os_get_passwd(&pwd);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
len = strlen(pwd.username);
ASSERT_GT(len, 0);
@ -114,7 +114,7 @@ TEST_IMPL(get_passwd2) {
/* Test the normal case */
r = uv_os_get_passwd(&pwd);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_os_get_passwd2(&pwd2, pwd.uid);
@ -123,7 +123,7 @@ TEST_IMPL(get_passwd2) {
(void) &len;
#else
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(pwd.uid, pwd2.uid);
ASSERT_STR_EQ(pwd.username, pwd2.username);
ASSERT_STR_EQ(pwd.shell, pwd2.shell);
@ -131,15 +131,20 @@ TEST_IMPL(get_passwd2) {
uv_os_free_passwd(&pwd2);
r = uv_os_get_passwd2(&pwd2, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
len = strlen(pwd2.username);
ASSERT_GT(len, 0);
#if defined(__PASE__)
// uid 0 is qsecofr on IBM i
ASSERT_STR_EQ(pwd2.username, "qsecofr");
#else
ASSERT_STR_EQ(pwd2.username, "root");
#endif
len = strlen(pwd2.homedir);
# ifndef __PASE__
ASSERT_GT(len, 0);
#endif
len = strlen(pwd2.shell);
# ifndef __PASE__
ASSERT_GT(len, 0);
@ -174,7 +179,7 @@ TEST_IMPL(get_group) {
int r;
r = uv_os_get_passwd(&pwd);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_os_get_group(&grp, pwd.gid);
@ -183,7 +188,7 @@ TEST_IMPL(get_group) {
(void) &len;
#else
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(pwd.gid, grp.gid);
len = strlen(grp.groupname);

68
deps/libuv/test/test-getaddrinfo.c vendored
View File

@ -40,8 +40,8 @@ static void getaddrinfo_fail_cb(uv_getaddrinfo_t* req,
int status,
struct addrinfo* res) {
ASSERT(fail_cb_called == 0);
ASSERT(status < 0);
ASSERT_OK(fail_cb_called);
ASSERT_LT(status, 0);
ASSERT_NULL(res);
uv_freeaddrinfo(res); /* Should not crash. */
fail_cb_called++;
@ -51,7 +51,7 @@ static void getaddrinfo_fail_cb(uv_getaddrinfo_t* req,
static void getaddrinfo_basic_cb(uv_getaddrinfo_t* handle,
int status,
struct addrinfo* res) {
ASSERT(handle == getaddrinfo_handle);
ASSERT_PTR_EQ(handle, getaddrinfo_handle);
getaddrinfo_cbs++;
free(handle);
uv_freeaddrinfo(res);
@ -66,7 +66,7 @@ static void getaddrinfo_cuncurrent_cb(uv_getaddrinfo_t* handle,
for (i = 0; i < CONCURRENT_COUNT; i++) {
if (&getaddrinfo_handles[i] == handle) {
ASSERT(i == *data);
ASSERT_EQ(i, *data);
callback_counts[i]++;
break;
@ -89,22 +89,22 @@ TEST_IMPL(getaddrinfo_fail) {
uv_getaddrinfo_t req;
ASSERT(UV_EINVAL == uv_getaddrinfo(uv_default_loop(),
&req,
(uv_getaddrinfo_cb) abort,
NULL,
NULL,
NULL));
ASSERT_EQ(UV_EINVAL, uv_getaddrinfo(uv_default_loop(),
&req,
(uv_getaddrinfo_cb) abort,
NULL,
NULL,
NULL));
/* Use a FQDN by ending in a period */
ASSERT(0 == uv_getaddrinfo(uv_default_loop(),
&req,
getaddrinfo_fail_cb,
"example.invalid.",
NULL,
NULL));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(fail_cb_called == 1);
ASSERT_OK(uv_getaddrinfo(uv_default_loop(),
&req,
getaddrinfo_fail_cb,
"example.invalid.",
NULL,
NULL));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(1, fail_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -119,12 +119,12 @@ TEST_IMPL(getaddrinfo_fail_sync) {
uv_getaddrinfo_t req;
/* Use a FQDN by ending in a period */
ASSERT(0 > uv_getaddrinfo(uv_default_loop(),
&req,
NULL,
"example.invalid.",
NULL,
NULL));
ASSERT_GT(0, uv_getaddrinfo(uv_default_loop(),
&req,
NULL,
"example.invalid.",
NULL,
NULL));
uv_freeaddrinfo(req.addrinfo);
MAKE_VALGRIND_HAPPY(uv_default_loop());
@ -147,11 +147,11 @@ TEST_IMPL(getaddrinfo_basic) {
name,
NULL,
NULL);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(getaddrinfo_cbs == 1);
ASSERT_EQ(1, getaddrinfo_cbs);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -165,12 +165,12 @@ TEST_IMPL(getaddrinfo_basic_sync) {
#endif
uv_getaddrinfo_t req;
ASSERT(0 == uv_getaddrinfo(uv_default_loop(),
&req,
NULL,
name,
NULL,
NULL));
ASSERT_OK(uv_getaddrinfo(uv_default_loop(),
&req,
NULL,
name,
NULL,
NULL));
uv_freeaddrinfo(req.addrinfo);
MAKE_VALGRIND_HAPPY(uv_default_loop());
@ -201,13 +201,13 @@ TEST_IMPL(getaddrinfo_concurrent) {
name,
NULL,
NULL);
ASSERT(r == 0);
ASSERT_OK(r);
}
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
for (i = 0; i < CONCURRENT_COUNT; i++) {
ASSERT(callback_counts[i] == 1);
ASSERT_EQ(1, callback_counts[i]);
}
MAKE_VALGRIND_HAPPY(uv_default_loop());

14
deps/libuv/test/test-gethostname.c vendored
View File

@ -32,27 +32,27 @@ TEST_IMPL(gethostname) {
/* Reject invalid inputs */
size = 1;
r = uv_os_gethostname(NULL, &size);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_os_gethostname(buf, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
size = 0;
r = uv_os_gethostname(buf, &size);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
/* Return UV_ENOBUFS if the buffer cannot hold the hostname */
enobufs_size = 1;
buf[0] = '\0';
r = uv_os_gethostname(buf, &enobufs_size);
ASSERT_EQ(r, UV_ENOBUFS);
ASSERT(buf[0] == '\0');
ASSERT(enobufs_size > 1);
ASSERT_EQ(buf[0], '\0');
ASSERT_GT(enobufs_size, 1);
/* Successfully get the hostname */
size = UV_MAXHOSTNAMESIZE;
r = uv_os_gethostname(buf, &size);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(size > 0 && size == strlen(buf));
ASSERT(size + 1 == enobufs_size);
ASSERT_EQ(size + 1, enobufs_size);
return 0;
}

26
deps/libuv/test/test-getnameinfo.c vendored
View File

@ -39,7 +39,7 @@ static void getnameinfo_req(uv_getnameinfo_t* handle,
const char* hostname,
const char* service) {
ASSERT_NOT_NULL(handle);
ASSERT(status == 0);
ASSERT_OK(status);
ASSERT_NOT_NULL(hostname);
ASSERT_NOT_NULL(service);
}
@ -54,14 +54,14 @@ TEST_IMPL(getnameinfo_basic_ip4) {
int r;
r = uv_ip4_addr(address_ip4, port, &addr4);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_getnameinfo(uv_default_loop(),
&req,
&getnameinfo_req,
(const struct sockaddr*)&addr4,
0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -76,15 +76,15 @@ TEST_IMPL(getnameinfo_basic_ip4_sync) {
RETURN_SKIP("Test does not currently work in QEMU");
#endif
ASSERT(0 == uv_ip4_addr(address_ip4, port, &addr4));
ASSERT_OK(uv_ip4_addr(address_ip4, port, &addr4));
ASSERT(0 == uv_getnameinfo(uv_default_loop(),
&req,
NULL,
(const struct sockaddr*)&addr4,
0));
ASSERT(req.host[0] != '\0');
ASSERT(req.service[0] != '\0');
ASSERT_OK(uv_getnameinfo(uv_default_loop(),
&req,
NULL,
(const struct sockaddr*)&addr4,
0));
ASSERT_NE(req.host[0], '\0');
ASSERT_NE(req.service[0], '\0');
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -100,14 +100,14 @@ TEST_IMPL(getnameinfo_basic_ip6) {
int r;
r = uv_ip6_addr(address_ip6, port, &addr6);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_getnameinfo(uv_default_loop(),
&req,
&getnameinfo_req,
(const struct sockaddr*)&addr6,
0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

68
deps/libuv/test/test-getsockname.c vendored
View File

@ -73,7 +73,7 @@ static void after_read(uv_stream_t* handle,
req = (uv_shutdown_t*) malloc(sizeof *req);
r = uv_shutdown(req, handle, after_shutdown);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -84,22 +84,22 @@ static void check_sockname(struct sockaddr* addr, const char* compare_ip,
char check_ip[17];
int r;
ASSERT(0 == uv_ip4_addr(compare_ip, compare_port, &compare_addr));
ASSERT_OK(uv_ip4_addr(compare_ip, compare_port, &compare_addr));
/* Both addresses should be ipv4 */
ASSERT(check_addr.sin_family == AF_INET);
ASSERT(compare_addr.sin_family == AF_INET);
ASSERT_EQ(check_addr.sin_family, AF_INET);
ASSERT_EQ(compare_addr.sin_family, AF_INET);
/* Check if the ip matches */
ASSERT(memcmp(&check_addr.sin_addr,
&compare_addr.sin_addr,
sizeof compare_addr.sin_addr) == 0);
ASSERT_OK(memcmp(&check_addr.sin_addr,
&compare_addr.sin_addr,
sizeof compare_addr.sin_addr));
/* Check if the port matches. If port == 0 anything goes. */
ASSERT(compare_port == 0 || check_addr.sin_port == compare_addr.sin_port);
r = uv_ip4_name(&check_addr, (char*) check_ip, sizeof check_ip);
ASSERT(r == 0);
ASSERT_OK(r);
printf("%s: %s:%d\n", context, check_ip, ntohs(check_addr.sin_port));
}
@ -114,34 +114,34 @@ static void on_connection(uv_stream_t* server, int status) {
if (status != 0) {
fprintf(stderr, "Connect error %s\n", uv_err_name(status));
}
ASSERT(status == 0);
ASSERT_OK(status);
handle = malloc(sizeof(*handle));
ASSERT_NOT_NULL(handle);
r = uv_tcp_init(loop, handle);
ASSERT(r == 0);
ASSERT_OK(r);
/* associate server with stream */
handle->data = server;
r = uv_accept(server, (uv_stream_t*)handle);
ASSERT(r == 0);
ASSERT_OK(r);
namelen = sizeof sockname;
r = uv_tcp_getsockname(handle, &sockname, &namelen);
ASSERT(r == 0);
ASSERT_OK(r);
check_sockname(&sockname, "127.0.0.1", server_port, "accepted socket");
getsocknamecount_tcp++;
namelen = sizeof peername;
r = uv_tcp_getpeername(handle, &peername, &namelen);
ASSERT(r == 0);
ASSERT_OK(r);
check_sockname(&peername, "127.0.0.1", connect_port, "accepted socket peer");
getpeernamecount++;
r = uv_read_start((uv_stream_t*)handle, alloc, after_read);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -149,17 +149,17 @@ static void on_connect(uv_connect_t* req, int status) {
struct sockaddr sockname, peername;
int r, namelen;
ASSERT(status == 0);
ASSERT_OK(status);
namelen = sizeof sockname;
r = uv_tcp_getsockname((uv_tcp_t*) req->handle, &sockname, &namelen);
ASSERT(r == 0);
ASSERT_OK(r);
check_sockname(&sockname, "127.0.0.1", 0, "connected socket");
getsocknamecount_tcp++;
namelen = sizeof peername;
r = uv_tcp_getpeername((uv_tcp_t*) req->handle, &peername, &namelen);
ASSERT(r == 0);
ASSERT_OK(r);
check_sockname(&peername, "127.0.0.1", server_port, "connected socket peer");
getpeernamecount++;
@ -173,7 +173,7 @@ static int tcp_listener(void) {
int namelen;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", server_port, &addr));
r = uv_tcp_init(loop, &tcpServer);
if (r) {
@ -196,13 +196,13 @@ static int tcp_listener(void) {
memset(&sockname, -1, sizeof sockname);
namelen = sizeof sockname;
r = uv_tcp_getsockname(&tcpServer, &sockname, &namelen);
ASSERT(r == 0);
ASSERT_OK(r);
check_sockname(&sockname, "0.0.0.0", server_port, "server socket");
getsocknamecount_tcp++;
namelen = sizeof sockname;
r = uv_tcp_getpeername(&tcpServer, &peername, &namelen);
ASSERT(r == UV_ENOTCONN);
ASSERT_EQ(r, UV_ENOTCONN);
getpeernamecount++;
return 0;
@ -214,7 +214,7 @@ static void tcp_connector(void) {
struct sockaddr sockname;
int r, namelen;
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", server_port, &server_addr));
r = uv_tcp_init(loop, &tcp);
tcp.data = &connect_req;
@ -230,9 +230,9 @@ static void tcp_connector(void) {
namelen = sizeof sockname;
r = uv_tcp_getsockname(&tcp, &sockname, &namelen);
ASSERT(!r);
ASSERT(sockname.sa_family == AF_INET);
ASSERT_EQ(sockname.sa_family, AF_INET);
connect_port = ntohs(((struct sockaddr_in*) &sockname)->sin_port);
ASSERT(connect_port > 0);
ASSERT_GT(connect_port, 0);
}
@ -245,7 +245,7 @@ static void udp_recv(uv_udp_t* handle,
int namelen;
int r;
ASSERT(nread >= 0);
ASSERT_GE(nread, 0);
free(buf->base);
if (nread == 0) {
@ -255,7 +255,7 @@ static void udp_recv(uv_udp_t* handle,
memset(&sockname, -1, sizeof sockname);
namelen = sizeof(sockname);
r = uv_udp_getsockname(&udp, &sockname, &namelen);
ASSERT(r == 0);
ASSERT_OK(r);
check_sockname(&sockname, "0.0.0.0", 0, "udp receiving socket");
getsocknamecount_udp++;
@ -275,7 +275,7 @@ static int udp_listener(void) {
int namelen;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", server_port, &addr));
r = uv_udp_init(loop, &udpServer);
if (r) {
@ -292,12 +292,12 @@ static int udp_listener(void) {
memset(&sockname, -1, sizeof sockname);
namelen = sizeof sockname;
r = uv_udp_getsockname(&udpServer, &sockname, &namelen);
ASSERT(r == 0);
ASSERT_OK(r);
check_sockname(&sockname, "0.0.0.0", server_port, "udp listener socket");
getsocknamecount_udp++;
r = uv_udp_recv_start(&udpServer, alloc, udp_recv);
ASSERT(r == 0);
ASSERT_OK(r);
return 0;
}
@ -312,7 +312,7 @@ static void udp_sender(void) {
ASSERT(!r);
buf = uv_buf_init("PING", 4);
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", server_port, &server_addr));
r = uv_udp_send(&send_req,
&udp,
@ -334,8 +334,8 @@ TEST_IMPL(getsockname_tcp) {
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(getsocknamecount_tcp == 3);
ASSERT(getpeernamecount == 3);
ASSERT_EQ(3, getsocknamecount_tcp);
ASSERT_EQ(3, getpeernamecount);
MAKE_VALGRIND_HAPPY(loop);
return 0;
@ -352,10 +352,10 @@ TEST_IMPL(getsockname_udp) {
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(getsocknamecount_udp == 2);
ASSERT_EQ(2, getsocknamecount_udp);
ASSERT(udp.send_queue_size == 0);
ASSERT(udpServer.send_queue_size == 0);
ASSERT_OK(udp.send_queue_size);
ASSERT_OK(udpServer.send_queue_size);
MAKE_VALGRIND_HAPPY(loop);
return 0;

48
deps/libuv/test/test-getters-setters.c vendored
View File

@ -30,9 +30,9 @@ int cookie3;
TEST_IMPL(handle_type_name) {
ASSERT(strcmp(uv_handle_type_name(UV_NAMED_PIPE), "pipe") == 0);
ASSERT(strcmp(uv_handle_type_name(UV_UDP), "udp") == 0);
ASSERT(strcmp(uv_handle_type_name(UV_FILE), "file") == 0);
ASSERT_OK(strcmp(uv_handle_type_name(UV_NAMED_PIPE), "pipe"));
ASSERT_OK(strcmp(uv_handle_type_name(UV_UDP), "udp"));
ASSERT_OK(strcmp(uv_handle_type_name(UV_FILE), "file"));
ASSERT_NULL(uv_handle_type_name(UV_HANDLE_TYPE_MAX));
ASSERT_NULL(uv_handle_type_name(UV_HANDLE_TYPE_MAX + 1));
ASSERT_NULL(uv_handle_type_name(UV_UNKNOWN_HANDLE));
@ -41,9 +41,9 @@ TEST_IMPL(handle_type_name) {
TEST_IMPL(req_type_name) {
ASSERT(strcmp(uv_req_type_name(UV_REQ), "req") == 0);
ASSERT(strcmp(uv_req_type_name(UV_UDP_SEND), "udp_send") == 0);
ASSERT(strcmp(uv_req_type_name(UV_WORK), "work") == 0);
ASSERT_OK(strcmp(uv_req_type_name(UV_REQ), "req"));
ASSERT_OK(strcmp(uv_req_type_name(UV_UDP_SEND), "udp_send"));
ASSERT_OK(strcmp(uv_req_type_name(UV_WORK), "work"));
ASSERT_NULL(uv_req_type_name(UV_REQ_TYPE_MAX));
ASSERT_NULL(uv_req_type_name(UV_REQ_TYPE_MAX + 1));
ASSERT_NULL(uv_req_type_name(UV_UNKNOWN_REQ));
@ -60,48 +60,48 @@ TEST_IMPL(getters_setters) {
loop = malloc(uv_loop_size());
ASSERT_NOT_NULL(loop);
r = uv_loop_init(loop);
ASSERT(r == 0);
ASSERT_OK(r);
uv_loop_set_data(loop, &cookie1);
ASSERT(loop->data == &cookie1);
ASSERT(uv_loop_get_data(loop) == &cookie1);
ASSERT_PTR_EQ(loop->data, &cookie1);
ASSERT_PTR_EQ(uv_loop_get_data(loop), &cookie1);
pipe = malloc(uv_handle_size(UV_NAMED_PIPE));
r = uv_pipe_init(loop, pipe, 0);
ASSERT(r == 0);
ASSERT(uv_handle_get_type((uv_handle_t*)pipe) == UV_NAMED_PIPE);
ASSERT_OK(r);
ASSERT_EQ(uv_handle_get_type((uv_handle_t*)pipe), UV_NAMED_PIPE);
ASSERT(uv_handle_get_loop((uv_handle_t*)pipe) == loop);
ASSERT_PTR_EQ(uv_handle_get_loop((uv_handle_t*)pipe), loop);
pipe->data = &cookie2;
ASSERT(uv_handle_get_data((uv_handle_t*)pipe) == &cookie2);
ASSERT_PTR_EQ(uv_handle_get_data((uv_handle_t*)pipe), &cookie2);
uv_handle_set_data((uv_handle_t*)pipe, &cookie1);
ASSERT(uv_handle_get_data((uv_handle_t*)pipe) == &cookie1);
ASSERT(pipe->data == &cookie1);
ASSERT_PTR_EQ(uv_handle_get_data((uv_handle_t*)pipe), &cookie1);
ASSERT_PTR_EQ(pipe->data, &cookie1);
ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)pipe) == 0);
ASSERT_OK(uv_stream_get_write_queue_size((uv_stream_t*)pipe));
pipe->write_queue_size++;
ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)pipe) == 1);
ASSERT_EQ(1, uv_stream_get_write_queue_size((uv_stream_t*)pipe));
pipe->write_queue_size--;
uv_close((uv_handle_t*)pipe, NULL);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
fs = malloc(uv_req_size(UV_FS));
uv_fs_stat(loop, fs, ".", NULL);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
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_EQ(uv_fs_get_type(fs), UV_FS_STAT);
ASSERT_OK(uv_fs_get_result(fs));
ASSERT_PTR_EQ(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);
ASSERT_OK(strcmp(uv_fs_get_path(fs), "."));
uv_fs_req_cleanup(fs);
r = uv_loop_close(loop);
ASSERT(r == 0);
ASSERT_OK(r);
free(pipe);
free(fs);

6
deps/libuv/test/test-gettimeofday.c vendored
View File

@ -28,12 +28,12 @@ TEST_IMPL(gettimeofday) {
tv.tv_sec = 0;
r = uv_gettimeofday(&tv);
ASSERT(r == 0);
ASSERT(tv.tv_sec != 0);
ASSERT_OK(r);
ASSERT_NE(0, tv.tv_sec);
/* Test invalid input. */
r = uv_gettimeofday(NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
return 0;
}

42
deps/libuv/test/test-handle-fileno.c vendored
View File

@ -56,49 +56,49 @@ TEST_IMPL(handle_fileno) {
uv_loop_t* loop;
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_idle_init(loop, &idle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fileno((uv_handle_t*) &idle, &fd);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
uv_close((uv_handle_t*) &idle, NULL);
r = uv_tcp_init(loop, &tcp);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fileno((uv_handle_t*) &tcp, &fd);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
r = uv_tcp_bind(&tcp, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fileno((uv_handle_t*) &tcp, &fd);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &tcp, NULL);
r = uv_fileno((uv_handle_t*) &tcp, &fd);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
r = uv_udp_init(loop, &udp);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fileno((uv_handle_t*) &udp, &fd);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
r = uv_udp_bind(&udp, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fileno((uv_handle_t*) &udp, &fd);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &udp, NULL);
r = uv_fileno((uv_handle_t*) &udp, &fd);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
r = uv_pipe_init(loop, &pipe, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fileno((uv_handle_t*) &pipe, &fd);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
r = uv_pipe_bind(&pipe, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_fileno((uv_handle_t*) &pipe, &fd);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &pipe, NULL);
r = uv_fileno((uv_handle_t*) &pipe, &fd);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
tty_fd = get_tty_fd();
if (tty_fd < 0) {
@ -106,14 +106,14 @@ TEST_IMPL(handle_fileno) {
fflush(stderr);
} else {
r = uv_tty_init(loop, &tty, tty_fd, 0);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(uv_is_readable((uv_stream_t*) &tty));
ASSERT(!uv_is_writable((uv_stream_t*) &tty));
r = uv_fileno((uv_handle_t*) &tty, &fd);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &tty, NULL);
r = uv_fileno((uv_handle_t*) &tty, &fd);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
ASSERT(!uv_is_readable((uv_stream_t*) &tty));
ASSERT(!uv_is_writable((uv_stream_t*) &tty));
}

28
deps/libuv/test/test-homedir.c vendored
View File

@ -34,39 +34,39 @@ TEST_IMPL(homedir) {
/* Test the normal case */
len = sizeof homedir;
homedir[0] = '\0';
ASSERT(strlen(homedir) == 0);
ASSERT_OK(strlen(homedir));
r = uv_os_homedir(homedir, &len);
ASSERT(r == 0);
ASSERT(strlen(homedir) == len);
ASSERT(len > 0);
ASSERT(homedir[len] == '\0');
ASSERT_OK(r);
ASSERT_EQ(strlen(homedir), len);
ASSERT_GT(len, 0);
ASSERT_EQ(homedir[len], '\0');
#ifdef _WIN32
if (len == 3 && homedir[1] == ':')
ASSERT(homedir[2] == '\\');
ASSERT_EQ(homedir[2], '\\');
else
ASSERT(homedir[len - 1] != '\\');
ASSERT_NE(homedir[len - 1], '\\');
#else
if (len == 1)
ASSERT(homedir[0] == '/');
ASSERT_EQ(homedir[0], '/');
else
ASSERT(homedir[len - 1] != '/');
ASSERT_NE(homedir[len - 1], '/');
#endif
/* Test the case where the buffer is too small */
len = SMALLPATH;
r = uv_os_homedir(homedir, &len);
ASSERT(r == UV_ENOBUFS);
ASSERT(len > SMALLPATH);
ASSERT_EQ(r, UV_ENOBUFS);
ASSERT_GT(len, SMALLPATH);
/* Test invalid inputs */
r = uv_os_homedir(NULL, &len);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
r = uv_os_homedir(homedir, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
len = 0;
r = uv_os_homedir(homedir, &len);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
return 0;
}

6
deps/libuv/test/test-hrtime.c vendored
View File

@ -45,7 +45,7 @@ TEST_IMPL(hrtime) {
* that the difference between the two hrtime values has a reasonable
* lower bound.
*/
ASSERT(diff > (uint64_t) 25 * NANOSEC / MILLISEC);
ASSERT_UINT64_GT(diff, (uint64_t) 25 * NANOSEC / MILLISEC);
--i;
}
return 0;
@ -57,8 +57,8 @@ TEST_IMPL(clock_gettime) {
ASSERT_EQ(UV_EINVAL, uv_clock_gettime(1337, &t));
ASSERT_EQ(UV_EFAULT, uv_clock_gettime(1337, NULL));
ASSERT_EQ(0, uv_clock_gettime(UV_CLOCK_MONOTONIC, &t));
ASSERT_EQ(0, uv_clock_gettime(UV_CLOCK_REALTIME, &t));
ASSERT_OK(uv_clock_gettime(UV_CLOCK_MONOTONIC, &t));
ASSERT_OK(uv_clock_gettime(UV_CLOCK_REALTIME, &t));
ASSERT_GT(1682500000000ll, t.tv_sec); /* 2023-04-26T09:06:40.000Z */
return 0;

38
deps/libuv/test/test-idle.c vendored
View File

@ -39,7 +39,7 @@ static void close_cb(uv_handle_t* handle) {
static void timer_cb(uv_timer_t* handle) {
ASSERT(handle == &timer_handle);
ASSERT_PTR_EQ(handle, &timer_handle);
uv_close((uv_handle_t*) &idle_handle, close_cb);
uv_close((uv_handle_t*) &check_handle, close_cb);
@ -52,7 +52,7 @@ static void timer_cb(uv_timer_t* handle) {
static void idle_cb(uv_idle_t* handle) {
ASSERT(handle == &idle_handle);
ASSERT_PTR_EQ(handle, &idle_handle);
idle_cb_called++;
fprintf(stderr, "idle_cb %d\n", idle_cb_called);
@ -61,7 +61,7 @@ static void idle_cb(uv_idle_t* handle) {
static void check_cb(uv_check_t* handle) {
ASSERT(handle == &check_handle);
ASSERT_PTR_EQ(handle, &check_handle);
check_cb_called++;
fprintf(stderr, "check_cb %d\n", check_cb_called);
@ -73,26 +73,26 @@ TEST_IMPL(idle_starvation) {
int r;
r = uv_idle_init(uv_default_loop(), &idle_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_idle_start(&idle_handle, idle_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_check_init(uv_default_loop(), &check_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_check_start(&check_handle, check_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_init(uv_default_loop(), &timer_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer_handle, timer_cb, 50, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(idle_cb_called > 0);
ASSERT(timer_cb_called == 1);
ASSERT(close_cb_called == 3);
ASSERT_GT(idle_cb_called, 0);
ASSERT_EQ(1, timer_cb_called);
ASSERT_EQ(3, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -105,19 +105,19 @@ static void idle_stop(uv_idle_t* handle) {
TEST_IMPL(idle_check) {
ASSERT_EQ(0, uv_idle_init(uv_default_loop(), &idle_handle));
ASSERT_EQ(0, uv_idle_start(&idle_handle, idle_stop));
ASSERT_OK(uv_idle_init(uv_default_loop(), &idle_handle));
ASSERT_OK(uv_idle_start(&idle_handle, idle_stop));
ASSERT_EQ(0, uv_check_init(uv_default_loop(), &check_handle));
ASSERT_EQ(0, uv_check_start(&check_handle, check_cb));
ASSERT_OK(uv_check_init(uv_default_loop(), &check_handle));
ASSERT_OK(uv_check_start(&check_handle, check_cb));
ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT_EQ(1, check_cb_called);
ASSERT_EQ(0, close_cb_called);
ASSERT_OK(close_cb_called);
uv_close((uv_handle_t*) &idle_handle, close_cb);
uv_close((uv_handle_t*) &check_handle, close_cb);
ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT_EQ(2, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());

73
deps/libuv/test/test-idna.c vendored
View File

@ -20,6 +20,7 @@
*/
#include "task.h"
#define uv__malloc malloc
#include "../src/idna.c"
#include <string.h>
@ -31,66 +32,66 @@ TEST_IMPL(utf8_decode1) {
/* ASCII. */
p = b;
snprintf(b, sizeof(b), "%c\x7F", 0x00);
ASSERT(0 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 1);
ASSERT(127 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 2);
ASSERT_OK(uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 1);
ASSERT_EQ(127, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 2);
/* Two-byte sequences. */
p = b;
snprintf(b, sizeof(b), "\xC2\x80\xDF\xBF");
ASSERT(128 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 2);
ASSERT(0x7FF == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 4);
ASSERT_EQ(128, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 2);
ASSERT_EQ(0x7FF, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 4);
/* Three-byte sequences. */
p = b;
snprintf(b, sizeof(b), "\xE0\xA0\x80\xEF\xBF\xBF");
ASSERT(0x800 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 3);
ASSERT(0xFFFF == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 6);
ASSERT_EQ(0x800, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 3);
ASSERT_EQ(0xFFFF, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 6);
/* Four-byte sequences. */
p = b;
snprintf(b, sizeof(b), "\xF0\x90\x80\x80\xF4\x8F\xBF\xBF");
ASSERT(0x10000 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 4);
ASSERT(0x10FFFF == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 8);
ASSERT_EQ(0x10000, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 4);
ASSERT_EQ(0x10FFFF, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 8);
/* Four-byte sequences > U+10FFFF; disallowed. */
p = b;
snprintf(b, sizeof(b), "\xF4\x90\xC0\xC0\xF7\xBF\xBF\xBF");
ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 4);
ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 8);
ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 4);
ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 8);
/* Overlong; disallowed. */
p = b;
snprintf(b, sizeof(b), "\xC0\x80\xC1\x80");
ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 2);
ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 4);
ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 2);
ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 4);
/* Surrogate pairs; disallowed. */
p = b;
snprintf(b, sizeof(b), "\xED\xA0\x80\xED\xA3\xBF");
ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 3);
ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + 6);
ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 3);
ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + 6);
/* Simply illegal. */
p = b;
snprintf(b, sizeof(b), "\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF");
for (i = 1; i <= 8; i++) {
ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT(p == b + i);
ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b)));
ASSERT_PTR_EQ(p, b + i);
}
return 0;
@ -122,7 +123,7 @@ TEST_IMPL(utf8_decode1_overrun) {
do { \
char d[256] = {0}; \
static const char s[] = "" input ""; \
ASSERT(err == uv__idna_toascii(s, s + sizeof(s) - 1, d, d + sizeof(d))); \
ASSERT_EQ(err, uv__idna_toascii(s, s + sizeof(s) - 1, d, d + sizeof(d))); \
} while (0)
#define T(input, expected) \
@ -132,13 +133,13 @@ TEST_IMPL(utf8_decode1_overrun) {
char d2[256] = {0}; \
static const char s[] = "" input ""; \
n = uv__idna_toascii(s, s + sizeof(s) - 1, d1, d1 + sizeof(d1)); \
ASSERT(n == sizeof(expected)); \
ASSERT(0 == memcmp(d1, expected, n)); \
ASSERT_EQ(n, sizeof(expected)); \
ASSERT_OK(memcmp(d1, expected, n)); \
/* Sanity check: encoding twice should not change the output. */ \
n = uv__idna_toascii(d1, d1 + strlen(d1), d2, d2 + sizeof(d2)); \
ASSERT(n == sizeof(expected)); \
ASSERT(0 == memcmp(d2, expected, n)); \
ASSERT(0 == memcmp(d1, d2, sizeof(d2))); \
ASSERT_EQ(n, sizeof(expected)); \
ASSERT_OK(memcmp(d2, expected, n)); \
ASSERT_OK(memcmp(d1, d2, sizeof(d2))); \
} while (0)
TEST_IMPL(idna_toascii) {

20
deps/libuv/test/test-ip-name.c vendored
View File

@ -40,20 +40,20 @@ TEST_IMPL(ip_name) {
struct sockaddr_in6* addr6 = &test_addr.addr6;
/* test ip4_name */
ASSERT_EQ(0, uv_ip4_addr("192.168.0.1", TEST_PORT, addr4));
ASSERT_EQ(0, uv_ip4_name(addr4, dst, INET_ADDRSTRLEN));
ASSERT_EQ(0, strcmp("192.168.0.1", dst));
ASSERT_OK(uv_ip4_addr("192.168.0.1", TEST_PORT, addr4));
ASSERT_OK(uv_ip4_name(addr4, dst, INET_ADDRSTRLEN));
ASSERT_OK(strcmp("192.168.0.1", dst));
ASSERT_EQ(0, uv_ip_name(addr, dst, INET_ADDRSTRLEN));
ASSERT_EQ(0, strcmp("192.168.0.1", dst));
ASSERT_OK(uv_ip_name(addr, dst, INET_ADDRSTRLEN));
ASSERT_OK(strcmp("192.168.0.1", dst));
/* test ip6_name */
ASSERT_EQ(0, uv_ip6_addr("fe80::2acf:daff:fedd:342a", TEST_PORT, addr6));
ASSERT_EQ(0, uv_ip6_name(addr6, dst, INET6_ADDRSTRLEN));
ASSERT_EQ(0, strcmp("fe80::2acf:daff:fedd:342a", dst));
ASSERT_OK(uv_ip6_addr("fe80::2acf:daff:fedd:342a", TEST_PORT, addr6));
ASSERT_OK(uv_ip6_name(addr6, dst, INET6_ADDRSTRLEN));
ASSERT_OK(strcmp("fe80::2acf:daff:fedd:342a", dst));
ASSERT_EQ(0, uv_ip_name(addr, dst, INET6_ADDRSTRLEN));
ASSERT_EQ(0, strcmp("fe80::2acf:daff:fedd:342a", dst));
ASSERT_OK(uv_ip_name(addr, dst, INET6_ADDRSTRLEN));
ASSERT_OK(strcmp("fe80::2acf:daff:fedd:342a", dst));
/* test other sa_family */
addr->sa_family = AF_UNIX;

26
deps/libuv/test/test-ip4-addr.c vendored
View File

@ -30,25 +30,25 @@ TEST_IMPL(ip4_addr) {
struct sockaddr_in addr;
char dst[16];
ASSERT(0 == uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF", dst, sizeof(dst)));
ASSERT(0 == strcmp(dst, "255.255.255.255"));
ASSERT(UV_ENOSPC == uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF",
dst, sizeof(dst) - 1));
ASSERT_OK(uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF", dst, sizeof(dst)));
ASSERT_OK(strcmp(dst, "255.255.255.255"));
ASSERT_EQ(UV_ENOSPC, uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF",
dst, sizeof(dst) - 1));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(0 == uv_ip4_addr("255.255.255.255", TEST_PORT, &addr));
ASSERT(UV_EINVAL == uv_ip4_addr("255.255.255*000", TEST_PORT, &addr));
ASSERT(UV_EINVAL == uv_ip4_addr("255.255.255.256", TEST_PORT, &addr));
ASSERT(UV_EINVAL == uv_ip4_addr("2555.0.0.0", TEST_PORT, &addr));
ASSERT(UV_EINVAL == uv_ip4_addr("255", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("255.255.255.255", TEST_PORT, &addr));
ASSERT_EQ(UV_EINVAL, uv_ip4_addr("255.255.255*000", TEST_PORT, &addr));
ASSERT_EQ(UV_EINVAL, uv_ip4_addr("255.255.255.256", TEST_PORT, &addr));
ASSERT_EQ(UV_EINVAL, uv_ip4_addr("2555.0.0.0", TEST_PORT, &addr));
ASSERT_EQ(UV_EINVAL, uv_ip4_addr("255", TEST_PORT, &addr));
#ifdef SIN6_LEN
ASSERT(addr.sin_len == sizeof(addr));
ASSERT_EQ(addr.sin_len, sizeof(addr));
#endif
/* for broken address family */
ASSERT(UV_EAFNOSUPPORT == uv_inet_pton(42, "127.0.0.1",
&addr.sin_addr.s_addr));
ASSERT_EQ(UV_EAFNOSUPPORT, uv_inet_pton(42, "127.0.0.1",
&addr.sin_addr.s_addr));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

50
deps/libuv/test/test-ip6-addr.c vendored
View File

@ -51,7 +51,7 @@ TEST_IMPL(ip6_addr_link_local) {
int ix;
int r;
ASSERT(0 == uv_interface_addresses(&addresses, &count));
ASSERT_OK(uv_interface_addresses(&addresses, &count));
for (ix = 0; ix < count; ix++) {
address = addresses + ix;
@ -59,10 +59,10 @@ TEST_IMPL(ip6_addr_link_local) {
if (address->address.address6.sin6_family != AF_INET6)
continue;
ASSERT(0 == uv_inet_ntop(AF_INET6,
&address->address.address6.sin6_addr,
string_address,
sizeof(string_address)));
ASSERT_OK(uv_inet_ntop(AF_INET6,
&address->address.address6.sin6_addr,
string_address,
sizeof(string_address)));
/* Skip addresses that are not link-local. */
if (strncmp(string_address, "fe80::", 6) != 0)
@ -72,21 +72,23 @@ TEST_IMPL(ip6_addr_link_local) {
device_name = address->name;
scoped_addr_len = sizeof(scoped_addr);
ASSERT(0 == uv_if_indextoname(iface_index, scoped_addr, &scoped_addr_len));
ASSERT_OK(uv_if_indextoname(iface_index,
scoped_addr,
&scoped_addr_len));
#ifndef _WIN32
/* This assert fails on Windows, as Windows semantics are different. */
ASSERT(0 == strcmp(device_name, scoped_addr));
ASSERT_OK(strcmp(device_name, scoped_addr));
#endif
interface_id_len = sizeof(interface_id);
r = uv_if_indextoiid(iface_index, interface_id, &interface_id_len);
ASSERT(0 == r);
ASSERT_OK(r);
#ifdef _WIN32
/* On Windows, the interface identifier is the numeric string of the index. */
ASSERT(strtoul(interface_id, NULL, 10) == iface_index);
ASSERT_EQ(strtoul(interface_id, NULL, 10), iface_index);
#else
/* On Unix/Linux, the interface identifier is the interface device name. */
ASSERT(0 == strcmp(device_name, interface_id));
ASSERT_OK(strcmp(device_name, interface_id));
#endif
snprintf(scoped_addr,
@ -102,16 +104,18 @@ TEST_IMPL(ip6_addr_link_local) {
device_name);
fflush(stderr);
ASSERT(0 == uv_ip6_addr(scoped_addr, TEST_PORT, &addr));
ASSERT_OK(uv_ip6_addr(scoped_addr, TEST_PORT, &addr));
fprintf(stderr, "Got scope_id 0x%2x\n", (unsigned)addr.sin6_scope_id);
fflush(stderr);
ASSERT(iface_index == addr.sin6_scope_id);
ASSERT_EQ(iface_index, addr.sin6_scope_id);
}
uv_free_interface_addresses(addresses, count);
scoped_addr_len = sizeof(scoped_addr);
ASSERT(0 != uv_if_indextoname((unsigned int)-1, scoped_addr, &scoped_addr_len));
ASSERT_NE(0, uv_if_indextoname((unsigned int)-1,
scoped_addr,
&scoped_addr_len));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -137,16 +141,16 @@ TEST_IMPL(ip6_addr_link_local) {
X("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255.255") \
#define TEST_GOOD(ADDR) \
ASSERT(0 == uv_inet_pton(AF_INET6, ADDR, &addr)); \
ASSERT(0 == uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \
ASSERT(0 == uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \
ASSERT(0 == uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \
ASSERT_OK(uv_inet_pton(AF_INET6, ADDR, &addr)); \
ASSERT_OK(uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \
ASSERT_OK(uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \
ASSERT_OK(uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \
#define TEST_BAD(ADDR) \
ASSERT(0 != uv_inet_pton(AF_INET6, ADDR, &addr)); \
ASSERT(0 != uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \
ASSERT(0 != uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \
ASSERT(0 != uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \
ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR, &addr)); \
ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \
ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \
ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \
TEST_IMPL(ip6_pton) {
struct in6_addr addr;
@ -163,9 +167,9 @@ TEST_IMPL(ip6_pton) {
TEST_IMPL(ip6_sin6_len) {
struct sockaddr_in6 s;
ASSERT_EQ(0, uv_ip6_addr("::", 0, &s));
ASSERT_OK(uv_ip6_addr("::", 0, &s));
#ifdef SIN6_LEN
ASSERT(s.sin6_len == sizeof(s));
ASSERT_EQ(s.sin6_len, sizeof(s));
#endif
return 0;
}

24
deps/libuv/test/test-ipc-heavy-traffic-deadlock-bug.c vendored
View File

@ -49,7 +49,7 @@ static size_t bytes_read;
static void write_cb(uv_write_t* req, int status) {
struct write_info* write_info =
container_of(req, struct write_info, write_req);
ASSERT(status == 0);
ASSERT_OK(status);
bytes_written += BUFFERS_PER_WRITE * BUFFER_SIZE;
free(write_info);
}
@ -75,7 +75,7 @@ static void do_write(uv_stream_t* handle) {
r = uv_write(
&write_info->write_req, handle, bufs, BUFFERS_PER_WRITE, write_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
static void alloc_cb(uv_handle_t* handle,
@ -94,18 +94,18 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
ssize_t i;
int r;
ASSERT(nread >= 0);
ASSERT_GE(nread, 0);
bytes_read += nread;
for (i = 0; i < nread; i++)
ASSERT(buf->base[i] == BUFFER_CONTENT);
ASSERT_EQ(buf->base[i], BUFFER_CONTENT);
free(buf->base);
if (bytes_read >= XFER_SIZE) {
r = uv_read_stop(handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_shutdown(&shutdown_req, handle, shutdown_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
}
@ -121,13 +121,13 @@ static void do_writes_and_reads(uv_stream_t* handle) {
}
r = uv_read_start(handle, alloc_cb, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_run(handle->loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(bytes_written == XFER_SIZE);
ASSERT(bytes_read == XFER_SIZE);
ASSERT_EQ(bytes_written, XFER_SIZE);
ASSERT_EQ(bytes_read, XFER_SIZE);
}
TEST_IMPL(ipc_heavy_traffic_deadlock_bug) {
@ -146,9 +146,9 @@ int ipc_helper_heavy_traffic_deadlock_bug(void) {
int r;
r = uv_pipe_init(uv_default_loop(), &pipe, 1);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_open(&pipe, 0);
ASSERT(r == 0);
ASSERT_OK(r);
notify_parent_process();
do_writes_and_reads((uv_stream_t*) &pipe);

100
deps/libuv/test/test-ipc-send-recv.c vendored
View File

@ -96,7 +96,7 @@ static void recv_cb(uv_stream_t* handle,
free(buf->base);
pipe = (uv_pipe_t*) handle;
ASSERT(pipe == &ctx.channel);
ASSERT_PTR_EQ(pipe, &ctx.channel);
do {
if (++recv_cb_count == 1) {
@ -112,13 +112,13 @@ static void recv_cb(uv_stream_t* handle,
* acceptable value. */
if (nread == UV_EOF) {
/* UV_EOF is only acceptable for the final recv_cb call */
ASSERT(recv_cb_count == 2);
ASSERT_EQ(2, recv_cb_count);
} else {
ASSERT(nread >= 0);
ASSERT(uv_pipe_pending_count(pipe) > 0);
ASSERT_GE(nread, 0);
ASSERT_GT(uv_pipe_pending_count(pipe), 0);
pending = uv_pipe_pending_type(pipe);
ASSERT(pending == ctx.expected_type);
ASSERT_EQ(pending, ctx.expected_type);
if (pending == UV_NAMED_PIPE)
r = uv_pipe_init(ctx.channel.loop, &recv->pipe, 0);
@ -126,10 +126,10 @@ static void recv_cb(uv_stream_t* handle,
r = uv_tcp_init(ctx.channel.loop, &recv->tcp);
else
abort();
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_accept(handle, &recv->stream);
ASSERT(r == 0);
ASSERT_OK(r);
}
} while (uv_pipe_pending_count(pipe) > 0);
@ -143,8 +143,8 @@ static void connect_cb(uv_connect_t* req, int status) {
int r;
uv_buf_t buf;
ASSERT(req == &ctx.connect_req);
ASSERT(status == 0);
ASSERT_PTR_EQ(req, &ctx.connect_req);
ASSERT_OK(status);
buf = uv_buf_init(".", 1);
r = uv_write2(&ctx.write_req,
@ -152,7 +152,7 @@ static void connect_cb(uv_connect_t* req, int status) {
&buf, 1,
&ctx.send.stream,
NULL);
ASSERT(r == 0);
ASSERT_OK(r);
/* Perform two writes to the same pipe to make sure that on Windows we are
* not running into issue 505:
@ -163,10 +163,10 @@ static void connect_cb(uv_connect_t* req, int status) {
&buf, 1,
&ctx.send2.stream,
NULL);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_read_start((uv_stream_t*)&ctx.channel, alloc_cb, recv_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
static int run_test(int inprocess) {
@ -176,12 +176,12 @@ static int run_test(int inprocess) {
if (inprocess) {
r = uv_thread_create(&tid, ipc_send_recv_helper_threadproc, (void *) 42);
ASSERT(r == 0);
ASSERT_OK(r);
uv_sleep(1000);
r = uv_pipe_init(uv_default_loop(), &ctx.channel, 1);
ASSERT(r == 0);
ASSERT_OK(r);
uv_pipe_connect(&ctx.connect_req, &ctx.channel, TEST_PIPENAME_3, connect_cb);
} else {
@ -191,13 +191,13 @@ static int run_test(int inprocess) {
}
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(recv_cb_count == 2);
ASSERT_EQ(2, recv_cb_count);
if (inprocess) {
r = uv_thread_join(&tid);
ASSERT(r == 0);
ASSERT_OK(r);
}
return 0;
@ -209,19 +209,19 @@ static int run_ipc_send_recv_pipe(int inprocess) {
ctx.expected_type = UV_NAMED_PIPE;
r = uv_pipe_init(uv_default_loop(), &ctx.send.pipe, 1);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&ctx.send.pipe, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_init(uv_default_loop(), &ctx.send2.pipe, 1);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&ctx.send2.pipe, TEST_PIPENAME_2);
ASSERT(r == 0);
ASSERT_OK(r);
r = run_test(inprocess);
ASSERT(r == 0);
ASSERT_OK(r);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -245,24 +245,24 @@ static int run_ipc_send_recv_tcp(int inprocess) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ctx.expected_type = UV_TCP;
r = uv_tcp_init(uv_default_loop(), &ctx.send.tcp);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_init(uv_default_loop(), &ctx.send2.tcp);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_bind(&ctx.send.tcp, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_bind(&ctx.send2.tcp, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = run_test(inprocess);
ASSERT(r == 0);
ASSERT_OK(r);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -286,7 +286,7 @@ TEST_IMPL(ipc_send_recv_tcp_inprocess) {
/* Everything here runs in a child process or second thread. */
static void write2_cb(uv_write_t* req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
/* After two successful writes in the child process, allow the child
* process to be closed. */
@ -317,7 +317,7 @@ static void read_cb(uv_stream_t* handle,
ASSERT_GE(nread, 0);
pipe = (uv_pipe_t*) handle;
ASSERT_EQ(pipe, &ctx2.channel);
ASSERT_PTR_EQ(pipe, &ctx2.channel);
while (uv_pipe_pending_count(pipe) > 0) {
if (++read_cb_count == 2) {
@ -337,10 +337,10 @@ static void read_cb(uv_stream_t* handle,
r = uv_tcp_init(ctx2.channel.loop, &recv->tcp);
else
abort();
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_accept(handle, &recv->stream);
ASSERT(r == 0);
ASSERT_OK(r);
wrbuf = uv_buf_init(".", 1);
r = uv_write2(write_req,
@ -349,27 +349,27 @@ static void read_cb(uv_stream_t* handle,
1,
&recv->stream,
write2_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
}
static void send_recv_start(void) {
int r;
ASSERT(1 == uv_is_readable((uv_stream_t*)&ctx2.channel));
ASSERT(1 == uv_is_writable((uv_stream_t*)&ctx2.channel));
ASSERT(0 == uv_is_closing((uv_handle_t*)&ctx2.channel));
ASSERT_EQ(1, uv_is_readable((uv_stream_t*)&ctx2.channel));
ASSERT_EQ(1, uv_is_writable((uv_stream_t*)&ctx2.channel));
ASSERT_OK(uv_is_closing((uv_handle_t*)&ctx2.channel));
r = uv_read_start((uv_stream_t*)&ctx2.channel, alloc_cb, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
static void listen_cb(uv_stream_t* handle, int status) {
int r;
ASSERT(handle == (uv_stream_t*)&ctx2.listen);
ASSERT(status == 0);
ASSERT_PTR_EQ(handle, (uv_stream_t*)&ctx2.listen);
ASSERT_OK(status);
r = uv_accept((uv_stream_t*)&ctx2.listen, (uv_stream_t*)&ctx2.channel);
ASSERT(r == 0);
ASSERT_OK(r);
send_recv_start();
}
@ -382,27 +382,27 @@ int run_ipc_send_recv_helper(uv_loop_t* loop, int inprocess) {
memset(&ctx2, 0, sizeof(ctx2));
r = uv_pipe_init(loop, &ctx2.listen, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_init(loop, &ctx2.channel, 1);
ASSERT(r == 0);
ASSERT_OK(r);
if (inprocess) {
r = uv_pipe_bind(&ctx2.listen, TEST_PIPENAME_3);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&ctx2.listen, SOMAXCONN, listen_cb);
ASSERT(r == 0);
ASSERT_OK(r);
} else {
r = uv_pipe_open(&ctx2.channel, 0);
ASSERT(r == 0);
ASSERT_OK(r);
send_recv_start();
}
notify_parent_process();
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
return 0;
}
@ -414,7 +414,7 @@ int ipc_send_recv_helper(void) {
int r;
r = run_ipc_send_recv_helper(uv_default_loop(), 0);
ASSERT(r == 0);
ASSERT_OK(r);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -425,11 +425,11 @@ void ipc_send_recv_helper_threadproc(void* arg) {
uv_loop_t loop;
r = uv_loop_init(&loop);
ASSERT(r == 0);
ASSERT_OK(r);
r = run_ipc_send_recv_helper(&loop, 1);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_loop_close(&loop);
ASSERT(r == 0);
ASSERT_OK(r);
}

216
deps/libuv/test/test-ipc.c vendored
View File

@ -68,16 +68,16 @@ static void on_connection(uv_stream_t* server, int status) {
if (!local_conn_accepted) {
/* Accept the connection and close it. Also and close the server. */
ASSERT_EQ(status, 0);
ASSERT_OK(status);
ASSERT_PTR_EQ(&tcp_server, server);
conn = malloc(sizeof(*conn));
ASSERT_NOT_NULL(conn);
r = uv_tcp_init(server->loop, conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept(server, (uv_stream_t*)conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)conn, close_server_conn_cb);
uv_close((uv_handle_t*)server, NULL);
@ -91,8 +91,8 @@ static void exit_cb(uv_process_t* process,
int term_signal) {
printf("exit_cb\n");
exit_cb_called++;
ASSERT_EQ(exit_status, 0);
ASSERT_EQ(term_signal, 0);
ASSERT_OK(exit_status);
ASSERT_OK(term_signal);
uv_close((uv_handle_t*)process, NULL);
}
@ -126,14 +126,14 @@ static void make_many_connections(void) {
ASSERT_NOT_NULL(conn);
r = uv_tcp_init(uv_default_loop(), &conn->conn);
ASSERT_EQ(r, 0);
ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(r);
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&conn->conn_req,
(uv_tcp_t*) &conn->conn,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
conn->conn.data = conn;
}
@ -179,13 +179,13 @@ static void on_read(uv_stream_t* handle,
/* Accept the pending TCP server, and start listening on it. */
ASSERT_EQ(pending, UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
tcp_server_listening = 1;
@ -194,13 +194,13 @@ static void on_read(uv_stream_t* handle,
outbuf = uv_buf_init("foobar\n", 7);
r = uv_write(&write_req, (uv_stream_t*)pipe, &outbuf, 1, NULL);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
/* Create a bunch of connections to get both servers to accept. */
make_many_connections();
} else if (memcmp("accepted_connection\n", buf->base, nread) == 0) {
/* Remote server has accepted a connection. Close the channel. */
ASSERT_EQ(0, uv_pipe_pending_count(pipe));
ASSERT_OK(uv_pipe_pending_count(pipe));
ASSERT_EQ(pending, UV_UNKNOWN_HANDLE);
remote_conn_accepted = 1;
uv_close((uv_handle_t*)&channel, NULL);
@ -248,28 +248,28 @@ static void on_read_listen_after_bound_twice(uv_stream_t* handle,
/* Accept the first TCP server, and start listening on it. */
ASSERT_EQ(pending, UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
} else if (read_cb_called == 2) {
/* Accept the second TCP server, and start listening on it. */
ASSERT_EQ(pending, UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server2);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server2);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&tcp_server2, BACKLOG, on_connection);
ASSERT_EQ(r, UV_EADDRINUSE);
uv_close((uv_handle_t*)&tcp_server, NULL);
uv_close((uv_handle_t*)&tcp_server2, NULL);
ASSERT_EQ(0, uv_pipe_pending_count(pipe));
ASSERT_OK(uv_pipe_pending_count(pipe));
uv_close((uv_handle_t*)&channel, NULL);
}
@ -288,12 +288,12 @@ void spawn_helper(uv_pipe_t* channel,
uv_stdio_container_t stdio[3];
r = uv_pipe_init(uv_default_loop(), channel, 1);
ASSERT_EQ(r, 0);
ASSERT_NE(channel->ipc, 0);
ASSERT_OK(r);
ASSERT_NE(0, channel->ipc);
exepath_size = sizeof(exepath);
r = uv_exepath(exepath, &exepath_size);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
exepath[exepath_size] = '\0';
args[0] = exepath;
@ -315,12 +315,12 @@ void spawn_helper(uv_pipe_t* channel,
stdio[2].data.fd = 2;
r = uv_spawn(uv_default_loop(), process, &options);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
}
static void on_tcp_write(uv_write_t* req, int status) {
ASSERT_EQ(status, 0);
ASSERT_OK(status);
ASSERT_PTR_EQ(req->handle, &tcp_connection);
tcp_write_cb_called++;
}
@ -385,10 +385,10 @@ static void on_read_connection(uv_stream_t* handle,
/* Accept the pending TCP connection */
ASSERT_EQ(pending, UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_connection);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept(handle, (uv_stream_t*)&tcp_connection);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
/* Make sure that the expected data is correctly multiplexed. */
ASSERT_MEM_EQ("hello\n", buf->base, nread);
@ -397,10 +397,10 @@ static void on_read_connection(uv_stream_t* handle,
outbuf = uv_buf_init("world\n", 6);
r = uv_write(&write_req, (uv_stream_t*)&tcp_connection, &outbuf, 1,
on_tcp_write);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_read_start((uv_stream_t*)&tcp_connection, on_read_alloc, on_tcp_read);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
free(buf->base);
}
@ -422,7 +422,7 @@ static int run_ipc_test(const char* helper, uv_read_cb read_cb) {
uv_read_start((uv_stream_t*)&channel, on_alloc, read_cb);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -434,10 +434,10 @@ TEST_IMPL(ipc_listen_before_write) {
RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
#endif
int r = run_ipc_test("ipc_helper_listen_before_write", on_read);
ASSERT_EQ(local_conn_accepted, 1);
ASSERT_EQ(remote_conn_accepted, 1);
ASSERT_EQ(read_cb_called, 1);
ASSERT_EQ(exit_cb_called, 1);
ASSERT_EQ(1, local_conn_accepted);
ASSERT_EQ(1, remote_conn_accepted);
ASSERT_EQ(1, read_cb_called);
ASSERT_EQ(1, exit_cb_called);
return r;
}
@ -447,10 +447,10 @@ TEST_IMPL(ipc_listen_after_write) {
RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
#endif
int r = run_ipc_test("ipc_helper_listen_after_write", on_read);
ASSERT_EQ(local_conn_accepted, 1);
ASSERT_EQ(remote_conn_accepted, 1);
ASSERT_EQ(read_cb_called, 1);
ASSERT_EQ(exit_cb_called, 1);
ASSERT_EQ(1, local_conn_accepted);
ASSERT_EQ(1, remote_conn_accepted);
ASSERT_EQ(1, read_cb_called);
ASSERT_EQ(1, exit_cb_called);
return r;
}
@ -460,10 +460,10 @@ TEST_IMPL(ipc_tcp_connection) {
RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
#endif
int r = run_ipc_test("ipc_helper_tcp_connection", on_read_connection);
ASSERT_EQ(read_cb_called, 1);
ASSERT_EQ(tcp_write_cb_called, 1);
ASSERT_EQ(tcp_read_cb_called, 1);
ASSERT_EQ(exit_cb_called, 1);
ASSERT_EQ(1, read_cb_called);
ASSERT_EQ(1, tcp_write_cb_called);
ASSERT_EQ(1, tcp_read_cb_called);
ASSERT_EQ(1, exit_cb_called);
return r;
}
@ -474,20 +474,20 @@ TEST_IMPL(listen_with_simultaneous_accepts) {
int r;
struct sockaddr_in addr;
ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_simultaneous_accepts(&server, 1);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL);
ASSERT_EQ(r, 0);
ASSERT_EQ(server.reqs_pending, 32);
ASSERT_OK(r);
ASSERT_EQ(32, server.reqs_pending);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -499,20 +499,20 @@ TEST_IMPL(listen_no_simultaneous_accepts) {
int r;
struct sockaddr_in addr;
ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_simultaneous_accepts(&server, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL);
ASSERT_EQ(r, 0);
ASSERT_EQ(server.reqs_pending, 1);
ASSERT_OK(r);
ASSERT_EQ(1, server.reqs_pending);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -523,8 +523,8 @@ TEST_IMPL(ipc_listen_after_bind_twice) {
RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
#endif
int r = run_ipc_test("ipc_helper_bind_twice", on_read_listen_after_bound_twice);
ASSERT_EQ(read_cb_called, 2);
ASSERT_EQ(exit_cb_called, 1);
ASSERT_EQ(2, read_cb_called);
ASSERT_EQ(1, exit_cb_called);
return r;
}
#endif
@ -532,7 +532,7 @@ TEST_IMPL(ipc_listen_after_bind_twice) {
TEST_IMPL(ipc_send_zero) {
int r;
r = run_ipc_test("ipc_helper_send_zero", on_read_send_zero);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
return 0;
}
@ -563,7 +563,7 @@ static void tcp_connection_write_cb(uv_write_t* req, int status) {
static void send_zero_write_cb(uv_write_t* req, int status) {
ASSERT_EQ(status, 0);
ASSERT_OK(status);
send_zero_write++;
}
@ -591,7 +591,7 @@ static void on_tcp_child_process_read(uv_stream_t* tcp,
/* Write to the socket */
outbuf = uv_buf_init("hello again\n", 12);
r = uv_write(&conn.tcp_write_req, tcp, &outbuf, 1, tcp_connection_write_cb);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
tcp_conn_read_cb_called++;
}
@ -600,9 +600,9 @@ static void on_tcp_child_process_read(uv_stream_t* tcp,
static void connect_child_process_cb(uv_connect_t* req, int status) {
int r;
ASSERT_EQ(status, 0);
ASSERT_OK(status);
r = uv_read_start(req->handle, on_read_alloc, on_tcp_child_process_read);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
}
@ -615,21 +615,21 @@ static void ipc_on_connection(uv_stream_t* server, int status) {
* Accept the connection and close it. Also let the other
* side know.
*/
ASSERT_EQ(status, 0);
ASSERT_OK(status);
ASSERT_PTR_EQ(&tcp_server, server);
r = uv_tcp_init(server->loop, &conn.conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept(server, (uv_stream_t*)&conn.conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)&conn.conn, close_cb);
buf = uv_buf_init("accepted_connection\n", 20);
r = uv_write2(&conn_notify_req, (uv_stream_t*)&channel, &buf, 1,
NULL, conn_notify_write_cb);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
connection_accepted = 1;
}
@ -646,28 +646,28 @@ static void ipc_on_connection_tcp_conn(uv_stream_t* server, int status) {
uv_buf_t buf;
uv_tcp_t* conn;
ASSERT_EQ(status, 0);
ASSERT_OK(status);
ASSERT_PTR_EQ(&tcp_server, server);
conn = malloc(sizeof(*conn));
ASSERT_NOT_NULL(conn);
r = uv_tcp_init(server->loop, conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept(server, (uv_stream_t*)conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
/* Send the accepted connection to the other process */
buf = uv_buf_init("hello\n", 6);
r = uv_write2(&conn_notify_req, (uv_stream_t*)&channel, &buf, 1,
(uv_stream_t*)conn, NULL);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_read_start((uv_stream_t*) conn,
on_read_alloc,
on_tcp_child_process_read);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)conn, close_and_free_cb);
}
@ -682,44 +682,44 @@ int ipc_helper(int listen_after_write) {
int r;
uv_buf_t buf;
ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_pipe_init(uv_default_loop(), &channel, 1);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_pipe_open(&channel, 0);
ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel));
ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
if (!listen_after_write) {
r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
}
buf = uv_buf_init("hello\n", 6);
r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1,
(uv_stream_t*)&tcp_server, NULL);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
if (listen_after_write) {
r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
}
notify_parent_process();
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(connection_accepted, 1);
ASSERT_EQ(close_cb_called, 3);
ASSERT_EQ(1, connection_accepted);
ASSERT_EQ(3, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -736,43 +736,43 @@ int ipc_helper_tcp_connection(void) {
struct sockaddr_in addr;
r = uv_pipe_init(uv_default_loop(), &channel, 1);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_pipe_open(&channel, 0);
ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel));
ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection_tcp_conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
/* Make a connection to the server */
r = uv_tcp_init(uv_default_loop(), &conn.conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_connect(&conn.conn_req,
(uv_tcp_t*) &conn.conn,
(const struct sockaddr*) &addr,
connect_child_process_cb);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(tcp_conn_read_cb_called, 1);
ASSERT_EQ(tcp_conn_write_cb_called, 1);
ASSERT_EQ(close_cb_called, 4);
ASSERT_EQ(1, tcp_conn_read_cb_called);
ASSERT_EQ(1, tcp_conn_write_cb_called);
ASSERT_EQ(4, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -787,38 +787,38 @@ int ipc_helper_bind_twice(void) {
int r;
uv_buf_t buf;
ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_pipe_init(uv_default_loop(), &channel, 1);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_pipe_open(&channel, 0);
ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel));
ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
buf = uv_buf_init("hello\n", 6);
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_init(uv_default_loop(), &tcp_server2);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_tcp_bind(&tcp_server2, (const struct sockaddr*) &addr, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1,
(uv_stream_t*)&tcp_server, NULL);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_write2(&write_req2, (uv_stream_t*)&channel, &buf, 1,
(uv_stream_t*)&tcp_server2, NULL);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -831,13 +831,13 @@ int ipc_helper_send_zero(void) {
zero_buf = uv_buf_init(0, 0);
r = uv_pipe_init(uv_default_loop(), &channel, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_pipe_open(&channel, 0);
ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel));
ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
r = uv_write(&write_req,
(uv_stream_t*)&channel,
@ -845,12 +845,12 @@ int ipc_helper_send_zero(void) {
1,
send_zero_write_cb);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(send_zero_write, 1);
ASSERT_EQ(1, send_zero_write);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

11
deps/libuv/test/test-list.h vendored
View File

@ -127,6 +127,8 @@ TEST_DECLARE (tcp_bind_writable_flags)
TEST_DECLARE (tcp_bind_or_listen_error_after_close)
TEST_DECLARE (tcp_listen_without_bind)
TEST_DECLARE (tcp_connect_error_fault)
TEST_DECLARE (tcp_connect6_error_fault)
TEST_DECLARE (tcp_connect6_link_local)
TEST_DECLARE (tcp_connect_timeout)
TEST_DECLARE (tcp_local_connect_timeout)
TEST_DECLARE (tcp6_local_connect_timeout)
@ -321,6 +323,7 @@ TEST_DECLARE (spawn_detached)
TEST_DECLARE (spawn_and_kill_with_std)
TEST_DECLARE (spawn_and_ping)
TEST_DECLARE (spawn_preserve_env)
TEST_DECLARE (spawn_same_stdout_stderr)
TEST_DECLARE (spawn_setuid_fails)
TEST_DECLARE (spawn_setgid_fails)
TEST_DECLARE (spawn_stdout_to_file)
@ -501,6 +504,7 @@ TEST_DECLARE (listen_with_simultaneous_accepts)
TEST_DECLARE (listen_no_simultaneous_accepts)
TEST_DECLARE (fs_stat_root)
TEST_DECLARE (spawn_with_an_odd_path)
TEST_DECLARE (spawn_no_path)
TEST_DECLARE (ipc_listen_after_bind_twice)
TEST_DECLARE (win32_signum_number)
#else
@ -542,6 +546,7 @@ TEST_DECLARE (fork_socketpair)
TEST_DECLARE (fork_socketpair_started)
TEST_DECLARE (fork_signal_to_child)
TEST_DECLARE (fork_signal_to_child_closed)
TEST_DECLARE (fork_close_signal_in_child)
#ifndef __APPLE__ /* This is forbidden in a fork child: The process has forked
and you cannot use this CoreFoundation functionality
safely. You MUST exec(). */
@ -724,6 +729,8 @@ TASK_LIST_START
TEST_ENTRY (tcp_bind_or_listen_error_after_close)
TEST_ENTRY (tcp_listen_without_bind)
TEST_ENTRY (tcp_connect_error_fault)
TEST_ENTRY (tcp_connect6_error_fault)
TEST_ENTRY (tcp_connect6_link_local)
TEST_ENTRY (tcp_connect_timeout)
TEST_ENTRY (tcp_local_connect_timeout)
TEST_ENTRY (tcp6_local_connect_timeout)
@ -977,6 +984,7 @@ TASK_LIST_START
TEST_ENTRY (spawn_and_kill_with_std)
TEST_ENTRY (spawn_and_ping)
TEST_ENTRY (spawn_preserve_env)
TEST_ENTRY (spawn_same_stdout_stderr)
TEST_ENTRY (spawn_setuid_fails)
TEST_ENTRY (spawn_setgid_fails)
TEST_ENTRY (spawn_stdout_to_file)
@ -1015,6 +1023,7 @@ TASK_LIST_START
TEST_ENTRY (listen_no_simultaneous_accepts)
TEST_ENTRY (fs_stat_root)
TEST_ENTRY (spawn_with_an_odd_path)
TEST_ENTRY (spawn_no_path)
TEST_ENTRY (ipc_listen_after_bind_twice)
TEST_ENTRY (win32_signum_number)
#else
@ -1055,6 +1064,7 @@ TASK_LIST_START
TEST_ENTRY (fs_unlink_archive_readonly)
#endif
TEST_ENTRY (fs_chown)
TEST_ENTRY (fs_link)
TEST_ENTRY (fs_utime)
TEST_ENTRY (fs_utime_round)
TEST_ENTRY (fs_futime)
@ -1175,6 +1185,7 @@ TASK_LIST_START
TEST_ENTRY (fork_socketpair_started)
TEST_ENTRY (fork_signal_to_child)
TEST_ENTRY (fork_signal_to_child_closed)
TEST_ENTRY (fork_close_signal_in_child)
#ifndef __APPLE__
TEST_ENTRY (fork_fs_events_child)
TEST_ENTRY (fork_fs_events_child_dir)

8
deps/libuv/test/test-loop-alive.c vendored
View File

@ -37,7 +37,7 @@ static void work_cb(uv_work_t* req) {
static void after_work_cb(uv_work_t* req, int status) {
ASSERT(req);
ASSERT(status == 0);
ASSERT_OK(status);
}
@ -51,16 +51,16 @@ TEST_IMPL(loop_alive) {
ASSERT(uv_loop_alive(uv_default_loop()));
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(!uv_loop_alive(uv_default_loop()));
/* loops with requests are alive */
r = uv_queue_work(uv_default_loop(), &work_req, work_cb, after_work_cb);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(uv_loop_alive(uv_default_loop()));
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(!uv_loop_alive(uv_default_loop()));
MAKE_VALGRIND_HAPPY(uv_default_loop());

24
deps/libuv/test/test-loop-close.c vendored
View File

@ -35,23 +35,23 @@ TEST_IMPL(loop_close) {
uv_loop_t loop;
loop.data = &loop;
ASSERT(0 == uv_loop_init(&loop));
ASSERT(loop.data == (void*) &loop);
ASSERT_OK(uv_loop_init(&loop));
ASSERT_PTR_EQ(loop.data, (void*) &loop);
uv_timer_init(&loop, &timer_handle);
uv_timer_start(&timer_handle, timer_cb, 100, 100);
ASSERT(UV_EBUSY == uv_loop_close(&loop));
ASSERT_EQ(UV_EBUSY, uv_loop_close(&loop));
uv_run(&loop, UV_RUN_DEFAULT);
uv_close((uv_handle_t*) &timer_handle, NULL);
r = uv_run(&loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(loop.data == (void*) &loop);
ASSERT(0 == uv_loop_close(&loop));
ASSERT(loop.data == (void*) &loop);
ASSERT_PTR_EQ(loop.data, (void*) &loop);
ASSERT_OK(uv_loop_close(&loop));
ASSERT_PTR_EQ(loop.data, (void*) &loop);
return 0;
}
@ -67,11 +67,11 @@ static void loop_instant_close_after_work_cb(uv_work_t* req, int status) {
TEST_IMPL(loop_instant_close) {
static uv_loop_t loop;
static uv_work_t req;
ASSERT(0 == uv_loop_init(&loop));
ASSERT(0 == uv_queue_work(&loop,
&req,
loop_instant_close_work_cb,
loop_instant_close_after_work_cb));
ASSERT_OK(uv_loop_init(&loop));
ASSERT_OK(uv_queue_work(&loop,
&req,
loop_instant_close_work_cb,
loop_instant_close_after_work_cb));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
}

14
deps/libuv/test/test-loop-configure.c vendored
View File

@ -24,15 +24,15 @@ static void timer_cb(uv_timer_t* handle) {
TEST_IMPL(loop_configure) {
uv_timer_t timer_handle;
uv_loop_t loop;
ASSERT(0 == uv_loop_init(&loop));
ASSERT_OK(uv_loop_init(&loop));
#ifdef _WIN32
ASSERT(UV_ENOSYS == uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, 0));
ASSERT_EQ(UV_ENOSYS, uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, 0));
#else
ASSERT(0 == uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, SIGPROF));
ASSERT_OK(uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, SIGPROF));
#endif
ASSERT(0 == uv_timer_init(&loop, &timer_handle));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 10, 0));
ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT));
ASSERT(0 == uv_loop_close(&loop));
ASSERT_OK(uv_timer_init(&loop, &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 10, 0));
ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_loop_close(&loop));
return 0;
}

72
deps/libuv/test/test-loop-handles.c vendored
View File

@ -108,7 +108,7 @@ static int idle_2_is_active = 0;
static void timer_cb(uv_timer_t* handle) {
ASSERT(handle == &timer_handle);
ASSERT_PTR_EQ(handle, &timer_handle);
}
@ -116,7 +116,7 @@ static void idle_2_close_cb(uv_handle_t* handle) {
fprintf(stderr, "%s", "IDLE_2_CLOSE_CB\n");
fflush(stderr);
ASSERT(handle == (uv_handle_t*)&idle_2_handle);
ASSERT_PTR_EQ(handle, (uv_handle_t*)&idle_2_handle);
ASSERT(idle_2_is_active);
@ -129,7 +129,7 @@ static void idle_2_cb(uv_idle_t* handle) {
fprintf(stderr, "%s", "IDLE_2_CB\n");
fflush(stderr);
ASSERT(handle == &idle_2_handle);
ASSERT_PTR_EQ(handle, &idle_2_handle);
idle_2_cb_called++;
@ -144,14 +144,14 @@ static void idle_1_cb(uv_idle_t* handle) {
fflush(stderr);
ASSERT_NOT_NULL(handle);
ASSERT(idles_1_active > 0);
ASSERT_GT(idles_1_active, 0);
/* Init idle_2 and make it active */
if (!idle_2_is_active && !uv_is_closing((uv_handle_t*)&idle_2_handle)) {
r = uv_idle_init(uv_default_loop(), &idle_2_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_idle_start(&idle_2_handle, idle_2_cb);
ASSERT(r == 0);
ASSERT_OK(r);
idle_2_is_active = 1;
idle_2_cb_started++;
}
@ -160,7 +160,7 @@ static void idle_1_cb(uv_idle_t* handle) {
if (idle_1_cb_called % 5 == 0) {
r = uv_idle_stop((uv_idle_t*)handle);
ASSERT(r == 0);
ASSERT_OK(r);
idles_1_active--;
}
}
@ -179,7 +179,7 @@ static void idle_1_close_cb(uv_handle_t* handle) {
static void prepare_1_close_cb(uv_handle_t* handle) {
fprintf(stderr, "%s", "PREPARE_1_CLOSE_CB");
fflush(stderr);
ASSERT(handle == (uv_handle_t*)&prepare_1_handle);
ASSERT_PTR_EQ(handle, (uv_handle_t*)&prepare_1_handle);
prepare_1_close_cb_called++;
}
@ -188,7 +188,7 @@ static void prepare_1_close_cb(uv_handle_t* handle) {
static void check_close_cb(uv_handle_t* handle) {
fprintf(stderr, "%s", "CHECK_CLOSE_CB\n");
fflush(stderr);
ASSERT(handle == (uv_handle_t*)&check_handle);
ASSERT_PTR_EQ(handle, (uv_handle_t*)&check_handle);
check_close_cb_called++;
}
@ -197,7 +197,7 @@ static void check_close_cb(uv_handle_t* handle) {
static void prepare_2_close_cb(uv_handle_t* handle) {
fprintf(stderr, "%s", "PREPARE_2_CLOSE_CB\n");
fflush(stderr);
ASSERT(handle == (uv_handle_t*)&prepare_2_handle);
ASSERT_PTR_EQ(handle, (uv_handle_t*)&prepare_2_handle);
prepare_2_close_cb_called++;
}
@ -208,13 +208,13 @@ static void check_cb(uv_check_t* handle) {
fprintf(stderr, "%s", "CHECK_CB\n");
fflush(stderr);
ASSERT(handle == &check_handle);
ASSERT_PTR_EQ(handle, &check_handle);
if (loop_iteration < ITERATIONS) {
/* Make some idle watchers active */
for (i = 0; i < 1 + (loop_iteration % IDLE_COUNT); i++) {
r = uv_idle_start(&idle_1_handles[i], idle_1_cb);
ASSERT(r == 0);
ASSERT_OK(r);
idles_1_active++;
}
@ -244,16 +244,16 @@ static void prepare_2_cb(uv_prepare_t* handle) {
fprintf(stderr, "%s", "PREPARE_2_CB\n");
fflush(stderr);
ASSERT(handle == &prepare_2_handle);
ASSERT_PTR_EQ(handle, &prepare_2_handle);
/* Prepare_2 gets started by prepare_1 when (loop_iteration % 2 == 0), and it
* stops itself immediately. A started watcher is not queued until the next
* round, so when this callback is made (loop_iteration % 2 == 0) cannot be
* true. */
ASSERT(loop_iteration % 2 != 0);
ASSERT_NE(0, loop_iteration % 2);
r = uv_prepare_stop((uv_prepare_t*)handle);
ASSERT(r == 0);
ASSERT_OK(r);
prepare_2_cb_called++;
}
@ -264,11 +264,11 @@ static void prepare_1_cb(uv_prepare_t* handle) {
fprintf(stderr, "%s", "PREPARE_1_CB\n");
fflush(stderr);
ASSERT(handle == &prepare_1_handle);
ASSERT_PTR_EQ(handle, &prepare_1_handle);
if (loop_iteration % 2 == 0) {
r = uv_prepare_start(&prepare_2_handle, prepare_2_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
prepare_1_cb_called++;
@ -283,23 +283,23 @@ TEST_IMPL(loop_handles) {
int r;
r = uv_prepare_init(uv_default_loop(), &prepare_1_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_prepare_start(&prepare_1_handle, prepare_1_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_check_init(uv_default_loop(), &check_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_check_start(&check_handle, check_cb);
ASSERT(r == 0);
ASSERT_OK(r);
/* initialize only, prepare_2 is started by prepare_1_cb */
r = uv_prepare_init(uv_default_loop(), &prepare_2_handle);
ASSERT(r == 0);
ASSERT_OK(r);
for (i = 0; i < IDLE_COUNT; i++) {
/* initialize only, idle_1 handles are started by check_cb */
r = uv_idle_init(uv_default_loop(), &idle_1_handles[i]);
ASSERT(r == 0);
ASSERT_OK(r);
}
/* don't init or start idle_2, both is done by idle_1_cb */
@ -307,30 +307,30 @@ TEST_IMPL(loop_handles) {
/* The timer callback is there to keep the event loop polling unref it as it
* is not supposed to keep the loop alive */
r = uv_timer_init(uv_default_loop(), &timer_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_timer_start(&timer_handle, timer_cb, TIMEOUT, TIMEOUT);
ASSERT(r == 0);
ASSERT_OK(r);
uv_unref((uv_handle_t*)&timer_handle);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(loop_iteration == ITERATIONS);
ASSERT_EQ(loop_iteration, ITERATIONS);
ASSERT(prepare_1_cb_called == ITERATIONS);
ASSERT(prepare_1_close_cb_called == 1);
ASSERT_EQ(prepare_1_cb_called, ITERATIONS);
ASSERT_EQ(1, prepare_1_close_cb_called);
ASSERT(prepare_2_cb_called == ITERATIONS / 2);
ASSERT(prepare_2_close_cb_called == 1);
ASSERT_EQ(prepare_2_cb_called, ITERATIONS / 2);
ASSERT_EQ(1, prepare_2_close_cb_called);
ASSERT(check_cb_called == ITERATIONS);
ASSERT(check_close_cb_called == 1);
ASSERT_EQ(check_cb_called, ITERATIONS);
ASSERT_EQ(1, check_close_cb_called);
/* idle_1_cb should be called a lot */
ASSERT(idle_1_close_cb_called == IDLE_COUNT);
ASSERT_EQ(idle_1_close_cb_called, IDLE_COUNT);
ASSERT(idle_2_close_cb_called == idle_2_cb_started);
ASSERT(idle_2_is_active == 0);
ASSERT_EQ(idle_2_close_cb_called, idle_2_cb_started);
ASSERT_OK(idle_2_is_active);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

20
deps/libuv/test/test-loop-stop.c vendored
View File

@ -30,7 +30,7 @@ static int num_ticks = 10;
static void prepare_cb(uv_prepare_t* handle) {
ASSERT(handle == &prepare_handle);
ASSERT_PTR_EQ(handle, &prepare_handle);
prepare_called++;
if (prepare_called == num_ticks)
uv_prepare_stop(handle);
@ -38,7 +38,7 @@ static void prepare_cb(uv_prepare_t* handle) {
static void timer_cb(uv_timer_t* handle) {
ASSERT(handle == &timer_handle);
ASSERT_PTR_EQ(handle, &timer_handle);
timer_called++;
if (timer_called == 1)
uv_stop(uv_default_loop());
@ -55,17 +55,17 @@ TEST_IMPL(loop_stop) {
uv_timer_start(&timer_handle, timer_cb, 100, 100);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r != 0);
ASSERT(timer_called == 1);
ASSERT(r);
ASSERT_EQ(1, timer_called);
r = uv_run(uv_default_loop(), UV_RUN_NOWAIT);
ASSERT(r != 0);
ASSERT(prepare_called > 1);
ASSERT(r);
ASSERT_GT(prepare_called, 1);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(timer_called == 10);
ASSERT(prepare_called == 10);
ASSERT_OK(r);
ASSERT_EQ(10, timer_called);
ASSERT_EQ(10, prepare_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -76,7 +76,7 @@ TEST_IMPL(loop_stop_before_run) {
ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle));
ASSERT_OK(uv_timer_start(&timer_handle, (uv_timer_cb) abort, 0, 0));
uv_stop(uv_default_loop());
ASSERT_NE(uv_run(uv_default_loop(), UV_RUN_DEFAULT), 0);
ASSERT_NE(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

20
deps/libuv/test/test-loop-time.c vendored
View File

@ -28,7 +28,7 @@ TEST_IMPL(loop_update_time) {
start = uv_now(uv_default_loop());
while (uv_now(uv_default_loop()) - start < 1000)
ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_NOWAIT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_NOWAIT));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -46,23 +46,23 @@ TEST_IMPL(loop_backend_timeout) {
/* The default loop has some internal watchers to initialize. */
loop->active_handles++;
r = uv_run(loop, UV_RUN_NOWAIT);
ASSERT_EQ(r, 1);
ASSERT_EQ(1, r);
loop->active_handles--;
ASSERT_EQ(uv_loop_alive(loop), 0);
ASSERT_OK(uv_loop_alive(loop));
r = uv_timer_init(loop, &timer);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
ASSERT_EQ(uv_loop_alive(loop), 0);
ASSERT_EQ(uv_backend_timeout(loop), 0);
ASSERT_OK(uv_loop_alive(loop));
ASSERT_OK(uv_backend_timeout(loop));
r = uv_timer_start(&timer, cb, 1000, 0); /* 1 sec */
ASSERT_EQ(r, 0);
ASSERT_EQ(uv_backend_timeout(loop), 1000);
ASSERT_OK(r);
ASSERT_EQ(1000, uv_backend_timeout(loop));
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT_EQ(r, 0);
ASSERT_EQ(uv_backend_timeout(loop), 0);
ASSERT_OK(r);
ASSERT_OK(uv_backend_timeout(loop));
MAKE_VALGRIND_HAPPY(loop);
return 0;

80
deps/libuv/test/test-metrics.c vendored
View File

@ -59,11 +59,11 @@ TEST_IMPL(metrics_idle_time) {
cntr = 0;
timer.data = &cntr;
ASSERT_EQ(0, uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME));
ASSERT_EQ(0, uv_timer_init(uv_default_loop(), &timer));
ASSERT_EQ(0, uv_timer_start(&timer, timer_spin_cb, timeout, 0));
ASSERT_OK(uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME));
ASSERT_OK(uv_timer_init(uv_default_loop(), &timer));
ASSERT_OK(uv_timer_start(&timer, timer_spin_cb, timeout, 0));
ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_GT(cntr, 0);
idle_time = uv_metrics_idle_time(uv_default_loop());
@ -87,12 +87,12 @@ static void metrics_routine_cb(void* arg) {
cntr = 0;
timer.data = &cntr;
ASSERT_EQ(0, uv_loop_init(&loop));
ASSERT_EQ(0, uv_loop_configure(&loop, UV_METRICS_IDLE_TIME));
ASSERT_EQ(0, uv_timer_init(&loop, &timer));
ASSERT_EQ(0, uv_timer_start(&timer, timer_spin_cb, timeout, 0));
ASSERT_OK(uv_loop_init(&loop));
ASSERT_OK(uv_loop_configure(&loop, UV_METRICS_IDLE_TIME));
ASSERT_OK(uv_timer_init(&loop, &timer));
ASSERT_OK(uv_timer_start(&timer, timer_spin_cb, timeout, 0));
ASSERT_EQ(0, uv_run(&loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
ASSERT_GT(cntr, 0);
idle_time = uv_metrics_idle_time(&loop);
@ -104,7 +104,7 @@ static void metrics_routine_cb(void* arg) {
ASSERT_GE(idle_time, (timeout - 500) * UV_NS_TO_MS);
close_loop(&loop);
ASSERT_EQ(0, uv_loop_close(&loop));
ASSERT_OK(uv_loop_close(&loop));
}
@ -113,7 +113,7 @@ TEST_IMPL(metrics_idle_time_thread) {
int i;
for (i = 0; i < 5; i++) {
ASSERT_EQ(0, uv_thread_create(&threads[i], metrics_routine_cb, NULL));
ASSERT_OK(uv_thread_create(&threads[i], metrics_routine_cb, NULL));
}
for (i = 0; i < 5; i++) {
@ -136,16 +136,16 @@ TEST_IMPL(metrics_idle_time_zero) {
cntr = 0;
timer.data = &cntr;
ASSERT_EQ(0, uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME));
ASSERT_EQ(0, uv_timer_init(uv_default_loop(), &timer));
ASSERT_EQ(0, uv_timer_start(&timer, timer_noop_cb, 0, 0));
ASSERT_OK(uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME));
ASSERT_OK(uv_timer_init(uv_default_loop(), &timer));
ASSERT_OK(uv_timer_start(&timer, timer_noop_cb, 0, 0));
ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_GT(cntr, 0);
ASSERT_EQ(0, uv_metrics_idle_time(uv_default_loop()));
ASSERT_OK(uv_metrics_idle_time(uv_default_loop()));
ASSERT_EQ(0, uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_UINT64_EQ(cntr, metrics.loop_count);
MAKE_VALGRIND_HAPPY(uv_default_loop());
@ -156,7 +156,7 @@ TEST_IMPL(metrics_idle_time_zero) {
static void close_cb(uv_fs_t* req) {
uv_metrics_t metrics;
ASSERT_EQ(0, uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_UINT64_EQ(3, metrics.loop_count);
ASSERT_UINT64_GT(metrics.events, last_events_count);
@ -168,7 +168,7 @@ static void close_cb(uv_fs_t* req) {
static void write_cb(uv_fs_t* req) {
uv_metrics_t metrics;
ASSERT_EQ(0, uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_UINT64_EQ(2, metrics.loop_count);
ASSERT_UINT64_GT(metrics.events, last_events_count);
ASSERT_EQ(req->result, sizeof(test_buf));
@ -176,17 +176,17 @@ static void write_cb(uv_fs_t* req) {
uv_fs_req_cleanup(req);
last_events_count = metrics.events;
ASSERT_EQ(0, uv_fs_close(uv_default_loop(),
&fs_reqs.close_req,
fs_reqs.open_req.result,
close_cb));
ASSERT_OK(uv_fs_close(uv_default_loop(),
&fs_reqs.close_req,
fs_reqs.open_req.result,
close_cb));
}
static void create_cb(uv_fs_t* req) {
uv_metrics_t metrics;
ASSERT_EQ(0, uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics));
/* Event count here is still 0 so not going to check. */
ASSERT_UINT64_EQ(1, metrics.loop_count);
ASSERT_GE(req->result, 0);
@ -195,13 +195,13 @@ static void create_cb(uv_fs_t* req) {
last_events_count = metrics.events;
uv_buf_t iov = uv_buf_init(test_buf, sizeof(test_buf));
ASSERT_EQ(0, uv_fs_write(uv_default_loop(),
&fs_reqs.write_req,
req->result,
&iov,
1,
0,
write_cb));
ASSERT_OK(uv_fs_write(uv_default_loop(),
&fs_reqs.write_req,
req->result,
&iov,
1,
0,
write_cb));
}
@ -210,15 +210,15 @@ static void prepare_cb(uv_prepare_t* handle) {
uv_prepare_stop(handle);
ASSERT_EQ(0, uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics));
ASSERT_UINT64_EQ(0, metrics.loop_count);
ASSERT_UINT64_EQ(0, metrics.events);
ASSERT_EQ(0, uv_fs_open(uv_default_loop(),
&fs_reqs.open_req,
"test_file",
O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR,
create_cb));
ASSERT_OK(uv_fs_open(uv_default_loop(),
&fs_reqs.open_req,
"test_file",
O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR,
create_cb));
}
@ -229,10 +229,10 @@ TEST_IMPL(metrics_info_check) {
uv_fs_unlink(NULL, &unlink_req, "test_file", NULL);
uv_fs_req_cleanup(&unlink_req);
ASSERT_EQ(0, uv_prepare_init(uv_default_loop(), &prepare));
ASSERT_EQ(0, uv_prepare_start(&prepare, prepare_cb));
ASSERT_OK(uv_prepare_init(uv_default_loop(), &prepare));
ASSERT_OK(uv_prepare_start(&prepare, prepare_cb));
ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
uv_fs_unlink(NULL, &unlink_req, "test_file", NULL);
uv_fs_req_cleanup(&unlink_req);

26
deps/libuv/test/test-multiple-listen.c vendored
View File

@ -38,7 +38,7 @@ static void close_cb(uv_handle_t* handle) {
static void connection_cb(uv_stream_t* tcp, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
uv_close((uv_handle_t*)&server, close_cb);
connection_cb_called++;
}
@ -48,25 +48,25 @@ static void start_server(void) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server, 128, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server, 128, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
static void connect_cb(uv_connect_t* req, int status) {
ASSERT_NOT_NULL(req);
ASSERT(status == 0);
ASSERT_OK(status);
free(req);
uv_close((uv_handle_t*)&client, close_cb);
connect_cb_called++;
@ -78,17 +78,17 @@ static void client_connect(void) {
uv_connect_t* connect_req = malloc(sizeof *connect_req);
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_NOT_NULL(connect_req);
r = uv_tcp_init(uv_default_loop(), &client);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_connect(connect_req,
&client,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
@ -100,9 +100,9 @@ TEST_IMPL(multiple_listen) {
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connection_cb_called == 1);
ASSERT(connect_cb_called == 1);
ASSERT(close_cb_called == 2);
ASSERT_EQ(1, connection_cb_called);
ASSERT_EQ(1, connect_cb_called);
ASSERT_EQ(2, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

44
deps/libuv/test/test-mutexes.c vendored
View File

@ -40,7 +40,7 @@ TEST_IMPL(thread_mutex) {
int r;
r = uv_mutex_init(&mutex);
ASSERT(r == 0);
ASSERT_OK(r);
uv_mutex_lock(&mutex);
uv_mutex_unlock(&mutex);
@ -55,11 +55,11 @@ TEST_IMPL(thread_mutex_recursive) {
int r;
r = uv_mutex_init_recursive(&mutex);
ASSERT(r == 0);
ASSERT_OK(r);
uv_mutex_lock(&mutex);
uv_mutex_lock(&mutex);
ASSERT(0 == uv_mutex_trylock(&mutex));
ASSERT_OK(uv_mutex_trylock(&mutex));
uv_mutex_unlock(&mutex);
uv_mutex_unlock(&mutex);
@ -75,7 +75,7 @@ TEST_IMPL(thread_rwlock) {
int r;
r = uv_rwlock_init(&rwlock);
ASSERT(r == 0);
ASSERT_OK(r);
uv_rwlock_rdlock(&rwlock);
uv_rwlock_rdunlock(&rwlock);
@ -101,7 +101,7 @@ static void synchronize(void) {
synchronize_nowait();
/* Wait for the other thread. Guard against spurious wakeups. */
for (current = step; current == step; uv_cond_wait(&condvar, &mutex));
ASSERT(step == current + 1);
ASSERT_EQ(step, current + 1);
}
@ -111,23 +111,23 @@ static void thread_rwlock_trylock_peer(void* unused) {
uv_mutex_lock(&mutex);
/* Write lock held by other thread. */
ASSERT(UV_EBUSY == uv_rwlock_tryrdlock(&rwlock));
ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock));
ASSERT_EQ(UV_EBUSY, uv_rwlock_tryrdlock(&rwlock));
ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock));
synchronize();
/* Read lock held by other thread. */
ASSERT(0 == uv_rwlock_tryrdlock(&rwlock));
ASSERT_OK(uv_rwlock_tryrdlock(&rwlock));
uv_rwlock_rdunlock(&rwlock);
ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock));
ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock));
synchronize();
/* Acquire write lock. */
ASSERT(0 == uv_rwlock_trywrlock(&rwlock));
ASSERT_OK(uv_rwlock_trywrlock(&rwlock));
synchronize();
/* Release write lock and acquire read lock. */
uv_rwlock_wrunlock(&rwlock);
ASSERT(0 == uv_rwlock_tryrdlock(&rwlock));
ASSERT_OK(uv_rwlock_tryrdlock(&rwlock));
synchronize();
uv_rwlock_rdunlock(&rwlock);
@ -139,22 +139,22 @@ static void thread_rwlock_trylock_peer(void* unused) {
TEST_IMPL(thread_rwlock_trylock) {
uv_thread_t thread;
ASSERT(0 == uv_cond_init(&condvar));
ASSERT(0 == uv_mutex_init(&mutex));
ASSERT(0 == uv_rwlock_init(&rwlock));
ASSERT_OK(uv_cond_init(&condvar));
ASSERT_OK(uv_mutex_init(&mutex));
ASSERT_OK(uv_rwlock_init(&rwlock));
uv_mutex_lock(&mutex);
ASSERT(0 == uv_thread_create(&thread, thread_rwlock_trylock_peer, NULL));
ASSERT_OK(uv_thread_create(&thread, thread_rwlock_trylock_peer, NULL));
/* Hold write lock. */
ASSERT(0 == uv_rwlock_trywrlock(&rwlock));
ASSERT_OK(uv_rwlock_trywrlock(&rwlock));
synchronize(); /* Releases the mutex to the other thread. */
/* Release write lock and acquire read lock. Pthreads doesn't support
* the notion of upgrading or downgrading rwlocks, so neither do we.
*/
uv_rwlock_wrunlock(&rwlock);
ASSERT(0 == uv_rwlock_tryrdlock(&rwlock));
ASSERT_OK(uv_rwlock_tryrdlock(&rwlock));
synchronize();
/* Release read lock. */
@ -162,17 +162,17 @@ TEST_IMPL(thread_rwlock_trylock) {
synchronize();
/* Write lock held by other thread. */
ASSERT(UV_EBUSY == uv_rwlock_tryrdlock(&rwlock));
ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock));
ASSERT_EQ(UV_EBUSY, uv_rwlock_tryrdlock(&rwlock));
ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock));
synchronize();
/* Read lock held by other thread. */
ASSERT(0 == uv_rwlock_tryrdlock(&rwlock));
ASSERT_OK(uv_rwlock_tryrdlock(&rwlock));
uv_rwlock_rdunlock(&rwlock);
ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock));
ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock));
synchronize();
ASSERT(0 == uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
uv_rwlock_destroy(&rwlock);
uv_mutex_unlock(&mutex);
uv_mutex_destroy(&mutex);

36
deps/libuv/test/test-not-readable-nor-writable-on-read-error.c vendored
View File

@ -35,7 +35,7 @@ static int close_cb_called;
static void write_cb(uv_write_t* req, int status) {
write_cb_called++;
ASSERT(status == 0);
ASSERT_OK(status);
}
static void alloc_cb(uv_handle_t* handle,
@ -54,8 +54,8 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
read_cb_called++;
ASSERT((nread < 0) && (nread != UV_EOF));
ASSERT(0 == uv_is_writable(handle));
ASSERT(0 == uv_is_readable(handle));
ASSERT_OK(uv_is_writable(handle));
ASSERT_OK(uv_is_readable(handle));
uv_close((uv_handle_t*) handle, close_cb);
}
@ -65,10 +65,10 @@ static void connect_cb(uv_connect_t* req, int status) {
uv_buf_t reset_me;
connect_cb_called++;
ASSERT(status == 0);
ASSERT_OK(status);
r = uv_read_start((uv_stream_t*) &tcp_client, alloc_cb, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
reset_me = uv_buf_init(reset_me_cmd, sizeof(reset_me_cmd));
@ -78,26 +78,26 @@ static void connect_cb(uv_connect_t* req, int status) {
1,
write_cb);
ASSERT(r == 0);
ASSERT_OK(r);
}
TEST_IMPL(not_readable_nor_writable_on_read_error) {
struct sockaddr_in sa;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &sa));
ASSERT(0 == uv_loop_init(&loop));
ASSERT(0 == uv_tcp_init(&loop, &tcp_client));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &sa));
ASSERT_OK(uv_loop_init(&loop));
ASSERT_OK(uv_tcp_init(&loop, &tcp_client));
ASSERT(0 == uv_tcp_connect(&connect_req,
&tcp_client,
(const struct sockaddr*) &sa,
connect_cb));
ASSERT_OK(uv_tcp_connect(&connect_req,
&tcp_client,
(const struct sockaddr*) &sa,
connect_cb));
ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT));
ASSERT(connect_cb_called == 1);
ASSERT(read_cb_called == 1);
ASSERT(write_cb_called == 1);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, connect_cb_called);
ASSERT_EQ(1, read_cb_called);
ASSERT_EQ(1, write_cb_called);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(&loop);
return 0;

14
deps/libuv/test/test-not-writable-after-shutdown.c vendored
View File

@ -34,12 +34,12 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
static void connect_cb(uv_connect_t* req, int status) {
int r;
ASSERT(status == 0);
ASSERT_OK(status);
r = uv_shutdown(&shutdown_req, req->handle, shutdown_cb);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(0 == uv_is_writable(req->handle));
ASSERT_OK(uv_is_writable(req->handle));
}
TEST_IMPL(not_writable_after_shutdown) {
@ -49,20 +49,20 @@ TEST_IMPL(not_writable_after_shutdown) {
uv_tcp_t socket;
uv_connect_t connect_req;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
r = uv_tcp_init(loop, &socket);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_connect(&connect_req,
&socket,
(const struct sockaddr*) &addr,
connect_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
MAKE_VALGRIND_HAPPY(loop);
return 0;

20
deps/libuv/test/test-osx-select.c vendored
View File

@ -62,7 +62,7 @@ TEST_IMPL(osx_select) {
}
r = uv_tty_init(uv_default_loop(), &tty, fd, 1);
ASSERT(r == 0);
ASSERT_OK(r);
uv_read_start((uv_stream_t*) &tty, alloc_cb, read_cb);
@ -72,12 +72,12 @@ TEST_IMPL(osx_select) {
"feel pretty happy\n";
for (i = 0, len = strlen(str); i < len; i++) {
r = ioctl(fd, TIOCSTI, str + i);
ASSERT(r == 0);
ASSERT_OK(r);
}
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(read_count == 3);
ASSERT_EQ(3, read_count);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -97,13 +97,13 @@ TEST_IMPL(osx_select_many_fds) {
TEST_FILE_LIMIT(ARRAY_SIZE(tcps) + 100);
r = uv_ip4_addr("127.0.0.1", 0, &addr);
ASSERT(r == 0);
ASSERT_OK(r);
for (i = 0; i < ARRAY_SIZE(tcps); i++) {
r = uv_tcp_init(uv_default_loop(), &tcps[i]);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_tcp_bind(&tcps[i], (const struct sockaddr *) &addr, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_unref((uv_handle_t*) &tcps[i]);
}
@ -115,10 +115,10 @@ TEST_IMPL(osx_select_many_fds) {
}
r = uv_tty_init(uv_default_loop(), &tty, fd, 1);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_read_start((uv_stream_t*) &tty, alloc_cb, read_cb);
ASSERT(r == 0);
ASSERT_OK(r);
/* Emulate user-input */
str = "got some input\n"
@ -126,12 +126,12 @@ TEST_IMPL(osx_select_many_fds) {
"feel pretty happy\n";
for (i = 0, len = strlen(str); i < len; i++) {
r = ioctl(fd, TIOCSTI, str + i);
ASSERT(r == 0);
ASSERT_OK(r);
}
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(read_count == 3);
ASSERT_EQ(3, read_count);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

72
deps/libuv/test/test-ping-pong.c vendored
View File

@ -83,7 +83,7 @@ static void pinger_on_close(uv_handle_t* handle) {
static void pinger_after_write(uv_write_t* req, int status) {
ASSERT_EQ(status, 0);
ASSERT_OK(status);
free(req->data);
free(req);
}
@ -112,7 +112,7 @@ static void pinger_write_ping(pinger_t* pinger) {
req = malloc(sizeof(*req));
ASSERT_NOT_NULL(req);
req->data = NULL;
ASSERT_EQ(0, uv_write(req, stream, bufs, nbufs, pinger_after_write));
ASSERT_OK(uv_write(req, stream, bufs, nbufs, pinger_after_write));
puts("PING");
}
@ -188,7 +188,7 @@ static void ponger_read_cb(uv_stream_t* stream,
req = malloc(sizeof(*req));
ASSERT_NOT_NULL(req);
req->data = buf->base;
ASSERT_EQ(0, uv_write(req, stream, &writebuf, 1, pinger_after_write));
ASSERT_OK(uv_write(req, stream, &writebuf, 1, pinger_after_write));
}
@ -197,17 +197,17 @@ static void pinger_on_connect(uv_connect_t* req, int status) {
pinger_on_connect_count++;
ASSERT_EQ(status, 0);
ASSERT_OK(status);
ASSERT_EQ(1, uv_is_readable(req->handle));
ASSERT_EQ(1, uv_is_writable(req->handle));
ASSERT_EQ(0, uv_is_closing((uv_handle_t *) req->handle));
ASSERT_OK(uv_is_closing((uv_handle_t *) req->handle));
pinger_write_ping(pinger);
ASSERT_EQ(0, uv_read_start((uv_stream_t*) req->handle,
alloc_cb,
pinger_read_cb));
ASSERT_OK(uv_read_start((uv_stream_t*) req->handle,
alloc_cb,
pinger_read_cb));
}
@ -218,7 +218,7 @@ static void tcp_pinger_v6_new(int vectored_writes) {
pinger_t* pinger;
ASSERT_EQ(0, uv_ip6_addr("::1", TEST_PORT, &server_addr));
ASSERT_OK(uv_ip6_addr("::1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
ASSERT_NOT_NULL(pinger);
pinger->vectored_writes = vectored_writes;
@ -229,7 +229,7 @@ static void tcp_pinger_v6_new(int vectored_writes) {
/* Try to connect to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);
pinger->stream.tcp.data = pinger;
ASSERT_EQ(0, r);
ASSERT_OK(r);
/* We are never doing multiple reads/connects at a time anyway, so these
* handles can be pre-initialized. */
@ -237,10 +237,10 @@ static void tcp_pinger_v6_new(int vectored_writes) {
&pinger->stream.tcp,
(const struct sockaddr*) &server_addr,
pinger_on_connect);
ASSERT_EQ(0, r);
ASSERT_OK(r);
/* Synchronous connect callbacks are not allowed. */
ASSERT_EQ(pinger_on_connect_count, 0);
ASSERT_OK(pinger_on_connect_count);
}
@ -249,7 +249,7 @@ static void tcp_pinger_new(int vectored_writes) {
struct sockaddr_in server_addr;
pinger_t* pinger;
ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
ASSERT_NOT_NULL(pinger);
pinger->vectored_writes = vectored_writes;
@ -260,7 +260,7 @@ static void tcp_pinger_new(int vectored_writes) {
/* Try to connect to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);
pinger->stream.tcp.data = pinger;
ASSERT_EQ(0, r);
ASSERT_OK(r);
/* We are never doing multiple reads/connects at a time anyway, so these
* handles can be pre-initialized. */
@ -268,10 +268,10 @@ static void tcp_pinger_new(int vectored_writes) {
&pinger->stream.tcp,
(const struct sockaddr*) &server_addr,
pinger_on_connect);
ASSERT_EQ(0, r);
ASSERT_OK(r);
/* Synchronous connect callbacks are not allowed. */
ASSERT_EQ(pinger_on_connect_count, 0);
ASSERT_OK(pinger_on_connect_count);
}
@ -289,7 +289,7 @@ static void pipe_pinger_new(int vectored_writes) {
/* Try to connect to the server and do NUM_PINGS ping-pongs. */
r = uv_pipe_init(uv_default_loop(), &pinger->stream.pipe, 0);
pinger->stream.pipe.data = pinger;
ASSERT_EQ(0, r);
ASSERT_OK(r);
/* We are never doing multiple reads/connects at a time anyway, so these
* handles can be pre-initialized. */
@ -297,7 +297,7 @@ static void pipe_pinger_new(int vectored_writes) {
pinger_on_connect);
/* Synchronous connect callbacks are not allowed. */
ASSERT_EQ(pinger_on_connect_count, 0);
ASSERT_OK(pinger_on_connect_count);
}
@ -315,31 +315,31 @@ static void socketpair_pinger_new(int vectored_writes) {
/* Try to make a socketpair and do NUM_PINGS ping-pongs. */
(void)uv_default_loop(); /* ensure WSAStartup has been performed */
ASSERT_EQ(0, uv_socketpair(SOCK_STREAM, 0, fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE));
ASSERT_OK(uv_socketpair(SOCK_STREAM, 0, fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE));
#ifndef _WIN32
/* On Windows, this is actually a UV_TCP, but libuv doesn't detect that. */
ASSERT_EQ(uv_guess_handle((uv_file) fds[0]), UV_NAMED_PIPE);
ASSERT_EQ(uv_guess_handle((uv_file) fds[1]), UV_NAMED_PIPE);
#endif
ASSERT_EQ(0, uv_tcp_init(uv_default_loop(), &pinger->stream.tcp));
ASSERT_OK(uv_tcp_init(uv_default_loop(), &pinger->stream.tcp));
pinger->stream.pipe.data = pinger;
ASSERT_EQ(0, uv_tcp_open(&pinger->stream.tcp, fds[1]));
ASSERT_OK(uv_tcp_open(&pinger->stream.tcp, fds[1]));
ponger = malloc(sizeof(*ponger));
ASSERT_NOT_NULL(ponger);
ponger->data = NULL;
ASSERT_EQ(0, uv_tcp_init(uv_default_loop(), ponger));
ASSERT_EQ(0, uv_tcp_open(ponger, fds[0]));
ASSERT_OK(uv_tcp_init(uv_default_loop(), ponger));
ASSERT_OK(uv_tcp_open(ponger, fds[0]));
pinger_write_ping(pinger);
ASSERT_EQ(0, uv_read_start((uv_stream_t*) &pinger->stream.tcp,
alloc_cb,
pinger_read_cb));
ASSERT_EQ(0, uv_read_start((uv_stream_t*) ponger,
alloc_cb,
ponger_read_cb));
ASSERT_OK(uv_read_start((uv_stream_t*) &pinger->stream.tcp,
alloc_cb,
pinger_read_cb));
ASSERT_OK(uv_read_start((uv_stream_t*) ponger,
alloc_cb,
ponger_read_cb));
}
@ -349,14 +349,14 @@ static void pipe2_pinger_new(int vectored_writes) {
uv_pipe_t* ponger;
/* Try to make a pipe and do NUM_PINGS pings. */
ASSERT_EQ(0, uv_pipe(fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE));
ASSERT_OK(uv_pipe(fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE));
ASSERT_EQ(uv_guess_handle(fds[0]), UV_NAMED_PIPE);
ASSERT_EQ(uv_guess_handle(fds[1]), UV_NAMED_PIPE);
ponger = malloc(sizeof(*ponger));
ASSERT_NOT_NULL(ponger);
ASSERT_EQ(0, uv_pipe_init(uv_default_loop(), ponger, 0));
ASSERT_EQ(0, uv_pipe_open(ponger, fds[0]));
ASSERT_OK(uv_pipe_init(uv_default_loop(), ponger, 0));
ASSERT_OK(uv_pipe_open(ponger, fds[0]));
pinger = malloc(sizeof(*pinger));
ASSERT_NOT_NULL(pinger);
@ -364,19 +364,19 @@ static void pipe2_pinger_new(int vectored_writes) {
pinger->state = 0;
pinger->pongs = 0;
pinger->pong = PING;
ASSERT_EQ(0, uv_pipe_init(uv_default_loop(), &pinger->stream.pipe, 0));
ASSERT_EQ(0, uv_pipe_open(&pinger->stream.pipe, fds[1]));
ASSERT_OK(uv_pipe_init(uv_default_loop(), &pinger->stream.pipe, 0));
ASSERT_OK(uv_pipe_open(&pinger->stream.pipe, fds[1]));
pinger->stream.pipe.data = pinger; /* record for close_cb */
ponger->data = pinger; /* record for read_cb */
pinger_write_ping(pinger);
ASSERT_EQ(0, uv_read_start((uv_stream_t*) ponger, alloc_cb, pinger_read_cb));
ASSERT_OK(uv_read_start((uv_stream_t*) ponger, alloc_cb, pinger_read_cb));
}
static int run_ping_pong_test(void) {
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(completed_pingers, 1);
ASSERT_EQ(1, completed_pingers);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

38
deps/libuv/test/test-pipe-bind-error.c vendored
View File

@ -46,26 +46,26 @@ TEST_IMPL(pipe_bind_error_addrinuse) {
int r;
r = uv_pipe_init(uv_default_loop(), &server1, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&server1, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_init(uv_default_loop(), &server2, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&server2, TEST_PIPENAME);
ASSERT(r == UV_EADDRINUSE);
ASSERT_EQ(r, UV_EADDRINUSE);
r = uv_listen((uv_stream_t*)&server1, SOMAXCONN, NULL);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server2, SOMAXCONN, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
uv_close((uv_handle_t*)&server1, close_cb);
uv_close((uv_handle_t*)&server2, close_cb);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(close_cb_called == 2);
ASSERT_EQ(2, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -77,16 +77,16 @@ TEST_IMPL(pipe_bind_error_addrnotavail) {
int r;
r = uv_pipe_init(uv_default_loop(), &server, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&server, BAD_PIPENAME);
ASSERT(r == UV_EACCES);
ASSERT_EQ(r, UV_EACCES);
uv_close((uv_handle_t*)&server, close_cb);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -98,17 +98,17 @@ TEST_IMPL(pipe_bind_error_inval) {
int r;
r = uv_pipe_init(uv_default_loop(), &server, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&server, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&server, TEST_PIPENAME_2);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -123,16 +123,16 @@ TEST_IMPL(pipe_listen_without_bind) {
int r;
r = uv_pipe_init(uv_default_loop(), &server, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -141,14 +141,14 @@ TEST_IMPL(pipe_listen_without_bind) {
TEST_IMPL(pipe_bind_or_listen_error_after_close) {
uv_pipe_t server;
ASSERT_EQ(uv_pipe_init(uv_default_loop(), &server, 0), 0);
ASSERT_OK(uv_pipe_init(uv_default_loop(), &server, 0));
uv_close((uv_handle_t*) &server, NULL);
ASSERT_EQ(uv_pipe_bind(&server, TEST_PIPENAME), UV_EINVAL);
ASSERT_EQ(uv_listen((uv_stream_t*) &server, SOMAXCONN, NULL), UV_EINVAL);
ASSERT_EQ(uv_run(uv_default_loop(), UV_RUN_DEFAULT), 0);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

12
deps/libuv/test/test-pipe-close-stdout-read-stdin.c vendored
View File

@ -61,7 +61,7 @@ TEST_IMPL(pipe_close_stdout_read_stdin) {
uv_pipe_t stdin_pipe;
r = pipe(fd);
ASSERT(r == 0);
ASSERT_OK(r);
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
pid = -1;
@ -80,24 +80,24 @@ TEST_IMPL(pipe_close_stdout_read_stdin) {
ASSERT(-1 <= r && r <= 1);
close(0);
r = dup(fd[0]);
ASSERT(r != -1);
ASSERT_NE(r, -1);
/* Create a stream that reads from the pipe. */
r = uv_pipe_init(uv_default_loop(), (uv_pipe_t *)&stdin_pipe, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_open((uv_pipe_t *)&stdin_pipe, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_read_start((uv_stream_t *)&stdin_pipe, alloc_buffer, read_stdin);
ASSERT(r == 0);
ASSERT_OK(r);
/*
* Because the other end of the pipe was closed, there should
* be no event left to process after one run of the event loop.
* Otherwise, it means that events were not processed correctly.
*/
ASSERT(uv_run(uv_default_loop(), UV_RUN_NOWAIT) == 0);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_NOWAIT));
} else {
/*
* Close both ends of the pipe so that the child

12
deps/libuv/test/test-pipe-connect-error.c vendored
View File

@ -64,13 +64,13 @@ TEST_IMPL(pipe_connect_bad_name) {
int r;
r = uv_pipe_init(uv_default_loop(), &client, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_pipe_connect(&req, &client, BAD_PIPENAME, connect_cb);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(close_cb_called, 1);
ASSERT_EQ(connect_cb_called, 1);
ASSERT_EQ(1, close_cb_called);
ASSERT_EQ(1, connect_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;
@ -84,13 +84,13 @@ TEST_IMPL(pipe_connect_to_file) {
int r;
r = uv_pipe_init(uv_default_loop(), &client, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_pipe_connect(&req, &client, path, connect_cb_file);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT_EQ(close_cb_called, 1);
ASSERT_EQ(connect_cb_called, 1);
ASSERT_EQ(1, close_cb_called);
ASSERT_EQ(1, connect_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

34
deps/libuv/test/test-pipe-connect-multiple.c vendored
View File

@ -44,14 +44,14 @@ static uv_pipe_t connections[NUM_CLIENTS];
static void connection_cb(uv_stream_t* server, int status) {
int r;
uv_pipe_t* conn;
ASSERT(status == 0);
ASSERT_OK(status);
conn = &connections[connection_cb_called];
r = uv_pipe_init(server->loop, conn, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_accept(server, (uv_stream_t*)conn);
ASSERT(r == 0);
ASSERT_OK(r);
if (++connection_cb_called == NUM_CLIENTS &&
connect_cb_called == NUM_CLIENTS) {
@ -61,7 +61,7 @@ static void connection_cb(uv_stream_t* server, int status) {
static void connect_cb(uv_connect_t* connect_req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
if (++connect_cb_called == NUM_CLIENTS &&
connection_cb_called == NUM_CLIENTS) {
uv_stop(connect_req->handle->loop);
@ -80,17 +80,17 @@ TEST_IMPL(pipe_connect_multiple) {
loop = uv_default_loop();
r = uv_pipe_init(loop, &server_handle, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&server_handle, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server_handle, 128, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
for (i = 0; i < NUM_CLIENTS; i++) {
r = uv_pipe_init(loop, &clients[i].pipe_handle, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_pipe_connect(&clients[i].conn_req,
&clients[i].pipe_handle,
TEST_PIPENAME,
@ -99,8 +99,8 @@ TEST_IMPL(pipe_connect_multiple) {
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(connection_cb_called == NUM_CLIENTS);
ASSERT(connect_cb_called == NUM_CLIENTS);
ASSERT_EQ(connection_cb_called, NUM_CLIENTS);
ASSERT_EQ(connect_cb_called, NUM_CLIENTS);
MAKE_VALGRIND_HAPPY(loop);
return 0;
@ -110,14 +110,14 @@ TEST_IMPL(pipe_connect_multiple) {
static void connection_cb2(uv_stream_t* server, int status) {
int r;
uv_pipe_t* conn;
ASSERT_EQ(status, 0);
ASSERT_OK(status);
conn = &connections[connection_cb_called];
r = uv_pipe_init(server->loop, conn, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_accept(server, (uv_stream_t*)conn);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)conn, NULL);
if (++connection_cb_called == NUM_CLIENTS &&
@ -146,17 +146,17 @@ TEST_IMPL(pipe_connect_close_multiple) {
loop = uv_default_loop();
r = uv_pipe_init(loop, &server_handle, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_pipe_bind(&server_handle, TEST_PIPENAME);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*)&server_handle, 128, connection_cb2);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
for (i = 0; i < NUM_CLIENTS; i++) {
r = uv_pipe_init(loop, &clients[i].pipe_handle, 0);
ASSERT_EQ(r, 0);
ASSERT_OK(r);
uv_pipe_connect(&clients[i].conn_req,
&clients[i].pipe_handle,
TEST_PIPENAME,

16
deps/libuv/test/test-pipe-connect-prepare.c vendored
View File

@ -48,7 +48,7 @@ static void close_cb(uv_handle_t* handle) {
static void connect_cb(uv_connect_t* connect_req, int status) {
ASSERT(status == UV_ENOENT);
ASSERT_EQ(status, UV_ENOENT);
connect_cb_called++;
uv_close((uv_handle_t*)&prepare_handle, close_cb);
uv_close((uv_handle_t*)&pipe_handle, close_cb);
@ -56,7 +56,7 @@ static void connect_cb(uv_connect_t* connect_req, int status) {
static void prepare_cb(uv_prepare_t* handle) {
ASSERT(handle == &prepare_handle);
ASSERT_PTR_EQ(handle, &prepare_handle);
uv_pipe_connect(&conn_req, &pipe_handle, BAD_PIPENAME, connect_cb);
}
@ -65,18 +65,18 @@ TEST_IMPL(pipe_connect_on_prepare) {
int r;
r = uv_pipe_init(uv_default_loop(), &pipe_handle, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_prepare_init(uv_default_loop(), &prepare_handle);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_prepare_start(&prepare_handle, prepare_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(close_cb_called == 2);
ASSERT(connect_cb_called == 1);
ASSERT_EQ(2, close_cb_called);
ASSERT_EQ(1, connect_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

80
deps/libuv/test/test-pipe-getsockname.c vendored
View File

@ -40,8 +40,8 @@ static int pipe_client_connect_cb_called = 0;
static void pipe_close_cb(uv_handle_t* handle) {
ASSERT(handle == (uv_handle_t*) &pipe_client ||
handle == (uv_handle_t*) &pipe_server);
ASSERT_NE(handle == (uv_handle_t*) &pipe_client ||
handle == (uv_handle_t*) &pipe_server, 0);
pipe_close_cb_called++;
}
@ -51,12 +51,12 @@ static void pipe_client_connect_cb(uv_connect_t* req, int status) {
size_t len;
int r;
ASSERT(req == &connect_req);
ASSERT(status == 0);
ASSERT_PTR_EQ(req, &connect_req);
ASSERT_OK(status);
len = sizeof buf;
r = uv_pipe_getpeername(&pipe_client, buf, &len);
ASSERT(r == 0);
ASSERT_OK(r);
if (*buf == '\0') { /* Linux abstract socket. */
const char expected[] = "\0" TEST_PIPENAME;
@ -82,7 +82,7 @@ static void pipe_server_connection_cb(uv_stream_t* handle, int status) {
/* This function *may* be called, depending on whether accept or the
* connection callback is called first.
*/
ASSERT(status == 0);
ASSERT_OK(status);
}
@ -99,44 +99,44 @@ TEST_IMPL(pipe_getsockname) {
ASSERT_NOT_NULL(loop);
r = uv_pipe_init(loop, &pipe_server, 0);
ASSERT(r == 0);
ASSERT_OK(r);
len = sizeof buf;
r = uv_pipe_getsockname(&pipe_server, buf, &len);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
len = sizeof buf;
r = uv_pipe_getpeername(&pipe_server, buf, &len);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
r = uv_pipe_bind(&pipe_server, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
len = sizeof buf;
r = uv_pipe_getsockname(&pipe_server, buf, &len);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(buf[len - 1] != 0);
ASSERT(buf[len] == '\0');
ASSERT(memcmp(buf, TEST_PIPENAME, len) == 0);
ASSERT_NE(0, buf[len - 1]);
ASSERT_EQ(buf[len], '\0');
ASSERT_OK(memcmp(buf, TEST_PIPENAME, len));
len = sizeof buf;
r = uv_pipe_getpeername(&pipe_server, buf, &len);
ASSERT(r == UV_ENOTCONN);
ASSERT_EQ(r, UV_ENOTCONN);
r = uv_listen((uv_stream_t*) &pipe_server, 0, pipe_server_connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_init(loop, &pipe_client, 0);
ASSERT(r == 0);
ASSERT_OK(r);
len = sizeof buf;
r = uv_pipe_getsockname(&pipe_client, buf, &len);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
len = sizeof buf;
r = uv_pipe_getpeername(&pipe_client, buf, &len);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
uv_pipe_connect(&connect_req, &pipe_client, TEST_PIPENAME, pipe_client_connect_cb);
@ -146,15 +146,15 @@ TEST_IMPL(pipe_getsockname) {
len = sizeof buf;
r = uv_pipe_getpeername(&pipe_client, buf, &len);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(buf[len - 1] != 0);
ASSERT(memcmp(buf, TEST_PIPENAME, len) == 0);
ASSERT_NE(0, buf[len - 1]);
ASSERT_OK(memcmp(buf, TEST_PIPENAME, len));
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(pipe_client_connect_cb_called == 1);
ASSERT(pipe_close_cb_called == 2);
ASSERT_OK(r);
ASSERT_EQ(1, pipe_client_connect_cb_called);
ASSERT_EQ(2, pipe_close_cb_called);
MAKE_VALGRIND_HAPPY(loop);
return 0;
@ -218,50 +218,50 @@ TEST_IMPL(pipe_getsockname_blocking) {
int r;
r = CreatePipe(&readh, &writeh, NULL, 65536);
ASSERT(r != 0);
ASSERT(r);
r = uv_pipe_init(uv_default_loop(), &pipe_client, 0);
ASSERT(r == 0);
ASSERT_OK(r);
readfd = _open_osfhandle((intptr_t)readh, _O_RDONLY);
ASSERT(r != -1);
ASSERT_NE(r, -1);
r = uv_pipe_open(&pipe_client, readfd);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_read_start((uv_stream_t*) &pipe_client,
(uv_alloc_cb) abort,
(uv_read_cb) abort);
ASSERT(r == 0);
ASSERT_OK(r);
Sleep(100);
r = uv_read_stop((uv_stream_t*)&pipe_client);
ASSERT(r == 0);
ASSERT_OK(r);
len1 = sizeof buf1;
r = uv_pipe_getsockname(&pipe_client, buf1, &len1);
ASSERT(r == 0);
ASSERT(len1 == 0); /* It's an annonymous pipe. */
ASSERT_OK(r);
ASSERT_OK(len1); /* It's an annonymous pipe. */
r = uv_read_start((uv_stream_t*)&pipe_client,
(uv_alloc_cb) abort,
(uv_read_cb) abort);
ASSERT(r == 0);
ASSERT_OK(r);
Sleep(100);
len2 = sizeof buf2;
r = uv_pipe_getsockname(&pipe_client, buf2, &len2);
ASSERT(r == 0);
ASSERT(len2 == 0); /* It's an annonymous pipe. */
ASSERT_OK(r);
ASSERT_OK(len2); /* It's an annonymous pipe. */
r = uv_read_stop((uv_stream_t*)&pipe_client);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(len1 == len2);
ASSERT(memcmp(buf1, buf2, len1) == 0);
ASSERT_EQ(len1, len2);
ASSERT_OK(memcmp(buf1, buf2, len1));
pipe_close_cb_called = 0;
uv_close((uv_handle_t*)&pipe_client, pipe_close_cb);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(pipe_close_cb_called == 1);
ASSERT_EQ(1, pipe_close_cb_called);
CloseHandle(writeh);
#endif

8
deps/libuv/test/test-pipe-pending-instances.c vendored
View File

@ -37,22 +37,22 @@ TEST_IMPL(pipe_pending_instances) {
loop = uv_default_loop();
r = uv_pipe_init(loop, &pipe_handle, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_pipe_pending_instances(&pipe_handle, 8);
r = uv_pipe_bind(&pipe_handle, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
uv_pipe_pending_instances(&pipe_handle, 16);
r = uv_listen((uv_stream_t*)&pipe_handle, 128, connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*)&pipe_handle, NULL);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
MAKE_VALGRIND_HAPPY(loop);
return 0;

38
deps/libuv/test/test-pipe-sendmsg.c vendored
View File

@ -45,12 +45,12 @@ static void set_nonblocking(uv_os_sock_t sock) {
#ifdef _WIN32
unsigned long on = 1;
r = ioctlsocket(sock, FIONBIO, &on);
ASSERT(r == 0);
ASSERT_OK(r);
#else
int flags = fcntl(sock, F_GETFL, 0);
ASSERT(flags >= 0);
ASSERT_GE(flags, 0);
r = fcntl(sock, F_SETFL, flags | O_NONBLOCK);
ASSERT(r >= 0);
ASSERT_GE(r, 0);
#endif
}
@ -79,22 +79,22 @@ static void read_cb(uv_stream_t* handle,
unsigned int i;
p = (uv_pipe_t*) handle;
ASSERT(nread >= 0);
ASSERT_GE(nread, 0);
while (uv_pipe_pending_count(p) != 0) {
pending = uv_pipe_pending_type(p);
ASSERT(pending == UV_NAMED_PIPE);
ASSERT_EQ(pending, UV_NAMED_PIPE);
ASSERT(incoming_count < ARRAY_SIZE(incoming));
ASSERT_LT(incoming_count, ARRAY_SIZE(incoming));
inc = &incoming[incoming_count++];
ASSERT(0 == uv_pipe_init(p->loop, inc, 0));
ASSERT(0 == uv_accept(handle, (uv_stream_t*) inc));
ASSERT_OK(uv_pipe_init(p->loop, inc, 0));
ASSERT_OK(uv_accept(handle, (uv_stream_t*) inc));
}
if (incoming_count != ARRAY_SIZE(incoming))
return;
ASSERT(0 == uv_read_stop((uv_stream_t*) p));
ASSERT_OK(uv_read_stop((uv_stream_t*) p));
uv_close((uv_handle_t*) p, close_cb);
for (i = 0; i < ARRAY_SIZE(incoming); i++)
uv_close((uv_handle_t*) &incoming[i], close_cb);
@ -115,12 +115,12 @@ TEST_IMPL(pipe_sendmsg) {
unsigned int i;
uv_buf_t buf;
ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
for (i = 0; i < ARRAY_SIZE(send_fds); i += 2)
ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, send_fds + i));
ASSERT(i == ARRAY_SIZE(send_fds));
ASSERT(0 == uv_pipe_init(uv_default_loop(), &p, 1));
ASSERT(0 == uv_pipe_open(&p, fds[1]));
ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, send_fds + i));
ASSERT_EQ(i, ARRAY_SIZE(send_fds));
ASSERT_OK(uv_pipe_init(uv_default_loop(), &p, 1));
ASSERT_OK(uv_pipe_open(&p, fds[1]));
buf = uv_buf_init("X", 1);
memset(&msg, 0, sizeof(msg));
@ -130,7 +130,7 @@ TEST_IMPL(pipe_sendmsg) {
msg.msg_control = (void*) scratch;
msg.msg_controllen = CMSG_LEN(sizeof(send_fds));
ASSERT(sizeof(scratch) >= msg.msg_controllen);
ASSERT_GE(sizeof(scratch), msg.msg_controllen);
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
@ -146,16 +146,16 @@ TEST_IMPL(pipe_sendmsg) {
}
set_nonblocking(fds[1]);
ASSERT(0 == uv_read_start((uv_stream_t*) &p, alloc_cb, read_cb));
ASSERT_OK(uv_read_start((uv_stream_t*) &p, alloc_cb, read_cb));
do
r = sendmsg(fds[0], &msg, 0);
while (r == -1 && errno == EINTR);
ASSERT(r == 1);
ASSERT_EQ(1, r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(ARRAY_SIZE(incoming) == incoming_count);
ASSERT(ARRAY_SIZE(incoming) + 1 == close_called);
ASSERT_EQ(ARRAY_SIZE(incoming), incoming_count);
ASSERT_EQ(ARRAY_SIZE(incoming) + 1, close_called);
close(fds[0]);
MAKE_VALGRIND_HAPPY(uv_default_loop());

24
deps/libuv/test/test-pipe-server-close.c vendored
View File

@ -35,15 +35,15 @@ static int pipe_client_connect_cb_called = 0;
static void pipe_close_cb(uv_handle_t* handle) {
ASSERT(handle == (uv_handle_t*) &pipe_client ||
handle == (uv_handle_t*) &pipe_server);
ASSERT_NE(handle == (uv_handle_t*) &pipe_client ||
handle == (uv_handle_t*) &pipe_server, 0);
pipe_close_cb_called++;
}
static void pipe_client_connect_cb(uv_connect_t* req, int status) {
ASSERT(req == &connect_req);
ASSERT(status == 0);
ASSERT_PTR_EQ(req, &connect_req);
ASSERT_OK(status);
pipe_client_connect_cb_called++;
@ -56,7 +56,7 @@ static void pipe_server_connection_cb(uv_stream_t* handle, int status) {
/* This function *may* be called, depending on whether accept or the
* connection callback is called first.
*/
ASSERT(status == 0);
ASSERT_OK(status);
}
@ -71,23 +71,23 @@ TEST_IMPL(pipe_server_close) {
ASSERT_NOT_NULL(loop);
r = uv_pipe_init(loop, &pipe_server, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&pipe_server, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_listen((uv_stream_t*) &pipe_server, 0, pipe_server_connection_cb);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_init(loop, &pipe_client, 0);
ASSERT(r == 0);
ASSERT_OK(r);
uv_pipe_connect(&connect_req, &pipe_client, TEST_PIPENAME, pipe_client_connect_cb);
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(pipe_client_connect_cb_called == 1);
ASSERT(pipe_close_cb_called == 2);
ASSERT_OK(r);
ASSERT_EQ(1, pipe_client_connect_cb_called);
ASSERT_EQ(2, pipe_close_cb_called);
MAKE_VALGRIND_HAPPY(loop);
return 0;

18
deps/libuv/test/test-pipe-set-fchmod.c vendored
View File

@ -35,10 +35,10 @@ TEST_IMPL(pipe_set_chmod) {
loop = uv_default_loop();
r = uv_pipe_init(loop, &pipe_handle, 0);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_pipe_bind(&pipe_handle, TEST_PIPENAME);
ASSERT(r == 0);
ASSERT_OK(r);
/* No easy way to test if this works, we will only make sure that the call is
* successful. */
@ -47,17 +47,17 @@ TEST_IMPL(pipe_set_chmod) {
MAKE_VALGRIND_HAPPY(loop);
RETURN_SKIP("Insufficient privileges to alter pipe fmode");
}
ASSERT(r == 0);
ASSERT_OK(r);
#ifndef _WIN32
memset(&stat_buf, 0, sizeof(stat_buf));
ASSERT_EQ(0, stat(TEST_PIPENAME, &stat_buf));
ASSERT_OK(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);
ASSERT_OK(r);
#ifndef _WIN32
stat(TEST_PIPENAME, &stat_buf);
ASSERT(stat_buf.st_mode & S_IWUSR);
@ -66,7 +66,7 @@ TEST_IMPL(pipe_set_chmod) {
#endif
r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE | UV_READABLE);
ASSERT(r == 0);
ASSERT_OK(r);
#ifndef _WIN32
stat(TEST_PIPENAME, &stat_buf);
ASSERT(stat_buf.st_mode & S_IRUSR);
@ -78,14 +78,14 @@ TEST_IMPL(pipe_set_chmod) {
#endif
r = uv_pipe_chmod(NULL, UV_WRITABLE | UV_READABLE);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
r = uv_pipe_chmod(&pipe_handle, 12345678);
ASSERT(r == UV_EINVAL);
ASSERT_EQ(r, UV_EINVAL);
uv_close((uv_handle_t*)&pipe_handle, NULL);
r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE | UV_READABLE);
ASSERT(r == UV_EBADF);
ASSERT_EQ(r, UV_EBADF);
MAKE_VALGRIND_HAPPY(loop);
return 0;

36
deps/libuv/test/test-pipe-set-non-blocking.c vendored
View File

@ -46,13 +46,13 @@ static void thread_main(void* arg) {
uv_fs_req_cleanup(&req);
} while (n > 0 || (n == -1 && uv_errno == UV_EINTR));
ASSERT(n == 0);
ASSERT_OK(n);
}
#ifdef _WIN32
static void write_cb(uv_write_t* req, int status) {
ASSERT(status == 0);
ASSERT_OK(status);
req->handle = NULL; /* signal completion of write_cb */
}
#endif
@ -77,15 +77,15 @@ TEST_IMPL(pipe_set_non_blocking) {
uv_write_t write_req;
#endif
ASSERT(0 == uv_pipe_init(uv_default_loop(), &pipe_handle, 0));
ASSERT(0 == uv_pipe(fd, 0, 0));
ASSERT(0 == uv_pipe_open(&pipe_handle, fd[1]));
ASSERT(0 == uv_stream_set_blocking((uv_stream_t*) &pipe_handle, 1));
ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_handle, 0));
ASSERT_OK(uv_pipe(fd, 0, 0));
ASSERT_OK(uv_pipe_open(&pipe_handle, fd[1]));
ASSERT_OK(uv_stream_set_blocking((uv_stream_t*) &pipe_handle, 1));
fd[1] = -1; /* fd[1] is owned by pipe_handle now. */
ctx.fd = fd[0];
ASSERT(0 == uv_barrier_init(&ctx.barrier, 2));
ASSERT(0 == uv_thread_create(&thread, thread_main, &ctx));
ASSERT_OK(uv_barrier_init(&ctx.barrier, 2));
ASSERT_OK(uv_thread_create(&thread, thread_main, &ctx));
uv_barrier_wait(&ctx.barrier);
buf.len = sizeof(data);
@ -99,25 +99,29 @@ TEST_IMPL(pipe_set_non_blocking) {
*/
n = uv_try_write((uv_stream_t*) &pipe_handle, &buf, 1);
#ifdef _WIN32
ASSERT(n == UV_EAGAIN); /* E_NOTIMPL */
ASSERT(0 == uv_write(&write_req, (uv_stream_t*) &pipe_handle, &buf, 1, write_cb));
ASSERT_EQ(n, UV_EAGAIN); /* E_NOTIMPL */
ASSERT_OK(uv_write(&write_req,
(uv_stream_t*) &pipe_handle,
&buf,
1,
write_cb));
ASSERT_NOT_NULL(write_req.handle);
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
ASSERT_NULL(write_req.handle); /* check for signaled completion of write_cb */
n = buf.len;
#endif
ASSERT(n == sizeof(data));
ASSERT_EQ(n, sizeof(data));
nwritten += n;
}
uv_close((uv_handle_t*) &pipe_handle, NULL);
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(0 == uv_thread_join(&thread));
ASSERT_OK(uv_thread_join(&thread));
#ifdef _WIN32
ASSERT(0 == _close(fd[0])); /* fd[1] is closed by uv_close(). */
ASSERT_OK(_close(fd[0])); /* fd[1] is closed by uv_close(). */
#else
ASSERT(0 == close(fd[0])); /* fd[1] is closed by uv_close(). */
ASSERT_OK(close(fd[0])); /* fd[1] is closed by uv_close(). */
#endif
fd[0] = -1;
uv_barrier_destroy(&ctx.barrier);

40
deps/libuv/test/test-platform-output.c vendored
View File

@ -44,37 +44,37 @@ TEST_IMPL(platform_output) {
int err;
err = uv_get_process_title(buffer, sizeof(buffer));
ASSERT(err == 0);
ASSERT_OK(err);
printf("uv_get_process_title: %s\n", buffer);
size = sizeof(buffer);
err = uv_cwd(buffer, &size);
ASSERT(err == 0);
ASSERT_OK(err);
printf("uv_cwd: %s\n", buffer);
err = uv_resident_set_memory(&rss);
#if defined(__MSYS__)
ASSERT(err == UV_ENOSYS);
ASSERT_EQ(err, UV_ENOSYS);
#else
ASSERT(err == 0);
ASSERT_OK(err);
printf("uv_resident_set_memory: %llu\n", (unsigned long long) rss);
#endif
err = uv_uptime(&uptime);
#if defined(__PASE__)
ASSERT(err == UV_ENOSYS);
ASSERT_EQ(err, UV_ENOSYS);
#else
ASSERT(err == 0);
ASSERT(uptime > 0);
ASSERT_OK(err);
ASSERT_GT(uptime, 0);
printf("uv_uptime: %f\n", uptime);
#endif
err = uv_getrusage(&rusage);
ASSERT(err == 0);
ASSERT(rusage.ru_utime.tv_sec >= 0);
ASSERT(rusage.ru_utime.tv_usec >= 0);
ASSERT(rusage.ru_stime.tv_sec >= 0);
ASSERT(rusage.ru_stime.tv_usec >= 0);
ASSERT_OK(err);
ASSERT_GE(rusage.ru_utime.tv_sec, 0);
ASSERT_GE(rusage.ru_utime.tv_usec, 0);
ASSERT_GE(rusage.ru_stime.tv_sec, 0);
ASSERT_GE(rusage.ru_stime.tv_usec, 0);
printf("uv_getrusage:\n");
printf(" user: %llu sec %llu microsec\n",
(unsigned long long) rusage.ru_utime.tv_sec,
@ -92,9 +92,9 @@ TEST_IMPL(platform_output) {
err = uv_cpu_info(&cpus, &count);
#if defined(__CYGWIN__) || defined(__MSYS__)
ASSERT(err == UV_ENOSYS);
ASSERT_EQ(err, UV_ENOSYS);
#else
ASSERT(err == 0);
ASSERT_OK(err);
printf("uv_cpu_info:\n");
for (i = 0; i < count; i++) {
@ -113,7 +113,7 @@ TEST_IMPL(platform_output) {
uv_free_cpu_info(cpus, count);
err = uv_interface_addresses(&interfaces, &count);
ASSERT(err == 0);
ASSERT_OK(err);
printf("uv_interface_addresses:\n");
for (i = 0; i < count; i++) {
@ -149,7 +149,7 @@ TEST_IMPL(platform_output) {
uv_free_interface_addresses(interfaces, count);
err = uv_os_get_passwd(&pwd);
ASSERT_EQ(err, 0);
ASSERT_OK(err);
err = uv_os_get_group(&grp, pwd.gid);
#if defined(_WIN32)
@ -159,7 +159,7 @@ TEST_IMPL(platform_output) {
(void) member;
grp.groupname = "ENOTSUP";
#else
ASSERT_EQ(err, 0);
ASSERT_OK(err);
ASSERT_EQ(pwd.gid, grp.gid);
#endif
@ -183,14 +183,14 @@ TEST_IMPL(platform_output) {
#endif
pid = uv_os_getpid();
ASSERT(pid > 0);
ASSERT_GT(pid, 0);
printf("uv_os_getpid: %d\n", (int) pid);
ppid = uv_os_getppid();
ASSERT(ppid > 0);
ASSERT_GT(ppid, 0);
printf("uv_os_getppid: %d\n", (int) ppid);
err = uv_os_uname(&uname);
ASSERT(err == 0);
ASSERT_OK(err);
printf("uv_os_uname:\n");
printf(" sysname: %s\n", uname.sysname);
printf(" release: %s\n", uname.release);

24
deps/libuv/test/test-poll-close-doesnt-corrupt-stack.c vendored
View File

@ -59,12 +59,12 @@ static void NO_INLINE close_socket_and_verify_stack(void) {
data[i] = MARKER;
r = closesocket(sock);
ASSERT(r == 0);
ASSERT_OK(r);
uv_sleep(VERIFY_AFTER);
for (i = 0; i < ARRAY_SIZE(data); i++)
ASSERT(data[i] == MARKER);
ASSERT_EQ(data[i], MARKER);
}
#endif
@ -79,34 +79,34 @@ TEST_IMPL(poll_close_doesnt_corrupt_stack) {
struct sockaddr_in addr;
r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
ASSERT(r == 0);
ASSERT_OK(r);
sock = socket(AF_INET, SOCK_STREAM, 0);
ASSERT(sock != INVALID_SOCKET);
ASSERT_NE(sock, INVALID_SOCKET);
on = 1;
r = ioctlsocket(sock, FIONBIO, &on);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_ip4_addr("127.0.0.1", TEST_PORT, &addr);
ASSERT(r == 0);
ASSERT_OK(r);
r = connect(sock, (const struct sockaddr*) &addr, sizeof addr);
ASSERT(r != 0);
ASSERT(WSAGetLastError() == WSAEWOULDBLOCK);
ASSERT(r);
ASSERT_EQ(WSAGetLastError(), WSAEWOULDBLOCK);
r = uv_poll_init_socket(uv_default_loop(), &handle, sock);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_poll_start(&handle, UV_READABLE | UV_WRITABLE, poll_cb);
ASSERT(r == 0);
ASSERT_OK(r);
uv_close((uv_handle_t*) &handle, close_cb);
close_socket_and_verify_stack();
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

4
deps/libuv/test/test-poll-close.c vendored
View File

@ -50,7 +50,7 @@ TEST_IMPL(poll_close) {
{
struct WSAData wsa_data;
int r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
ASSERT(r == 0);
ASSERT_OK(r);
}
#endif
@ -66,7 +66,7 @@ TEST_IMPL(poll_close) {
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(close_cb_called == NUM_SOCKETS);
ASSERT_EQ(close_cb_called, NUM_SOCKETS);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

24
deps/libuv/test/test-poll-closesocket.c vendored
View File

@ -39,11 +39,11 @@ static void close_cb(uv_handle_t* h) {
static void poll_cb(uv_poll_t* h, int status, int events) {
int r;
ASSERT(status == 0);
ASSERT(h == &handle);
ASSERT_OK(status);
ASSERT_PTR_EQ(h, &handle);
r = uv_poll_start(&handle, UV_READABLE, poll_cb);
ASSERT(r == 0);
ASSERT_OK(r);
closesocket(sock);
uv_close((uv_handle_t*) &handle, close_cb);
@ -62,29 +62,29 @@ TEST_IMPL(poll_closesocket) {
struct sockaddr_in addr;
r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
ASSERT(r == 0);
ASSERT_OK(r);
sock = socket(AF_INET, SOCK_STREAM, 0);
ASSERT(sock != INVALID_SOCKET);
ASSERT_NE(sock, INVALID_SOCKET);
on = 1;
r = ioctlsocket(sock, FIONBIO, &on);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_ip4_addr("127.0.0.1", TEST_PORT, &addr);
ASSERT(r == 0);
ASSERT_OK(r);
r = connect(sock, (const struct sockaddr*) &addr, sizeof addr);
ASSERT(r != 0);
ASSERT(WSAGetLastError() == WSAEWOULDBLOCK);
ASSERT(r);
ASSERT_EQ(WSAGetLastError(), WSAEWOULDBLOCK);
r = uv_poll_init_socket(uv_default_loop(), &handle, sock);
ASSERT(r == 0);
ASSERT_OK(r);
r = uv_poll_start(&handle, UV_WRITABLE, poll_cb);
ASSERT(r == 0);
ASSERT_OK(r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
ASSERT_EQ(1, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

33
deps/libuv/test/test-poll-multiple-handles.c vendored
View File

@ -40,7 +40,7 @@ static void close_cb(uv_handle_t* handle) {
static void poll_cb(uv_poll_t* handle, int status, int events) {
/* Not a bound socket, linux immediately reports UV_READABLE, other OS do not */
ASSERT(events == UV_READABLE);
ASSERT_EQ(events, UV_READABLE);
}
TEST_IMPL(poll_multiple_handles) {
@ -51,20 +51,24 @@ TEST_IMPL(poll_multiple_handles) {
{
struct WSAData wsa_data;
int r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
ASSERT(r == 0);
ASSERT_OK(r);
}
#endif
sock = socket(AF_INET, SOCK_STREAM, 0);
#ifdef _WIN32
ASSERT(sock != INVALID_SOCKET);
ASSERT_NE(sock, INVALID_SOCKET);
#else
ASSERT(sock != -1);
ASSERT_NE(sock, -1);
#endif
ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &first_poll_handle, sock));
ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &second_poll_handle, sock));
ASSERT_OK(uv_poll_init_socket(uv_default_loop(),
&first_poll_handle,
sock));
ASSERT_OK(uv_poll_init_socket(uv_default_loop(),
&second_poll_handle,
sock));
ASSERT(0 == uv_poll_start(&first_poll_handle, UV_READABLE, poll_cb));
ASSERT_OK(uv_poll_start(&first_poll_handle, UV_READABLE, poll_cb));
/* We may not start polling while another polling handle is active
* on that fd.
@ -73,26 +77,27 @@ TEST_IMPL(poll_multiple_handles) {
/* We do not track handles in an O(1) lookupable way on Windows,
* so not checking that here.
*/
ASSERT(uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb) == UV_EEXIST);
ASSERT_EQ(uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb),
UV_EEXIST);
#endif
/* After stopping the other polling handle, we now should be able to poll */
ASSERT(0 == uv_poll_stop(&first_poll_handle));
ASSERT(0 == uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb));
ASSERT_OK(uv_poll_stop(&first_poll_handle));
ASSERT_OK(uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb));
/* Closing an already stopped polling handle is safe in any case */
uv_close((uv_handle_t*) &first_poll_handle, close_cb);
uv_unref((uv_handle_t*) &second_poll_handle);
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(close_cb_called == 1);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(1, close_cb_called);
uv_ref((uv_handle_t*) &second_poll_handle);
ASSERT(uv_is_active((uv_handle_t*) &second_poll_handle));
uv_close((uv_handle_t*) &second_poll_handle, close_cb);
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(close_cb_called == 2);
ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT_EQ(2, close_cb_called);
MAKE_VALGRIND_HAPPY(uv_default_loop());
return 0;

90
deps/libuv/test/test-poll-oob.c vendored
View File

@ -70,7 +70,7 @@ static void poll_cb(uv_poll_t* handle, int status, int events) {
int n;
int fd;
ASSERT(0 == uv_fileno((uv_handle_t*)handle, &fd));
ASSERT_OK(uv_fileno((uv_handle_t*)handle, &fd));
memset(buffer, 0, 5);
if (events & UV_PRIORITIZED) {
@ -79,10 +79,10 @@ static void poll_cb(uv_poll_t* handle, int status, int events) {
while (n == -1 && errno == EINTR);
ASSERT(n >= 0 || errno != EINVAL);
cli_pr_check = 1;
ASSERT(0 == uv_poll_stop(&poll_req[0]));
ASSERT(0 == uv_poll_start(&poll_req[0],
UV_READABLE | UV_WRITABLE,
poll_cb));
ASSERT_OK(uv_poll_stop(&poll_req[0]));
ASSERT_OK(uv_poll_start(&poll_req[0],
UV_READABLE | UV_WRITABLE,
poll_cb));
}
if (events & UV_READABLE) {
if (fd == client_fd) {
@ -91,21 +91,21 @@ static void poll_cb(uv_poll_t* handle, int status, int events) {
while (n == -1 && errno == EINTR);
ASSERT(n >= 0 || errno != EINVAL);
if (cli_rd_check == 1) {
ASSERT(strncmp(buffer, "world", n) == 0);
ASSERT(5 == n);
ASSERT_OK(strncmp(buffer, "world", n));
ASSERT_EQ(5, n);
cli_rd_check = 2;
}
if (cli_rd_check == 0) {
ASSERT(n == 4);
ASSERT(strncmp(buffer, "hello", n) == 0);
ASSERT_EQ(4, n);
ASSERT_OK(strncmp(buffer, "hello", n));
cli_rd_check = 1;
do {
do
n = recv(server_fd, &buffer, 5, 0);
while (n == -1 && errno == EINTR);
if (n > 0) {
ASSERT(n == 5);
ASSERT(strncmp(buffer, "world", n) == 0);
ASSERT_EQ(5, n);
ASSERT_OK(strncmp(buffer, "world", n));
cli_rd_check = 2;
}
} while (n > 0);
@ -118,8 +118,8 @@ static void poll_cb(uv_poll_t* handle, int status, int events) {
n = recv(server_fd, &buffer, 3, 0);
while (n == -1 && errno == EINTR);
ASSERT(n >= 0 || errno != EINVAL);
ASSERT(3 == n);
ASSERT(strncmp(buffer, "foo", n) == 0);
ASSERT_EQ(3, n);
ASSERT_OK(strncmp(buffer, "foo", n));
srv_rd_check = 1;
uv_poll_stop(&poll_req[1]);
}
@ -128,35 +128,39 @@ static void poll_cb(uv_poll_t* handle, int status, int events) {
do {
n = send(client_fd, "foo", 3, 0);
} while (n < 0 && errno == EINTR);
ASSERT(3 == n);
ASSERT_EQ(3, n);
}
}
static void connection_cb(uv_stream_t* handle, int status) {
int r;
ASSERT(0 == status);
ASSERT(0 == uv_accept(handle, (uv_stream_t*) &peer_handle));
ASSERT(0 == uv_fileno((uv_handle_t*) &peer_handle, &server_fd));
ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &poll_req[0], client_fd));
ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &poll_req[1], server_fd));
ASSERT(0 == uv_poll_start(&poll_req[0],
UV_PRIORITIZED | UV_READABLE | UV_WRITABLE,
poll_cb));
ASSERT(0 == uv_poll_start(&poll_req[1],
UV_READABLE,
poll_cb));
ASSERT_OK(status);
ASSERT_OK(uv_accept(handle, (uv_stream_t*) &peer_handle));
ASSERT_OK(uv_fileno((uv_handle_t*) &peer_handle, &server_fd));
ASSERT_OK(uv_poll_init_socket(uv_default_loop(),
&poll_req[0],
client_fd));
ASSERT_OK(uv_poll_init_socket(uv_default_loop(),
&poll_req[1],
server_fd));
ASSERT_OK(uv_poll_start(&poll_req[0],
UV_PRIORITIZED | UV_READABLE | UV_WRITABLE,
poll_cb));
ASSERT_OK(uv_poll_start(&poll_req[1],
UV_READABLE,
poll_cb));
do {
r = send(server_fd, "hello", 5, MSG_OOB);
} while (r < 0 && errno == EINTR);
ASSERT(5 == r);
ASSERT_EQ(5, r);
do {
r = send(server_fd, "world", 5, 0);
} while (r < 0 && errno == EINTR);
ASSERT(5 == r);
ASSERT_EQ(5, r);
ASSERT(0 == uv_idle_start(&idle, idle_cb));
ASSERT_OK(uv_idle_start(&idle, idle_cb));
}
@ -165,39 +169,39 @@ TEST_IMPL(poll_oob) {
int r = 0;
uv_loop_t* loop;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
ASSERT(0 == uv_tcp_init(loop, &server_handle));
ASSERT(0 == uv_tcp_init(loop, &client_handle));
ASSERT(0 == uv_tcp_init(loop, &peer_handle));
ASSERT(0 == uv_idle_init(loop, &idle));
ASSERT(0 == uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0));
ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb));
ASSERT_OK(uv_tcp_init(loop, &server_handle));
ASSERT_OK(uv_tcp_init(loop, &client_handle));
ASSERT_OK(uv_tcp_init(loop, &peer_handle));
ASSERT_OK(uv_idle_init(loop, &idle));
ASSERT_OK(uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0));
ASSERT_OK(uv_listen((uv_stream_t*) &server_handle, 1, connection_cb));
/* Ensure two separate packets */
ASSERT(0 == uv_tcp_nodelay(&client_handle, 1));
ASSERT_OK(uv_tcp_nodelay(&client_handle, 1));
client_fd = socket(PF_INET, SOCK_STREAM, 0);
ASSERT(client_fd >= 0);
ASSERT_GE(client_fd, 0);
do {
errno = 0;
r = connect(client_fd, (const struct sockaddr*)&addr, sizeof(addr));
} while (r == -1 && errno == EINTR);
ASSERT(r == 0);
ASSERT_OK(r);
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
ASSERT(ticks == kMaxTicks);
ASSERT_EQ(ticks, kMaxTicks);
/* Did client receive the POLLPRI message */
ASSERT(cli_pr_check == 1);
ASSERT_EQ(1, cli_pr_check);
/* Did client receive the POLLIN message */
ASSERT(cli_rd_check == 2);
ASSERT_EQ(2, cli_rd_check);
/* Could we write with POLLOUT and did the server receive our POLLOUT message
* through POLLIN.
*/
ASSERT(srv_rd_check == 1);
ASSERT_EQ(1, srv_rd_check);
MAKE_VALGRIND_HAPPY(loop);
return 0;

Some files were not shown because too many files have changed in this diff Show More