luo980/libuv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

unix: multiplicity

Browse Source
This commit is contained in:
Ryan Dahl 2011-08-31 04:18:29 +02:00 committed by Bert Belder
parent 0ba44cfd4e
commit 56dcaf9b06
38 changed files with 640 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/eio.h
View File

@ -195,7 +195,7 @@ enum
enum
{
EIO_MCL_CURRENT = 1,
EIO_MCL_FUTURE = 2,
EIO_MCL_FUTURE = 2
};
/* request priorities */
@ -203,7 +203,7 @@ enum
enum {
EIO_PRI_MIN = -4,
EIO_PRI_MAX = 4,
EIO_PRI_DEFAULT = 0,
EIO_PRI_DEFAULT = 0
};
/* eio request structure */

10
include/uv-unix.h
View File

@ -42,6 +42,16 @@ typedef struct {
typedef int uv_file;
#define UV_LOOP_PRIVATE_FIELDS \
ares_channel channel; \
/* \
* While the channel is active this timer is called once per second to be \
* sure that we're always calling ares_process. See the warning above the \
* definition of ares_timeout(). \
*/ \
ev_timer timer; \
struct ev_loop* ev;
#define UV_REQ_BUFSML_SIZE (4)
#define UV_REQ_PRIVATE_FIELDS /* empty */

84
include/uv.h
View File

@ -19,7 +19,7 @@
* IN THE SOFTWARE.
*/
/* See uv_init for an introduction. */
/* See uv_loop_new for an introduction. */
#ifndef UV_H
#define UV_H
@ -41,6 +41,8 @@ extern "C" {
typedef intptr_t ssize_t;
#endif
typedef struct uv_loop_s uv_loop_t;
typedef struct uv_ares_task_s uv_ares_task_t;
typedef struct uv_err_s uv_err_t;
typedef struct uv_handle_s uv_handle_t;
typedef struct uv_stream_s uv_stream_t;
@ -54,6 +56,7 @@ typedef struct uv_idle_s uv_idle_t;
typedef struct uv_async_s uv_async_t;
typedef struct uv_getaddrinfo_s uv_getaddrinfo_t;
typedef struct uv_process_s uv_process_t;
typedef struct uv_counters_s uv_counters_t;
/* Request types */
typedef struct uv_req_s uv_req_t;
typedef struct uv_shutdown_s uv_shutdown_t;
@ -73,32 +76,35 @@ typedef struct uv_work_s uv_work_t;
/*
* This function must be called before any other functions in libuv.
*
* At the moment libuv is single threaded but this will likely change in the
* near future. Basically it will change by uv_init() taking a 'loop'
* argument and all other _init having a first argument as the the 'loop'.
*
* All functions besides uv_run() are non-blocking.
*
* All callbacks in libuv are made asynchronously. That is they are never
* made by the function that takes them as a parameter.
*/
void uv_init();
uv_loop_t* uv_loop_new();
void uv_loop_delete(uv_loop_t*);
/*
* Returns the default loop.
*/
uv_loop_t* uv_default_loop();
/*
* This function starts the event loop. It blocks until the reference count
* of the loop drops to zero.
*/
int uv_run();
int uv_run(uv_loop_t*);
/*
* Manually modify the event loop's reference count. Useful if the user wants
* to have a handle or timeout that doesn't keep the loop alive.
*/
void uv_ref();
void uv_unref();
void uv_ref(uv_loop_t*);
void uv_unref(uv_loop_t*);
void uv_update_time();
int64_t uv_now();
void uv_update_time(uv_loop_t*);
int64_t uv_now(uv_loop_t*);
/*
@ -223,13 +229,14 @@ struct uv_err_s {
* On error the user should then call uv_last_error() to determine
* the error code.
*/
uv_err_t uv_last_error();
uv_err_t uv_last_error(uv_loop_t*);
char* uv_strerror(uv_err_t err);
const char* uv_err_name(uv_err_t err);
#define UV_REQ_FIELDS \
/* read-only */ \
uv_loop_t* loop; \
uv_req_type type; \
/* public */ \
void* data; \
@ -266,6 +273,7 @@ struct uv_shutdown_s {
#define UV_HANDLE_FIELDS \
/* read-only */ \
uv_loop_t* loop; \
uv_handle_type type; \
/* public */ \
uv_close_cb close_cb; \
@ -358,7 +366,7 @@ typedef enum {
UV_STDERR
} uv_std_type;
uv_stream_t* uv_std_handle(uv_std_type type);
uv_stream_t* uv_std_handle(uv_loop_t*, uv_std_type type);
/*
* Write data to stream. Buffers are written in order. Example:
@ -402,7 +410,7 @@ struct uv_tcp_s {
UV_TCP_PRIVATE_FIELDS
};
int uv_tcp_init(uv_tcp_t* handle);
int uv_tcp_init(uv_loop_t*, uv_tcp_t* handle);
int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in);
int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6);
@ -485,7 +493,7 @@ struct uv_udp_send_s {
* Initialize a new UDP handle. The actual socket is created lazily.
* Returns 0 on success.
*/
int uv_udp_init(uv_udp_t* handle);
int uv_udp_init(uv_loop_t*, uv_udp_t* handle);
/*
* Bind to a IPv4 address and port.
@ -590,7 +598,7 @@ struct uv_pipe_s {
UV_PIPE_PRIVATE_FIELDS
};
int uv_pipe_init(uv_pipe_t* handle);
int uv_pipe_init(uv_loop_t*, uv_pipe_t* handle);
int uv_pipe_bind(uv_pipe_t* handle, const char* name);
@ -610,7 +618,7 @@ struct uv_prepare_s {
UV_PREPARE_PRIVATE_FIELDS
};
int uv_prepare_init(uv_prepare_t* prepare);
int uv_prepare_init(uv_loop_t*, uv_prepare_t* prepare);
int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb);
@ -628,7 +636,7 @@ struct uv_check_s {
UV_CHECK_PRIVATE_FIELDS
};
int uv_check_init(uv_check_t* check);
int uv_check_init(uv_loop_t*, uv_check_t* check);
int uv_check_start(uv_check_t* check, uv_check_cb cb);
@ -648,7 +656,7 @@ struct uv_idle_s {
UV_IDLE_PRIVATE_FIELDS
};
int uv_idle_init(uv_idle_t* idle);
int uv_idle_init(uv_loop_t*, uv_idle_t* idle);
int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb);
@ -670,7 +678,7 @@ struct uv_async_s {
UV_ASYNC_PRIVATE_FIELDS
};
int uv_async_init(uv_async_t* async, uv_async_cb async_cb);
int uv_async_init(uv_loop_t*, uv_async_t* async, uv_async_cb async_cb);
/*
* This can be called from other threads to wake up a libuv thread.
@ -691,7 +699,7 @@ struct uv_timer_s {
UV_TIMER_PRIVATE_FIELDS
};
int uv_timer_init(uv_timer_t* timer);
int uv_timer_init(uv_loop_t*, uv_timer_t* timer);
int uv_timer_start(uv_timer_t* timer, uv_timer_cb cb, int64_t timeout,
int64_t repeat);
@ -717,11 +725,13 @@ int64_t uv_timer_get_repeat(uv_timer_t* timer);
/* c-ares integration initialize and terminate */
int uv_ares_init_options(ares_channel *channelptr,
int uv_ares_init_options(uv_loop_t*,
ares_channel *channelptr,
struct ares_options *options,
int optmask);
void uv_ares_destroy(ares_channel channel);
/* TODO remove the loop argument from this function? */
void uv_ares_destroy(uv_loop_t*, ares_channel channel);
/*
@ -745,7 +755,8 @@ struct uv_getaddrinfo_s {
* Input arguments may be released after return from this call. Callback
* must not call freeaddrinfo.
*/
int uv_getaddrinfo(uv_getaddrinfo_t* handle,
int uv_getaddrinfo(uv_loop_t*,
uv_getaddrinfo_t* handle,
uv_getaddrinfo_cb getaddrinfo_cb,
const char* node,
const char* service,
@ -799,7 +810,7 @@ struct uv_process_s {
};
/* Initializes uv_process_t and starts the process. */
int uv_spawn(uv_process_t*, uv_process_options_t options);
int uv_spawn(uv_loop_t*, uv_process_t*, uv_process_options_t options);
/*
* Kills the process with the specified signal. The user must still
@ -941,8 +952,8 @@ union uv_any_req {
};
/* Diagnostic counters */
typedef struct {
struct uv_counters_s {
uint64_t eio_init;
uint64_t req_init;
uint64_t handle_init;
uint64_t stream_init;
@ -955,9 +966,24 @@ typedef struct {
uint64_t async_init;
uint64_t timer_init;
uint64_t process_init;
} uv_counters_t;
};
uv_counters_t* uv_counters();
struct uv_loop_s {
UV_LOOP_PRIVATE_FIELDS
/* list used for ares task handles */
uv_ares_task_t* uv_ares_handles_;
/* Various thing for libeio. */
uv_async_t uv_eio_want_poll_notifier;
uv_async_t uv_eio_done_poll_notifier;
uv_idle_t uv_eio_poller;
/* Diagnostic counters */
uv_counters_t counters;
/* The last error */
uv_err_t last_err;
/* User data - use this for whatever. */
void* data;
};
/* Don't export the private CPP symbols. */

30
src/uv-common.c
View File

@ -31,9 +31,6 @@
#include "ares/inet_net_pton.h"
#include "ares/inet_ntop.h"
/* list used for ares task handles */
static uv_ares_task_t* uv_ares_handles_ = NULL;
static uv_counters_t counters;
@ -135,20 +132,23 @@ int uv_ip6_name(struct sockaddr_in6* src, char* dst, size_t size) {
/* find matching ares handle in list */
void uv_add_ares_handle(uv_ares_task_t* handle) {
handle->ares_next = uv_ares_handles_;
void uv_add_ares_handle(uv_loop_t* loop, uv_ares_task_t* handle) {
handle->loop = loop;
handle->ares_next = loop->uv_ares_handles_;
handle->ares_prev = NULL;
if (uv_ares_handles_) {
uv_ares_handles_->ares_prev = handle;
if (loop->uv_ares_handles_) {
loop->uv_ares_handles_->ares_prev = handle;
}
uv_ares_handles_ = handle;
loop->uv_ares_handles_ = handle;
}
/* find matching ares handle in list */
/* TODO: faster lookup */
uv_ares_task_t* uv_find_ares_handle(ares_socket_t sock) {
uv_ares_task_t* handle = uv_ares_handles_;
uv_ares_task_t* uv_find_ares_handle(uv_loop_t* loop, ares_socket_t sock) {
uv_ares_task_t* handle = loop->uv_ares_handles_;
while (handle != NULL) {
if (handle->sock == sock) {
break;
@ -161,8 +161,10 @@ uv_ares_task_t* uv_find_ares_handle(ares_socket_t sock) {
/* remove ares handle in list */
void uv_remove_ares_handle(uv_ares_task_t* handle) {
if (handle == uv_ares_handles_) {
uv_ares_handles_ = handle->ares_next;
uv_loop_t* loop = handle->loop;
if (handle == loop->uv_ares_handles_) {
loop->uv_ares_handles_ = handle->ares_next;
}
if (handle->ares_next) {
@ -176,6 +178,6 @@ void uv_remove_ares_handle(uv_ares_task_t* handle) {
/* Returns 1 if the uv_ares_handles_ list is empty. 0 otherwise. */
int uv_ares_handles_empty() {
return uv_ares_handles_ ? 0 : 1;
int uv_ares_handles_empty(uv_loop_t* loop) {
return loop->uv_ares_handles_ ? 0 : 1;
}

14
src/uv-common.h
View File

@ -38,11 +38,6 @@
req->errorno = errno; \
}
/*
* Subclass of uv_handle_t. Used for integration of c-ares.
*/
typedef struct uv_ares_task_s uv_ares_task_t;
struct uv_ares_task_s {
UV_HANDLE_FIELDS
UV_ARES_TASK_PRIVATE_FIELDS
@ -52,9 +47,12 @@ struct uv_ares_task_s {
void uv_remove_ares_handle(uv_ares_task_t* handle);
uv_ares_task_t* uv_find_ares_handle(ares_socket_t sock);
void uv_add_ares_handle(uv_ares_task_t* handle);
int uv_ares_handles_empty();
uv_ares_task_t* uv_find_ares_handle(uv_loop_t*, ares_socket_t sock);
/* TODO Rename to uv_ares_task_init? */
void uv_add_ares_handle(uv_loop_t* loop, uv_ares_task_t* handle);
int uv_ares_handles_empty(uv_loop_t* loop);
#endif /* UV_COMMON_H_ */

65
src/uv-eio.c
View File

@ -25,48 +25,46 @@
#include <assert.h>
static uv_async_t uv_eio_want_poll_notifier;
static uv_async_t uv_eio_done_poll_notifier;
static uv_idle_t uv_eio_poller;
static int uv_eio_init_count;
static void uv_eio_do_poll(uv_idle_t* watcher, int status) {
assert(watcher == &uv_eio_poller);
assert(watcher == &(watcher->loop->uv_eio_poller));
/* printf("uv_eio_poller\n"); */
if (eio_poll() != -1 && uv_is_active((uv_handle_t*) &uv_eio_poller)) {
if (eio_poll() != -1 && uv_is_active((uv_handle_t*) watcher)) {
/* printf("uv_eio_poller stop\n"); */
uv_idle_stop(&uv_eio_poller);
uv_unref();
uv_idle_stop(watcher);
uv_unref(watcher->loop);
}
}
/* Called from the main thread. */
static void uv_eio_want_poll_notifier_cb(uv_async_t* watcher, int status) {
assert(watcher == &uv_eio_want_poll_notifier);
uv_loop_t* loop = watcher->loop;
assert(watcher == &loop->uv_eio_want_poll_notifier);
/* printf("want poll notifier\n"); */
if (eio_poll() == -1 && !uv_is_active((uv_handle_t*) &uv_eio_poller)) {
if (eio_poll() == -1 && !uv_is_active((uv_handle_t*) &loop->uv_eio_poller)) {
/* printf("uv_eio_poller start\n"); */
uv_idle_start(&uv_eio_poller, uv_eio_do_poll);
uv_ref();
uv_idle_start(&loop->uv_eio_poller, uv_eio_do_poll);
uv_ref(loop);
}
}
static void uv_eio_done_poll_notifier_cb(uv_async_t* watcher, int revents) {
assert(watcher == &uv_eio_done_poll_notifier);
uv_loop_t* loop = watcher->loop;
assert(watcher == &loop->uv_eio_done_poll_notifier);
/* printf("done poll notifier\n"); */
if (eio_poll() != -1 && uv_is_active((uv_handle_t*) &uv_eio_poller)) {
if (eio_poll() != -1 && uv_is_active((uv_handle_t*) &loop->uv_eio_poller)) {
/* printf("uv_eio_poller stop\n"); */
uv_idle_stop(&uv_eio_poller);
uv_unref();
uv_idle_stop(&loop->uv_eio_poller);
uv_unref(loop);
}
}
@ -77,7 +75,15 @@ static void uv_eio_done_poll_notifier_cb(uv_async_t* watcher, int revents) {
*/
static void uv_eio_want_poll(void) {
/* Signal the main thread that eio_poll need to be processed. */
#if 0
/*
* TODO need to select the correct uv_loop_t and async_send to
* uv_eio_want_poll_notifier.
*/
uv_async_send(&uv_eio_want_poll_notifier);
#endif
}
@ -86,22 +92,27 @@ static void uv_eio_done_poll(void) {
* Signal the main thread that we should stop calling eio_poll().
* from the idle watcher.
*/
#if 0
uv_async_send(&uv_eio_done_poll_notifier);
#endif
}
void uv_eio_init() {
if (uv_eio_init_count == 0) {
uv_eio_init_count++;
void uv_eio_init(uv_loop_t* loop) {
if (loop->counters.eio_init == 0) {
loop->counters.eio_init++;
uv_idle_init(&uv_eio_poller);
uv_idle_start(&uv_eio_poller, uv_eio_do_poll);
uv_idle_init(loop, &loop->uv_eio_poller);
uv_idle_start(&loop->uv_eio_poller, uv_eio_do_poll);
uv_async_init(&uv_eio_want_poll_notifier, uv_eio_want_poll_notifier_cb);
uv_unref();
uv_async_init(loop, &loop->uv_eio_want_poll_notifier,
uv_eio_want_poll_notifier_cb);
uv_unref(loop);
uv_async_init(&uv_eio_done_poll_notifier, uv_eio_done_poll_notifier_cb);
uv_unref();
uv_async_init(loop, &loop->uv_eio_done_poll_notifier,
uv_eio_done_poll_notifier_cb);
uv_unref(loop);
eio_init(uv_eio_want_poll, uv_eio_done_poll);
/*

2
src/uv-eio.h
View File

@ -9,5 +9,5 @@
* safe to call more than once.
* TODO: uv_eio_deinit
*/
void uv_eio_init(void);
void uv_eio_init(uv_loop_t*);
#endif

472
src/uv-unix.c
View File

File diff suppressed because it is too large Load Diff

2
test/benchmark-ares.c
View File

@ -84,7 +84,7 @@ BENCHMARK_IMPL(gethostbyname) {
return 1;
}
uv_init();
ares_callbacks = 0;
ares_errors = 0;

2
test/benchmark-getaddrinfo.c
View File

@ -66,7 +66,7 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle) {
BENCHMARK_IMPL(getaddrinfo) {
int i;
uv_init();
uv_update_time();
start_time = uv_now();

2
test/benchmark-ping-pongs.c
View File

@ -198,7 +198,7 @@ static void pinger_new() {
BENCHMARK_IMPL(ping_pongs) {
uv_init();
start_time = uv_now();
pinger_new();

2
test/benchmark-pound.c
View File

@ -275,7 +275,7 @@ static int pound_it(int concurrency,
uint64_t start_time; /* in ns */
uint64_t end_time;
uv_init();
uv_update_time();
start = uv_now();

8
test/benchmark-pump.c
View File

@ -366,7 +366,7 @@ HELPER_IMPL(tcp_pump_server) {
int r;
type = TCP;
uv_init();
listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
/* Server */
@ -388,7 +388,7 @@ HELPER_IMPL(pipe_pump_server) {
int r;
type = PIPE;
uv_init();
/* Server */
server = (uv_stream_t*)&pipeServer;
@ -410,7 +410,7 @@ void tcp_pump(int n) {
TARGET_CONNECTIONS = n;
type = TCP;
uv_init();
connect_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
@ -426,7 +426,7 @@ void pipe_pump(int n) {
TARGET_CONNECTIONS = n;
type = PIPE;
uv_init();
/* Start making connections */
maybe_connect_some();

2
test/benchmark-spawn.c
View File

@ -130,7 +130,7 @@ BENCHMARK_IMPL(spawn) {
int r;
static int64_t start_time, end_time;
uv_init();
r = uv_exepath(exepath, &exepath_size);
ASSERT(r == 0);

2
test/dns-server.c
View File

@ -314,7 +314,7 @@ static int dns_start(int port) {
HELPER_IMPL(dns_server) {
uv_init();
if (dns_start(TEST_PORT_2))
return 1;

43
test/echo-server.c
View File

@ -46,7 +46,7 @@ static void after_write(uv_write_t* req, int status) {
write_req_t* wr;
if (status) {
uv_err_t err = uv_last_error();
uv_err_t err = uv_last_error(uv_default_loop());
fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
ASSERT(0);
}
@ -72,7 +72,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
if (nread < 0) {
/* Error or EOF */
ASSERT (uv_last_error().code == UV_EOF);
ASSERT (uv_last_error(uv_default_loop()).code == UV_EOF);
if (buf.base) {
free(buf.base);
@ -133,7 +133,8 @@ static void on_connection(uv_stream_t* server, int status) {
int r;
if (status != 0) {
fprintf(stderr, "Connect error %d\n", uv_last_error().code);
fprintf(stderr, "Connect error %d\n",
uv_last_error(uv_default_loop()).code);
}
ASSERT(status == 0);
@ -141,13 +142,13 @@ static void on_connection(uv_stream_t* server, int status) {
case TCP:
stream = malloc(sizeof(uv_tcp_t));
ASSERT(stream != NULL);
uv_tcp_init((uv_tcp_t*)stream);
uv_tcp_init(uv_default_loop(), (uv_tcp_t*)stream);
break;
case PIPE:
stream = malloc(sizeof(uv_pipe_t));
ASSERT(stream != NULL);
uv_pipe_init((uv_pipe_t*)stream);
uv_pipe_init(uv_default_loop(), (uv_pipe_t*)stream);
break;
default:
@ -178,7 +179,7 @@ static int tcp4_echo_start(int port) {
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
r = uv_tcp_init(&tcpServer);
r = uv_tcp_init(uv_default_loop(), &tcpServer);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Socket creation error\n");
@ -195,7 +196,8 @@ static int tcp4_echo_start(int port) {
r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Listen error %s\n", uv_err_name(uv_last_error()));
fprintf(stderr, "Listen error %s\n",
uv_err_name(uv_last_error(uv_default_loop())));
return 1;
}
@ -210,7 +212,7 @@ static int tcp6_echo_start(int port) {
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
r = uv_tcp_init(&tcpServer);
r = uv_tcp_init(uv_default_loop(), &tcpServer);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Socket creation error\n");
@ -242,21 +244,24 @@ static int pipe_echo_start(char* pipeName) {
server = (uv_handle_t*)&pipeServer;
serverType = PIPE;
r = uv_pipe_init(&pipeServer);
r = uv_pipe_init(uv_default_loop(), &pipeServer);
if (r) {
fprintf(stderr, "uv_pipe_init: %s\n", uv_strerror(uv_last_error()));
fprintf(stderr, "uv_pipe_init: %s\n",
uv_strerror(uv_last_error(uv_default_loop())));
return 1;
}
r = uv_pipe_bind(&pipeServer, pipeName);
if (r) {
fprintf(stderr, "uv_pipe_bind: %s\n", uv_strerror(uv_last_error()));
fprintf(stderr, "uv_pipe_bind: %s\n",
uv_strerror(uv_last_error(uv_default_loop())));
return 1;
}
r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
if (r) {
fprintf(stderr, "uv_pipe_listen: %s\n", uv_strerror(uv_last_error()));
fprintf(stderr, "uv_pipe_listen: %s\n",
uv_strerror(uv_last_error(uv_default_loop())));
return 1;
}
@ -265,31 +270,33 @@ static int pipe_echo_start(char* pipeName) {
HELPER_IMPL(tcp4_echo_server) {
uv_init();
uv_loop_t* loop = uv_default_loop();
if (tcp4_echo_start(TEST_PORT))
return 1;
uv_run();
uv_run(loop);
return 0;
}
HELPER_IMPL(tcp6_echo_server) {
uv_init();
uv_loop_t* loop = uv_default_loop();
if (tcp6_echo_start(TEST_PORT))
return 1;
uv_run();
uv_run(loop);
return 0;
}
HELPER_IMPL(pipe_echo_server) {
uv_init();
uv_loop_t* loop = uv_default_loop();
if (pipe_echo_start(TEST_PIPENAME))
return 1;
uv_run();
uv_run(loop);
return 0;
}

8
test/test-async.c
View File

@ -182,14 +182,12 @@ static void prepare_cb(uv_prepare_t* handle, int status) {
TEST_IMPL(async) {
int r;
uv_init();
r = uv_prepare_init(&prepare_handle);
r = uv_prepare_init(uv_default_loop(), &prepare_handle);
ASSERT(r == 0);
r = uv_prepare_start(&prepare_handle, prepare_cb);
ASSERT(r == 0);
r = uv_async_init(&async1_handle, async1_cb);
r = uv_async_init(uv_default_loop(), &async1_handle, async1_cb);
ASSERT(r == 0);
#if 0
@ -197,7 +195,7 @@ TEST_IMPL(async) {
ASSERT(r == 0);
#endif
r = uv_run();
r = uv_run(uv_default_loop());
ASSERT(r == 0);
r = uv_wait_thread(thread1_id);

12
test/test-callback-stack.c
View File

@ -76,11 +76,11 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
free(buf.base);
if (nread == 0) {
ASSERT(uv_last_error().code == UV_EAGAIN);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EAGAIN);
return;
} else if (nread == -1) {
ASSERT(uv_last_error().code == UV_EOF);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
nested++;
uv_close((uv_handle_t*)tcp, close_cb);
@ -140,7 +140,7 @@ static void write_cb(uv_write_t* req, int status) {
/* back to our receive buffer when we start reading. This maximizes the */
/* tempation for the backend to use dirty stack for calling read_cb. */
nested++;
r = uv_timer_init(&timer);
r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);
r = uv_timer_start(&timer, timer_cb, 500, 0);
ASSERT(r == 0);
@ -176,9 +176,7 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(callback_stack) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
uv_init();
if (uv_tcp_init(&client)) {
if (uv_tcp_init(uv_default_loop(), &client)) {
FATAL("uv_tcp_init failed");
}
@ -191,7 +189,7 @@ TEST_IMPL(callback_stack) {
}
nested--;
uv_run();
uv_run(uv_default_loop());
ASSERT(nested == 0);
ASSERT(connect_cb_called == 1 && "connect_cb must be called exactly once");

14
test/test-connection-fail.c
View File

@ -69,7 +69,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
static void on_connect_with_close(uv_connect_t *req, int status) {
ASSERT((uv_stream_t*) &tcp == req->handle);
ASSERT(status == -1);
ASSERT(uv_last_error().code == UV_ECONNREFUSED);
ASSERT(uv_last_error(uv_default_loop()).code == UV_ECONNREFUSED);
connect_cb_calls++;
ASSERT(close_cb_calls == 0);
@ -79,7 +79,7 @@ static void on_connect_with_close(uv_connect_t *req, int status) {
static void on_connect_without_close(uv_connect_t *req, int status) {
ASSERT(status == -1);
ASSERT(uv_last_error().code == UV_ECONNREFUSED);
ASSERT(uv_last_error(uv_default_loop()).code == UV_ECONNREFUSED);
connect_cb_calls++;
uv_timer_start(&timer, timer_cb, 100, 0);
@ -98,7 +98,7 @@ void connection_fail(uv_connect_cb connect_cb) {
server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
/* Try to connec to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(&tcp);
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(!r);
/* We are never doing multiple reads/connects at a time anyway. */
@ -107,7 +107,7 @@ void connection_fail(uv_connect_cb connect_cb) {
r = uv_tcp_connect(&req, &tcp, server_addr, connect_cb);
ASSERT(!r);
uv_run();
uv_run(uv_default_loop());
ASSERT(connect_cb_calls == 1);
ASSERT(close_cb_calls == 1);
@ -119,7 +119,7 @@ void connection_fail(uv_connect_cb connect_cb) {
* expect an error.
*/
TEST_IMPL(connection_fail) {
uv_init();
connection_fail(on_connect_with_close);
@ -136,9 +136,9 @@ TEST_IMPL(connection_fail) {
* attempt.
*/
TEST_IMPL(connection_fail_doesnt_auto_close) {
uv_init();
uv_timer_init(&timer);
uv_timer_init(uv_default_loop(), &timer);
connection_fail(on_connect_without_close);

26
test/test-delayed-accept.c
View File

@ -57,16 +57,16 @@ static void do_accept(uv_timer_t* timer_handle, int status) {
ASSERT(status == 0);
ASSERT(accepted_handle != NULL);
uv_tcp_init(accepted_handle);
uv_tcp_init(uv_default_loop(), accepted_handle);
/* Test to that uv_counters()->tcp_init does not increase across the uv_accept. */
tcpcnt = uv_counters()->tcp_init;
/* Test to that uv_default_loop()->counters.tcp_init does not increase across the uv_accept. */
tcpcnt = uv_default_loop()->counters.tcp_init;
server = (uv_tcp_t*)timer_handle->data;
r = uv_accept((uv_stream_t*)server, (uv_stream_t*)accepted_handle);
ASSERT(r == 0);
ASSERT(uv_counters()->tcp_init == tcpcnt);
ASSERT(uv_default_loop()->counters.tcp_init == tcpcnt);
do_accept_called++;
@ -93,7 +93,7 @@ static void connection_cb(uv_stream_t* tcp, int status) {
ASSERT(timer_handle != NULL);
/* Accept the client after 1 second */
r = uv_timer_init(timer_handle);
r = uv_timer_init(uv_default_loop(), timer_handle);
ASSERT(r == 0);
timer_handle->data = tcp;
@ -112,10 +112,10 @@ static void start_server() {
ASSERT(server != NULL);
r = uv_tcp_init(server);
r = uv_tcp_init(uv_default_loop(), server);
ASSERT(r == 0);
ASSERT(uv_counters()->tcp_init == 1);
ASSERT(uv_counters()->handle_init == 1);
ASSERT(uv_default_loop()->counters.tcp_init == 1);
ASSERT(uv_default_loop()->counters.handle_init == 1);
r = uv_tcp_bind(server, addr);
ASSERT(r == 0);
@ -134,11 +134,11 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
if (nread != -1) {
ASSERT(nread == 0);
ASSERT(uv_last_error().code == UV_EAGAIN);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EAGAIN);
} else {
ASSERT(tcp != NULL);
ASSERT(nread == -1);
ASSERT(uv_last_error().code == UV_EOF);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
uv_close((uv_handle_t*)tcp, close_cb);
}
}
@ -170,7 +170,7 @@ static void client_connect() {
ASSERT(client != NULL);
ASSERT(connect_req != NULL);
r = uv_tcp_init(client);
r = uv_tcp_init(uv_default_loop(), client);
ASSERT(r == 0);
r = uv_tcp_connect(connect_req, client, addr, connect_cb);
@ -180,14 +180,14 @@ static void client_connect() {
TEST_IMPL(delayed_accept) {
uv_init();
start_server();
client_connect();
client_connect();
uv_run();
uv_run(uv_default_loop());
ASSERT(connection_cb_called == 2);
ASSERT(do_accept_called == 2);

22
test/test-getaddrinfo.c
View File

@ -67,16 +67,17 @@ static void getaddrinfo_cuncurrent_cb(uv_getaddrinfo_t* handle,
TEST_IMPL(getaddrinfo_basic) {
int r;
uv_init();
r = uv_getaddrinfo(&getaddrinfo_handle,
r = uv_getaddrinfo(uv_default_loop(),
&getaddrinfo_handle,
&getaddrinfo_basic_cb,
name,
NULL,
NULL);
ASSERT(r == 0);
uv_run();
uv_run(uv_default_loop());
ASSERT(getaddrinfo_cbs == 1);
@ -87,20 +88,21 @@ TEST_IMPL(getaddrinfo_basic) {
TEST_IMPL(getaddrinfo_concurrent) {
int i, r;
uv_init();
for (i = 0; i < CONCURRENT_COUNT; i++) {
callback_counts[i] = 0;
r = uv_getaddrinfo(&getaddrinfo_handles[i],
&getaddrinfo_cuncurrent_cb,
name,
NULL,
NULL);
r = uv_getaddrinfo(uv_default_loop(),
&getaddrinfo_handles[i],
&getaddrinfo_cuncurrent_cb,
name,
NULL,
NULL);
ASSERT(r == 0);
}
uv_run();
uv_run(uv_default_loop());
for (i = 0; i < CONCURRENT_COUNT; i++) {
ASSERT(callback_counts[i] == 1);

18
test/test-gethostbyname.c
View File

@ -74,7 +74,7 @@ static void prep_tcploopback() {
options.tcp_port = htons(TEST_PORT);
options.flags = ARES_FLAG_USEVC;
rc = uv_ares_init_options(&channel, &options, optmask);
rc = uv_ares_init_options(uv_default_loop(), &channel, &options, optmask);
ASSERT(rc == ARES_SUCCESS);
}
@ -91,7 +91,7 @@ TEST_IMPL(gethostbyname) {
return 1;
}
uv_init();
printf("Start basic gethostbyname test\n");
prep_tcploopback();
@ -104,11 +104,11 @@ TEST_IMPL(gethostbyname) {
AF_INET,
&aresbynamecallback,
&bynamecallbacksig);
uv_run();
uv_run(uv_default_loop());
ASSERT(ares_bynamecallbacks == 1);
uv_ares_destroy(channel);
uv_ares_destroy(uv_default_loop(), channel);
printf("Done basic gethostbyname test\n");
@ -125,7 +125,7 @@ TEST_IMPL(gethostbyname) {
AF_INET,
&aresbynamecallback,
&bynamecallbacksig);
uv_run();
uv_run(uv_default_loop());
ASSERT(ares_bynamecallbacks == 1);
@ -143,11 +143,11 @@ TEST_IMPL(gethostbyname) {
&aresbyaddrcallback,
&byaddrcallbacksig);
uv_run();
uv_run(uv_default_loop());
ASSERT(ares_byaddrcallbacks == 1);
uv_ares_destroy(channel);
uv_ares_destroy(uv_default_loop(), channel);
printf("Done gethostbyname and gethostbyaddr sequential test\n");
@ -179,13 +179,13 @@ TEST_IMPL(gethostbyname) {
&aresbyaddrcallback,
&byaddrcallbacksig);
uv_run();
uv_run(uv_default_loop());
ASSERT(ares_bynamecallbacks == 1);
ASSERT(ares_byaddrcallbacks == 1);
uv_ares_destroy(channel);
uv_ares_destroy(uv_default_loop(), channel);
printf("Done gethostbyname and gethostbyaddr concurrent test\n");
return 0;

24
test/test-getsockname.c
View File

@ -78,14 +78,15 @@ static void on_connection(uv_stream_t* server, int status) {
int r;
if (status != 0) {
fprintf(stderr, "Connect error %d\n", uv_last_error().code);
fprintf(stderr, "Connect error %d\n",
uv_last_error(uv_default_loop()).code);
}
ASSERT(status == 0);
handle = (uv_handle_t*) malloc(sizeof(uv_tcp_t));
ASSERT(handle != NULL);
uv_tcp_init((uv_tcp_t*)handle);
uv_tcp_init(uv_default_loop(), (uv_tcp_t*)handle);
/* associate server with stream */
handle->data = server;
@ -95,7 +96,8 @@ static void on_connection(uv_stream_t* server, int status) {
status = uv_getsockname(handle, &sockname, &namelen);
if (status != 0) {
fprintf(stderr, "uv_getsockname error (accepted) %d\n", uv_last_error().code);
fprintf(stderr, "uv_getsockname error (accepted) %d\n",
uv_last_error(uv_default_loop()).code);
}
ASSERT(status == 0);
@ -115,7 +117,8 @@ static void on_connect(uv_connect_t* req, int status) {
r = uv_getsockname((uv_handle_t*)&tcp, &sockname, &namelen);
if (r != 0) {
fprintf(stderr, "uv_getsockname error (connector) %d\n", uv_last_error().code);
fprintf(stderr, "uv_getsockname error (connector) %d\n",
uv_last_error(uv_default_loop()).code);
}
ASSERT(r == 0);
@ -132,7 +135,7 @@ static int tcp_listener(int port) {
char ip[20];
int r;
r = uv_tcp_init(&tcpServer);
r = uv_tcp_init(uv_default_loop(), &tcpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
@ -154,7 +157,8 @@ static int tcp_listener(int port) {
r = uv_getsockname((uv_handle_t*)&tcpServer, &sockname, &namelen);
if (r != 0) {
fprintf(stderr, "uv_getsockname error (listening) %d\n", uv_last_error().code);
fprintf(stderr, "uv_getsockname error (listening) %d\n",
uv_last_error(uv_default_loop()).code);
}
ASSERT(r == 0);
@ -175,7 +179,7 @@ static void tcp_connector() {
int r;
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
r = uv_tcp_init(&tcp);
r = uv_tcp_init(uv_default_loop(), &tcp);
tcp.data = &connect_req;
ASSERT(!r);
@ -284,14 +288,14 @@ static void udp_sender(void) {
TEST_IMPL(getsockname_tcp) {
uv_init();
if (tcp_listener(TEST_PORT))
return 1;
tcp_connector();
uv_run();
uv_run(uv_default_loop());
ASSERT(getsocknamecount == 3);
@ -312,4 +316,4 @@ TEST_IMPL(getsockname_udp) {
ASSERT(getsocknamecount == 2);
return 0;
}
}

8
test/test-idle.c
View File

@ -60,19 +60,19 @@ static void idle_cb(uv_idle_t* handle, int status) {
TEST_IMPL(idle_starvation) {
int r;
uv_init();
r = uv_idle_init(&idle_handle);
r = uv_idle_init(uv_default_loop(), &idle_handle);
ASSERT(r == 0);
r = uv_idle_start(&idle_handle, idle_cb);
ASSERT(r == 0);
r = uv_timer_init(&timer_handle);
r = uv_timer_init(uv_default_loop(), &timer_handle);
ASSERT(r == 0);
r = uv_timer_start(&timer_handle, timer_cb, 50, 0);
ASSERT(r == 0);
r = uv_run();
r = uv_run(uv_default_loop());
ASSERT(r == 0);
ASSERT(idle_cb_called > 0);

18
test/test-loop-handles.c
View File

@ -153,7 +153,7 @@ static void idle_1_cb(uv_idle_t* handle, int status) {
/* Init idle_2 and make it active */
if (!idle_2_is_active) {
r = uv_idle_init(&idle_2_handle);
r = uv_idle_init(uv_default_loop(), &idle_2_handle);
ASSERT(r == 0);
r = uv_idle_start(&idle_2_handle, idle_2_cb);
ASSERT(r == 0);
@ -299,25 +299,25 @@ TEST_IMPL(loop_handles) {
int i;
int r;
uv_init();
r = uv_prepare_init(&prepare_1_handle);
r = uv_prepare_init(uv_default_loop(), &prepare_1_handle);
ASSERT(r == 0);
r = uv_prepare_start(&prepare_1_handle, prepare_1_cb);
ASSERT(r == 0);
r = uv_check_init(&check_handle);
r = uv_check_init(uv_default_loop(), &check_handle);
ASSERT(r == 0);
r = uv_check_start(&check_handle, check_cb);
ASSERT(r == 0);
/* initialize only, prepare_2 is started by prepare_1_cb */
r = uv_prepare_init(&prepare_2_handle);
r = uv_prepare_init(uv_default_loop(), &prepare_2_handle);
ASSERT(r == 0);
for (i = 0; i < IDLE_COUNT; i++) {
/* initialize only, idle_1 handles are started by check_cb */
r = uv_idle_init(&idle_1_handles[i]);
r = uv_idle_init(uv_default_loop(), &idle_1_handles[i]);
ASSERT(r == 0);
}
@ -325,13 +325,13 @@ 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(&timer_handle);
r = uv_timer_init(uv_default_loop(), &timer_handle);
ASSERT(r == 0);
r = uv_timer_start(&timer_handle, timer_cb, TIMEOUT, TIMEOUT);
ASSERT(r == 0);
uv_unref();
uv_unref(uv_default_loop());
r = uv_run();
r = uv_run(uv_default_loop());
ASSERT(r == 0);
ASSERT(loop_iteration == ITERATIONS);

20
test/test-ping-pong.c
View File

@ -100,7 +100,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
pinger = (pinger_t*)stream->data;
if (nread < 0) {
ASSERT(uv_last_error().code == UV_EOF);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
puts("got EOF");
@ -155,7 +155,7 @@ static void tcp_pinger_v6_new() {
pinger->pongs = 0;
/* Try to connec to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(&pinger->tcp);
r = uv_tcp_init(uv_default_loop(), &pinger->tcp);
pinger->tcp.data = pinger;
ASSERT(!r);
@ -180,7 +180,7 @@ static void tcp_pinger_new() {
pinger->pongs = 0;
/* Try to connec to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(&pinger->tcp);
r = uv_tcp_init(uv_default_loop(), &pinger->tcp);
pinger->tcp.data = pinger;
ASSERT(!r);
@ -204,7 +204,7 @@ static void pipe_pinger_new() {
pinger->pongs = 0;
/* Try to connec to the server and do NUM_PINGS ping-pongs. */
r = uv_pipe_init(&pinger->pipe);
r = uv_pipe_init(uv_default_loop(), &pinger->pipe);
pinger->pipe.data = pinger;
ASSERT(!r);
@ -221,10 +221,10 @@ static void pipe_pinger_new() {
TEST_IMPL(tcp_ping_pong) {
uv_init();
tcp_pinger_new();
uv_run();
uv_run(uv_default_loop());
ASSERT(completed_pingers == 1);
@ -233,10 +233,10 @@ TEST_IMPL(tcp_ping_pong) {
TEST_IMPL(tcp_ping_pong_v6) {
uv_init();
tcp_pinger_v6_new();
uv_run();
uv_run(uv_default_loop());
ASSERT(completed_pingers == 1);
@ -245,10 +245,10 @@ TEST_IMPL(tcp_ping_pong_v6) {
TEST_IMPL(pipe_ping_pong) {
uv_init();
pipe_pinger_new();
uv_run();
uv_run(uv_default_loop());
ASSERT(completed_pingers == 1);

36
test/test-pipe-bind-error.c
View File

@ -45,31 +45,31 @@ TEST_IMPL(pipe_bind_error_addrinuse) {
uv_pipe_t server1, server2;
int r;
uv_init();
r = uv_pipe_init(&server1);
r = uv_pipe_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_pipe_bind(&server1, TEST_PIPENAME);
ASSERT(r == 0);
r = uv_pipe_init(&server2);
r = uv_pipe_init(uv_default_loop(), &server2);
ASSERT(r == 0);
r = uv_pipe_bind(&server2, TEST_PIPENAME);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRINUSE);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EADDRINUSE);
r = uv_listen((uv_stream_t*)&server1, SOMAXCONN, NULL);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&server2, SOMAXCONN, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EINVAL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
uv_close((uv_handle_t*)&server1, close_cb);
uv_close((uv_handle_t*)&server2, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 2);
@ -81,18 +81,18 @@ TEST_IMPL(pipe_bind_error_addrnotavail) {
uv_pipe_t server;
int r;
uv_init();
r = uv_pipe_init(&server);
r = uv_pipe_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_pipe_bind(&server, BAD_PIPENAME);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EACCESS);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EACCESS);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -104,20 +104,20 @@ TEST_IMPL(pipe_bind_error_inval) {
uv_pipe_t server;
int r;
uv_init();
r = uv_pipe_init(&server);
r = uv_pipe_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_pipe_bind(&server, TEST_PIPENAME);
ASSERT(r == 0);
r = uv_pipe_bind(&server, TEST_PIPENAME_2);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EINVAL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -129,18 +129,18 @@ TEST_IMPL(pipe_listen_without_bind) {
uv_pipe_t server;
int r;
uv_init();
r = uv_pipe_init(&server);
r = uv_pipe_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EINVAL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);

39
test/test-ref.c
View File

@ -24,51 +24,46 @@
TEST_IMPL(ref) {
uv_init();
uv_run();
uv_run(uv_default_loop());
return 0;
}
TEST_IMPL(idle_ref) {
uv_idle_t h;
uv_init();
uv_idle_init(&h);
uv_idle_init(uv_default_loop(), &h);
uv_idle_start(&h, NULL);
uv_unref();
uv_run();
uv_unref(uv_default_loop());
uv_run(uv_default_loop());
return 0;
}
TEST_IMPL(async_ref) {
uv_async_t h;
uv_init();
uv_async_init(&h, NULL);
uv_unref();
uv_run();
uv_async_init(uv_default_loop(), &h, NULL);
uv_unref(uv_default_loop());
uv_run(uv_default_loop());
return 0;
}
TEST_IMPL(prepare_ref) {
uv_prepare_t h;
uv_init();
uv_prepare_init(&h);
uv_prepare_init(uv_default_loop(), &h);
uv_prepare_start(&h, NULL);
uv_unref();
uv_run();
uv_unref(uv_default_loop());
uv_run(uv_default_loop());
return 0;
}
TEST_IMPL(check_ref) {
uv_check_t h;
uv_init();
uv_check_init(&h);
uv_check_init(uv_default_loop(), &h);
uv_check_start(&h, NULL);
uv_unref();
uv_run();
uv_unref(uv_default_loop());
uv_run(uv_default_loop());
return 0;
}
@ -77,15 +72,15 @@ static void prepare_cb(uv_prepare_t* handle, int status) {
ASSERT(handle != NULL);
ASSERT(status == 0);
uv_unref();
uv_unref(uv_default_loop());
}
TEST_IMPL(unref_in_prepare_cb) {
uv_prepare_t h;
uv_init();
uv_prepare_init(&h);
uv_prepare_init(uv_default_loop(), &h);
uv_prepare_start(&h, prepare_cb);
uv_run();
uv_run(uv_default_loop());
return 0;
}

10
test/test-shutdown-eof.c
View File

@ -48,7 +48,7 @@ static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
static void read_cb(uv_stream_t* t, ssize_t nread, uv_buf_t buf) {
uv_err_t err = uv_last_error();
uv_err_t err = uv_last_error(uv_default_loop());
ASSERT((uv_tcp_t*)t == &tcp);
@ -153,22 +153,22 @@ TEST_IMPL(shutdown_eof) {
struct sockaddr_in server_addr;
int r;
uv_init();
qbuf.base = "Q";
qbuf.len = 1;
uv_timer_init(&timer);
uv_timer_init(uv_default_loop(), &timer);
uv_timer_start(&timer, timer_cb, 100, 0);
server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
r = uv_tcp_init(&tcp);
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(!r);
r = uv_tcp_connect(&connect_req, &tcp, server_addr, connect_cb);
ASSERT(!r);
uv_run();
uv_run(uv_default_loop());
ASSERT(called_connect_cb == 1);
ASSERT(called_shutdown_cb == 1);

36
test/test-spawn.c
View File

@ -75,7 +75,7 @@ uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
uv_err_t err = uv_last_error();
uv_err_t err = uv_last_error(uv_default_loop());
if (nread > 0) {
output_used += nread;
@ -116,14 +116,14 @@ static void timer_cb(uv_timer_t* handle, int status) {
TEST_IMPL(spawn_exit_code) {
int r;
uv_init();
init_process_options("spawn_helper1", exit_cb);
r = uv_spawn(&process, options);
r = uv_spawn(uv_default_loop(), &process, options);
ASSERT(r == 0);
r = uv_run();
r = uv_run(uv_default_loop());
ASSERT(r == 0);
ASSERT(exit_cb_called == 1);
@ -137,20 +137,20 @@ TEST_IMPL(spawn_stdout) {
int r;
uv_pipe_t out;
uv_init();
init_process_options("spawn_helper2", exit_cb);
uv_pipe_init(&out);
uv_pipe_init(uv_default_loop(), &out);
options.stdout_stream = &out;
r = uv_spawn(&process, options);
r = uv_spawn(uv_default_loop(), &process, options);
ASSERT(r == 0);
r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
ASSERT(r == 0);
r = uv_run();
r = uv_run(uv_default_loop());
ASSERT(r == 0);
ASSERT(exit_cb_called == 1);
@ -170,16 +170,16 @@ int r;
uv_buf_t buf;
char buffer[] = "hello-from-spawn_stdin";
uv_init();
init_process_options("spawn_helper3", exit_cb);
uv_pipe_init(&out);
uv_pipe_init(&in);
uv_pipe_init(uv_default_loop(), &out);
uv_pipe_init(uv_default_loop(), &in);
options.stdout_stream = &out;
options.stdin_stream = &in;
r = uv_spawn(&process, options);
r = uv_spawn(uv_default_loop(), &process, options);
ASSERT(r == 0);
buf.base = buffer;
@ -190,7 +190,7 @@ int r;
r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
ASSERT(r == 0);
r = uv_run();
r = uv_run(uv_default_loop());
ASSERT(r == 0);
ASSERT(exit_cb_called == 1);
@ -204,20 +204,20 @@ int r;
TEST_IMPL(spawn_and_kill) {
int r;
uv_init();
init_process_options("spawn_helper4", kill_cb);
r = uv_spawn(&process, options);
r = uv_spawn(uv_default_loop(), &process, options);
ASSERT(r == 0);
r = uv_timer_init(&timer);
r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);
r = uv_timer_start(&timer, timer_cb, 500, 0);
ASSERT(r == 0);
r = uv_run();
r = uv_run(uv_default_loop());
ASSERT(r == 0);
ASSERT(exit_cb_called == 1);
@ -234,7 +234,7 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) {
char name[64];
HANDLE pipe_handle;
uv_init();
init_process_options("spawn_helper2", exit_cb);

50
test/test-tcp-bind-error.c
View File

@ -39,14 +39,14 @@ TEST_IMPL(tcp_bind_error_addrinuse) {
uv_tcp_t server1, server2;
int r;
uv_init();
r = uv_tcp_init(&server1);
r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind(&server1, addr);
ASSERT(r == 0);
r = uv_tcp_init(&server2);
r = uv_tcp_init(uv_default_loop(), &server2);
ASSERT(r == 0);
r = uv_tcp_bind(&server2, addr);
ASSERT(r == 0);
@ -56,12 +56,12 @@ TEST_IMPL(tcp_bind_error_addrinuse) {
r = uv_listen((uv_stream_t*)&server2, 128, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRINUSE);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EADDRINUSE);
uv_close((uv_handle_t*)&server1, close_cb);
uv_close((uv_handle_t*)&server2, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 2);
@ -74,20 +74,20 @@ TEST_IMPL(tcp_bind_error_addrnotavail_1) {
uv_tcp_t server;
int r;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
/* It seems that Linux is broken here - bind succeeds. */
if (r == -1) {
ASSERT(uv_last_error().code == UV_EADDRNOTAVAIL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EADDRNOTAVAIL);
}
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -100,17 +100,15 @@ TEST_IMPL(tcp_bind_error_addrnotavail_2) {
uv_tcp_t server;
int r;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRNOTAVAIL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EADDRNOTAVAIL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -126,18 +124,18 @@ TEST_IMPL(tcp_bind_error_fault) {
garbage_addr = (struct sockaddr_in*) &garbage;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, *garbage_addr);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EFAULT);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EFAULT);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -152,20 +150,20 @@ TEST_IMPL(tcp_bind_error_inval) {
uv_tcp_t server;
int r;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr1);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr2);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EINVAL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -179,9 +177,9 @@ TEST_IMPL(tcp_bind_localhost_ok) {
uv_tcp_t server;
int r;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
ASSERT(r == 0);
@ -194,8 +192,8 @@ TEST_IMPL(tcp_listen_without_bind) {
int r;
uv_tcp_t server;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&server, 128, NULL);
ASSERT(r == 0);

38
test/test-tcp-bind6-error.c
View File

@ -39,14 +39,14 @@ TEST_IMPL(tcp_bind6_error_addrinuse) {
uv_tcp_t server1, server2;
int r;
uv_init();
r = uv_tcp_init(&server1);
r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind6(&server1, addr);
ASSERT(r == 0);
r = uv_tcp_init(&server2);
r = uv_tcp_init(uv_default_loop(), &server2);
ASSERT(r == 0);
r = uv_tcp_bind6(&server2, addr);
ASSERT(r == 0);
@ -56,12 +56,12 @@ TEST_IMPL(tcp_bind6_error_addrinuse) {
r = uv_listen((uv_stream_t*)&server2, 128, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRINUSE);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EADDRINUSE);
uv_close((uv_handle_t*)&server1, close_cb);
uv_close((uv_handle_t*)&server2, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 2);
@ -74,17 +74,17 @@ TEST_IMPL(tcp_bind6_error_addrnotavail) {
uv_tcp_t server;
int r;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRNOTAVAIL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EADDRNOTAVAIL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -100,18 +100,18 @@ TEST_IMPL(tcp_bind6_error_fault) {
garbage_addr = (struct sockaddr_in6*) &garbage;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, *garbage_addr);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EFAULT);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EFAULT);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -126,20 +126,20 @@ TEST_IMPL(tcp_bind6_error_inval) {
uv_tcp_t server;
int r;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr1);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr2);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EINVAL);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 1);
@ -153,9 +153,9 @@ TEST_IMPL(tcp_bind6_localhost_ok) {
uv_tcp_t server;
int r;
uv_init();
r = uv_tcp_init(&server);
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);
ASSERT(r == 0);

10
test/test-tcp-writealot.c
View File

@ -87,7 +87,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
ASSERT(tcp != NULL);
if (nread < 0) {
ASSERT(uv_last_error().code == UV_EOF);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
printf("GOT EOF\n");
if (buf.base) {
@ -108,7 +108,7 @@ static void write_cb(uv_write_t* req, int status) {
ASSERT(req != NULL);
if (status) {
uv_err_t err = uv_last_error();
uv_err_t err = uv_last_error(uv_default_loop());
fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
ASSERT(0);
}
@ -176,15 +176,15 @@ TEST_IMPL(tcp_writealot) {
ASSERT(send_buffer != NULL);
uv_init();
r = uv_tcp_init(client);
r = uv_tcp_init(uv_default_loop(), client);
ASSERT(r == 0);
r = uv_tcp_connect(connect_req, client, addr, connect_cb);
ASSERT(r == 0);
uv_run();
uv_run(uv_default_loop());
ASSERT(shutdown_cb_called == 1);
ASSERT(connect_cb_called == 1);

28
test/test-timer-again.c
View File

@ -49,14 +49,15 @@ static void repeat_1_cb(uv_timer_t* handle, int status) {
ASSERT(uv_timer_get_repeat((uv_timer_t*)handle) == 50);
LOGF("repeat_1_cb called after %ld ms\n", (long int)(uv_now() - start_time));
LOGF("repeat_1_cb called after %ld ms\n",
(long int)(uv_now(uv_default_loop()) - start_time));
repeat_1_cb_called++;
r = uv_timer_again(&repeat_2);
ASSERT(r == 0);
if (uv_now() >= start_time + 500) {
if (uv_now(uv_default_loop()) >= start_time + 500) {
uv_close((uv_handle_t*)handle, close_cb);
/* We're not calling uv_timer_again on repeat_2 any more, so after this */
/* timer_2_cb is expected. */
@ -71,7 +72,8 @@ static void repeat_2_cb(uv_timer_t* handle, int status) {
ASSERT(status == 0);
ASSERT(repeat_2_cb_allowed);
LOGF("repeat_2_cb called after %ld ms\n", (long int)(uv_now() - start_time));
LOGF("repeat_2_cb called after %ld ms\n",
(long int)(uv_now(uv_default_loop()) - start_time));
repeat_2_cb_called++;
@ -93,21 +95,21 @@ static void repeat_2_cb(uv_timer_t* handle, int status) {
TEST_IMPL(timer_again) {
int r;
uv_init();
start_time = uv_now();
start_time = uv_now(uv_default_loop());
ASSERT(0 < start_time);
/* Verify that it is not possible to uv_timer_again a never-started timer. */
r = uv_timer_init(&dummy);
r = uv_timer_init(uv_default_loop(), &dummy);
ASSERT(r == 0);
r = uv_timer_again(&dummy);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EINVAL);
uv_unref();
ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
uv_unref(uv_default_loop());
/* Start timer repeat_1. */
r = uv_timer_init(&repeat_1);
r = uv_timer_init(uv_default_loop(), &repeat_1);
ASSERT(r == 0);
r = uv_timer_start(&repeat_1, repeat_1_cb, 50, 0);
ASSERT(r == 0);
@ -121,21 +123,21 @@ TEST_IMPL(timer_again) {
* Start another repeating timer. It'll be again()ed by the repeat_1 so
* it should not time out until repeat_1 stops.
*/
r = uv_timer_init(&repeat_2);
r = uv_timer_init(uv_default_loop(), &repeat_2);
ASSERT(r == 0);
r = uv_timer_start(&repeat_2, repeat_2_cb, 100, 100);
ASSERT(r == 0);
ASSERT(uv_timer_get_repeat(&repeat_2) == 100);
uv_run();
uv_run(uv_default_loop());
ASSERT(repeat_1_cb_called == 10);
ASSERT(repeat_2_cb_called == 2);
ASSERT(close_cb_called == 2);
LOGF("Test took %ld ms (expected ~700 ms)\n",
(long int)(uv_now() - start_time));
ASSERT(700 <= uv_now() - start_time);
(long int)(uv_now(uv_default_loop()) - start_time));
ASSERT(700 <= uv_now(uv_default_loop()) - start_time);
return 0;
}

18
test/test-timer.c
View File

@ -53,7 +53,7 @@ static void once_cb(uv_timer_t* handle, int status) {
uv_close((uv_handle_t*)handle, once_close_cb);
/* Just call this randomly for the code coverage. */
uv_update_time();
uv_update_time(uv_default_loop());
}
@ -90,37 +90,35 @@ TEST_IMPL(timer) {
uv_timer_t repeat, never;
int i, r;
uv_init();
start_time = uv_now();
start_time = uv_now(uv_default_loop());
ASSERT(0 < start_time);
/* Let 10 timers time out in 500 ms total. */
for (i = 0; i < 10; i++) {
once = (uv_timer_t*)malloc(sizeof(*once));
ASSERT(once != NULL);
r = uv_timer_init(once);
r = uv_timer_init(uv_default_loop(), once);
ASSERT(r == 0);
r = uv_timer_start(once, once_cb, i * 50, 0);
ASSERT(r == 0);
}
/* The 11th timer is a repeating timer that runs 4 times */
r = uv_timer_init(&repeat);
r = uv_timer_init(uv_default_loop(), &repeat);
ASSERT(r == 0);
r = uv_timer_start(&repeat, repeat_cb, 100, 100);
ASSERT(r == 0);
/* The 12th timer should not do anything. */
r = uv_timer_init(&never);
r = uv_timer_init(uv_default_loop(), &never);
ASSERT(r == 0);
r = uv_timer_start(&never, never_cb, 100, 100);
ASSERT(r == 0);
r = uv_timer_stop(&never);
ASSERT(r == 0);
uv_unref();
uv_unref(uv_default_loop());
uv_run();
uv_run(uv_default_loop());
ASSERT(once_cb_called == 10);
ASSERT(once_close_cb_called == 10);
@ -128,7 +126,7 @@ TEST_IMPL(timer) {
ASSERT(repeat_cb_called == 5);
ASSERT(repeat_close_cb_called == 1);
ASSERT(500 <= uv_now() - start_time);
ASSERT(500 <= uv_now(uv_default_loop()) - start_time);
return 0;
}

8
test/test-udp-dgram-too-big.c
View File

@ -50,7 +50,7 @@ static void send_cb(uv_udp_send_t* req, int status) {
CHECK_HANDLE(req->handle);
ASSERT(status == -1);
ASSERT(uv_last_error().code == UV_EMSGSIZE);
ASSERT(uv_last_error(uv_default_loop()).code == UV_EMSGSIZE);
uv_close((uv_handle_t*)req->handle, close_cb);
send_cb_called++;
@ -65,9 +65,7 @@ TEST_IMPL(udp_dgram_too_big) {
memset(dgram, 42, sizeof dgram); /* silence valgrind */
uv_init();
r = uv_udp_init(&handle_);
r = uv_udp_init(uv_default_loop(), &handle_);
ASSERT(r == 0);
buf = uv_buf_init(dgram, sizeof dgram);
@ -79,7 +77,7 @@ TEST_IMPL(udp_dgram_too_big) {
ASSERT(close_cb_called == 0);
ASSERT(send_cb_called == 0);
uv_run();
uv_run(uv_default_loop());
ASSERT(send_cb_called == 1);
ASSERT(close_cb_called == 1);

10
test/test-udp-ipv6.c
View File

@ -100,11 +100,9 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
uv_buf_t buf;
int r;
uv_init();
addr6 = uv_ip6_addr("::0", TEST_PORT);
r = uv_udp_init(&server);
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_udp_bind6(&server, addr6, bind_flags);
@ -113,7 +111,7 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
r = uv_udp_recv_start(&server, alloc_cb, recv_cb);
ASSERT(r == 0);
r = uv_udp_init(&client);
r = uv_udp_init(uv_default_loop(), &client);
ASSERT(r == 0);
buf = uv_buf_init("PING", 4);
@ -122,7 +120,7 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
r = uv_udp_send(&req_, &client, &buf, 1, addr, send_cb);
ASSERT(r == 0);
r = uv_timer_init(&timeout);
r = uv_timer_init(uv_default_loop(), &timeout);
ASSERT(r == 0);
r = uv_timer_start(&timeout, timeout_cb, 500, 0);
@ -132,7 +130,7 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
ASSERT(send_cb_called == 0);
ASSERT(recv_cb_called == 0);
uv_run();
uv_run(uv_default_loop());
ASSERT(close_cb_called == 3);
}

8
test/test-udp-send-and-recv.c
View File

@ -170,9 +170,7 @@ TEST_IMPL(udp_send_and_recv) {
addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
uv_init();
r = uv_udp_init(&server);
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_udp_bind(&server, addr, 0);
@ -183,7 +181,7 @@ TEST_IMPL(udp_send_and_recv) {
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
r = uv_udp_init(&client);
r = uv_udp_init(uv_default_loop(), &client);
ASSERT(r == 0);
/* client sends "PING", expects "PONG" */
@ -198,7 +196,7 @@ TEST_IMPL(udp_send_and_recv) {
ASSERT(sv_send_cb_called == 0);
ASSERT(sv_recv_cb_called == 0);
uv_run();
uv_run(uv_default_loop());
ASSERT(cl_send_cb_called == 1);
ASSERT(cl_recv_cb_called == 1);