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

update tests for multiplicity

Browse Source
This commit is contained in:
Bert Belder 2011-08-31 04:19:26 +02:00
parent 78debf9f67
commit 8e3a8602ad
5 changed files with 117 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
test/echo-server.c
View File

@ -29,6 +29,8 @@ typedef struct {
uv_buf_t buf;
} write_req_t;
static uv_loop_t* loop;
static int server_closed;
static stream_type serverType;
static uv_tcp_t tcpServer;
@ -46,7 +48,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_default_loop());
uv_err_t err = uv_last_error(loop);
fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
ASSERT(0);
}
@ -72,7 +74,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(uv_default_loop()).code == UV_EOF);
ASSERT (uv_last_error(loop).code == UV_EOF);
if (buf.base) {
free(buf.base);
@ -134,7 +136,7 @@ static void on_connection(uv_stream_t* server, int status) {
if (status != 0) {
fprintf(stderr, "Connect error %d\n",
uv_last_error(uv_default_loop()).code);
uv_last_error(loop).code);
}
ASSERT(status == 0);
@ -142,13 +144,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_default_loop(), (uv_tcp_t*)stream);
uv_tcp_init(loop, (uv_tcp_t*)stream);
break;
case PIPE:
stream = malloc(sizeof(uv_pipe_t));
ASSERT(stream != NULL);
uv_pipe_init(uv_default_loop(), (uv_pipe_t*)stream);
uv_pipe_init(loop, (uv_pipe_t*)stream);
break;
default:
@ -179,7 +181,7 @@ static int tcp4_echo_start(int port) {
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
r = uv_tcp_init(uv_default_loop(), &tcpServer);
r = uv_tcp_init(loop, &tcpServer);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Socket creation error\n");
@ -197,7 +199,7 @@ static int tcp4_echo_start(int port) {
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Listen error %s\n",
uv_err_name(uv_last_error(uv_default_loop())));
uv_err_name(uv_last_error(loop)));
return 1;
}
@ -212,7 +214,7 @@ static int tcp6_echo_start(int port) {
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
r = uv_tcp_init(uv_default_loop(), &tcpServer);
r = uv_tcp_init(loop, &tcpServer);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Socket creation error\n");
@ -244,24 +246,24 @@ static int pipe_echo_start(char* pipeName) {
server = (uv_handle_t*)&pipeServer;
serverType = PIPE;
r = uv_pipe_init(uv_default_loop(), &pipeServer);
r = uv_pipe_init(loop, &pipeServer);
if (r) {
fprintf(stderr, "uv_pipe_init: %s\n",
uv_strerror(uv_last_error(uv_default_loop())));
uv_strerror(uv_last_error(loop)));
return 1;
}
r = uv_pipe_bind(&pipeServer, pipeName);
if (r) {
fprintf(stderr, "uv_pipe_bind: %s\n",
uv_strerror(uv_last_error(uv_default_loop())));
uv_strerror(uv_last_error(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(uv_default_loop())));
uv_strerror(uv_last_error(loop)));
return 1;
}
@ -271,7 +273,7 @@ static int pipe_echo_start(char* pipeName) {
HELPER_IMPL(tcp4_echo_server) {
uv_init();
uv_loop_t* loop = uv_default_loop();
loop = uv_default_loop();
if (tcp4_echo_start(TEST_PORT))
return 1;
@ -283,7 +285,7 @@ HELPER_IMPL(tcp4_echo_server) {
HELPER_IMPL(tcp6_echo_server) {
uv_init();
uv_loop_t* loop = uv_default_loop();
loop = uv_default_loop();
if (tcp6_echo_start(TEST_PORT))
return 1;
@ -295,7 +297,7 @@ HELPER_IMPL(tcp6_echo_server) {
HELPER_IMPL(pipe_echo_server) {
uv_init();
uv_loop_t* loop = uv_default_loop();
loop = uv_default_loop();
if (pipe_echo_start(TEST_PIPENAME))
return 1;

143
test/test-fs.c
View File

@ -58,6 +58,8 @@ static int fdatasync_cb_count;
static int ftruncate_cb_count;
static int sendfile_cb_count;
static uv_loop_t* loop;
static uv_fs_t open_req1;
static uv_fs_t open_req2;
static uv_fs_t read_req;
@ -95,7 +97,7 @@ static void close_cb(uv_fs_t* req) {
close_cb_count++;
uv_fs_req_cleanup(req);
if (close_cb_count == 3) {
r = uv_fs_unlink(&unlink_req, "test_file2", unlink_cb);
r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb);
}
}
@ -107,7 +109,7 @@ static void ftruncate_cb(uv_fs_t* req) {
ASSERT(req->result != -1);
ftruncate_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_close(&close_req, open_req1.result, close_cb);
r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
}
@ -120,10 +122,11 @@ static void read_cb(uv_fs_t* req) {
uv_fs_req_cleanup(req);
if (read_cb_count == 1) {
ASSERT(strcmp(buf, test_buf) == 0);
r = uv_fs_ftruncate(&ftruncate_req, open_req1.result, 7, ftruncate_cb);
r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7,
ftruncate_cb);
} else {
ASSERT(strcmp(buf, "test-bu") == 0);
r = uv_fs_close(&close_req, open_req1.result, close_cb);
r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
}
}
@ -132,7 +135,7 @@ static void open_cb(uv_fs_t* req) {
int r;
ASSERT(req == &open_req1);
ASSERT(req->fs_type == UV_FS_OPEN);
if (req->result < 0) {
if (req->result < 0) {
/* TODO get error with uv_last_error() */
fprintf(stderr, "async open error: %d\n", req->errorno);
ASSERT(0);
@ -140,7 +143,8 @@ static void open_cb(uv_fs_t* req) {
open_cb_count++;
uv_fs_req_cleanup(req);
memset(buf, 0, sizeof(buf));
r = uv_fs_read(&read_req, open_req1.result, buf, sizeof(buf), -1, read_cb);
r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
read_cb);
}
@ -151,7 +155,7 @@ static void fsync_cb(uv_fs_t* req) {
ASSERT(req->result != -1);
fsync_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_close(&close_req, open_req1.result, close_cb);
r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
}
@ -162,7 +166,7 @@ static void fdatasync_cb(uv_fs_t* req) {
ASSERT(req->result != -1);
fdatasync_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_fsync(&fsync_req, open_req1.result, fsync_cb);
r = uv_fs_fsync(loop, &fsync_req, open_req1.result, fsync_cb);
}
@ -173,7 +177,7 @@ static void write_cb(uv_fs_t* req) {
ASSERT(req->result != -1);
write_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_fdatasync(&fdatasync_req, open_req1.result, fdatasync_cb);
r = uv_fs_fdatasync(loop, &fdatasync_req, open_req1.result, fdatasync_cb);
}
@ -184,8 +188,8 @@ static void create_cb(uv_fs_t* req) {
ASSERT(req->result != -1);
create_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_write(&write_req, req->result, test_buf, sizeof(test_buf), -1,
write_cb);
r = uv_fs_write(loop, &write_req, req->result, test_buf, sizeof(test_buf),
-1, write_cb);
}
@ -222,7 +226,8 @@ static void readdir_cb(uv_fs_t* req) {
ASSERT(req->result == 2);
ASSERT(req->ptr);
ASSERT(strcmp((const char*)req->ptr, "file1") == 0);
ASSERT(strcmp((char*)req->ptr + strlen((const char*)req->ptr) + 1, "file2") == 0);
ASSERT(strcmp((char*)req->ptr + strlen((const char*)req->ptr) + 1,
"file2") == 0);
readdir_cb_count++;
uv_fs_req_cleanup(req);
ASSERT(!req->ptr);
@ -257,11 +262,12 @@ TEST_IMPL(fs_file_async) {
unlink("test_file2");
uv_init();
loop = uv_default_loop();
r = uv_fs_open(&open_req1, "test_file", O_WRONLY | O_CREAT,
r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,
S_IREAD | S_IWRITE, create_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(create_cb_count == 1);
ASSERT(write_cb_count == 1);
@ -269,19 +275,19 @@ TEST_IMPL(fs_file_async) {
ASSERT(fdatasync_cb_count == 1);
ASSERT(close_cb_count == 1);
r = uv_fs_rename(&rename_req, "test_file", "test_file2", rename_cb);
r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", rename_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(create_cb_count == 1);
ASSERT(write_cb_count == 1);
ASSERT(close_cb_count == 1);
ASSERT(rename_cb_count == 1);
r = uv_fs_open(&open_req1, "test_file2", O_RDWR, 0, open_cb);
r = uv_fs_open(loop, &open_req1, "test_file2", O_RDWR, 0, open_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(open_cb_count == 1);
ASSERT(read_cb_count == 1);
ASSERT(close_cb_count == 2);
@ -290,10 +296,10 @@ TEST_IMPL(fs_file_async) {
ASSERT(write_cb_count == 1);
ASSERT(ftruncate_cb_count == 1);
r = uv_fs_open(&open_req1, "test_file2", O_RDONLY, 0, open_cb);
r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, open_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(open_cb_count == 2);
ASSERT(read_cb_count == 2);
ASSERT(close_cb_count == 3);
@ -319,68 +325,71 @@ TEST_IMPL(fs_file_sync) {
unlink("test_file2");
uv_init();
r = uv_fs_open(&open_req1, "test_file", O_WRONLY | O_CREAT,
loop = uv_default_loop();
r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);
r = uv_fs_write(&write_req, open_req1.result, test_buf, sizeof(test_buf), -1,
NULL);
r = uv_fs_write(loop, &write_req, open_req1.result, test_buf,
sizeof(test_buf), -1, NULL);
ASSERT(r == 0);
ASSERT(write_req.result != -1);
uv_fs_req_cleanup(&write_req);
r = uv_fs_close(&close_req, open_req1.result, NULL);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result != -1);
uv_fs_req_cleanup(&close_req);
r = uv_fs_open(&open_req1, "test_file", O_RDWR, 0, NULL);
r = uv_fs_open(loop, &open_req1, "test_file", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);
r = uv_fs_read(&read_req, open_req1.result, buf, sizeof(buf), -1, NULL);
r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
NULL);
ASSERT(r == 0);
ASSERT(read_req.result != -1);
ASSERT(strcmp(buf, test_buf) == 0);
uv_fs_req_cleanup(&read_req);
r = uv_fs_ftruncate(&ftruncate_req, open_req1.result, 7, NULL);
r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7, NULL);
ASSERT(r == 0);
ASSERT(ftruncate_req.result != -1);
uv_fs_req_cleanup(&ftruncate_req);
r = uv_fs_close(&close_req, open_req1.result, NULL);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result != -1);
uv_fs_req_cleanup(&close_req);
r = uv_fs_rename(&rename_req, "test_file", "test_file2", NULL);
r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", NULL);
ASSERT(r == 0);
ASSERT(rename_req.result != -1);
uv_fs_req_cleanup(&rename_req);
r = uv_fs_open(&open_req1, "test_file2", O_RDONLY, 0, NULL);
r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, NULL);
ASSERT(r == 0);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);
memset(buf, 0, sizeof(buf));
r = uv_fs_read(&read_req, open_req1.result, buf, sizeof(buf), -1, NULL);
r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
NULL);
ASSERT(r == 0);
ASSERT(read_req.result != -1);
ASSERT(strcmp(buf, "test-bu") == 0);
uv_fs_req_cleanup(&read_req);
r = uv_fs_close(&close_req, open_req1.result, NULL);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
ASSERT(close_req.result != -1);
uv_fs_req_cleanup(&close_req);
r = uv_fs_unlink(&unlink_req, "test_file2", NULL);
r = uv_fs_unlink(loop, &unlink_req, "test_file2", NULL);
ASSERT(r == 0);
ASSERT(unlink_req.result != -1);
uv_fs_req_cleanup(&unlink_req);
@ -402,67 +411,68 @@ TEST_IMPL(fs_async_dir) {
rmdir("test_dir");
uv_init();
loop = uv_default_loop();
r = uv_fs_mkdir(&mkdir_req, "test_dir", 0755, mkdir_cb);
r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(mkdir_cb_count == 1);
/* Create 2 files synchronously. */
r = uv_fs_open(&open_req1, "test_dir/file1", O_WRONLY | O_CREAT,
r = uv_fs_open(loop, &open_req1, "test_dir/file1", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&open_req1);
r = uv_fs_close(&close_req, open_req1.result, NULL);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);
r = uv_fs_open(&open_req1, "test_dir/file2", O_WRONLY | O_CREAT,
r = uv_fs_open(loop, &open_req1, "test_dir/file2", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&open_req1);
r = uv_fs_close(&close_req, open_req1.result, NULL);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);
r = uv_fs_readdir(&readdir_req, "test_dir", 0, readdir_cb);
r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, readdir_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(readdir_cb_count == 1);
r = uv_fs_stat(&stat_req, "test_dir", stat_cb);
r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
r = uv_fs_stat(&stat_req, "test_dir\\", stat_cb);
r = uv_fs_stat(loop, &stat_req, "test_dir\\", stat_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
r = uv_fs_lstat(&stat_req, "test_dir", stat_cb);
r = uv_fs_lstat(loop, &stat_req, "test_dir", stat_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
r = uv_fs_lstat(&stat_req, "test_dir\\", stat_cb);
r = uv_fs_lstat(loop, &stat_req, "test_dir\\", stat_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(stat_cb_count == 4);
r = uv_fs_unlink(&unlink_req, "test_dir/file1", unlink_cb);
r = uv_fs_unlink(loop, &unlink_req, "test_dir/file1", unlink_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(unlink_cb_count == 1);
r = uv_fs_unlink(&unlink_req, "test_dir/file2", unlink_cb);
r = uv_fs_unlink(loop, &unlink_req, "test_dir/file2", unlink_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(unlink_cb_count == 2);
r = uv_fs_rmdir(&rmdir_req, "test_dir", rmdir_cb);
r = uv_fs_rmdir(loop, &rmdir_req, "test_dir", rmdir_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(rmdir_cb_count == 1);
/* Cleanup */
@ -485,7 +495,7 @@ TEST_IMPL(fs_async_sendfile) {
f = open("test_file", O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
ASSERT(f != -1);
r = write(f, "begin\n", 6);
ASSERT(r == 6);
@ -500,29 +510,30 @@ TEST_IMPL(fs_async_sendfile) {
/* Test starts here. */
uv_init();
loop = uv_default_loop();
r = uv_fs_open(&open_req1, "test_file", O_RDWR, 0, NULL);
r = uv_fs_open(loop, &open_req1, "test_file", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);
r = uv_fs_open(&open_req2, "test_file2", O_WRONLY | O_CREAT,
r = uv_fs_open(loop, &open_req2, "test_file2", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(open_req2.result != -1);
uv_fs_req_cleanup(&open_req2);
r = uv_fs_sendfile(&sendfile_req, open_req2.result, open_req1.result, 0,
131072, sendfile_cb);
r = uv_fs_sendfile(loop, &sendfile_req, open_req2.result, open_req1.result,
0, 131072, sendfile_cb);
ASSERT(r == 0);
uv_run();
uv_run(loop);
ASSERT(sendfile_cb_count == 1);
r = uv_fs_close(&close_req, open_req1.result, NULL);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);
r = uv_fs_close(&close_req, open_req2.result, NULL);
r = uv_fs_close(loop, &close_req, open_req2.result, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);

33
test/test-getsockname.c
View File

@ -29,6 +29,7 @@
static int getsocknamecount = 0;
static uv_loop_t* loop;
static uv_tcp_t tcp;
static uv_udp_t udp;
static uv_connect_t connect_req;
@ -79,14 +80,14 @@ static void on_connection(uv_stream_t* server, int status) {
if (status != 0) {
fprintf(stderr, "Connect error %d\n",
uv_last_error(uv_default_loop()).code);
uv_last_error(loop).code);
}
ASSERT(status == 0);
handle = (uv_handle_t*) malloc(sizeof(uv_tcp_t));
ASSERT(handle != NULL);
uv_tcp_init(uv_default_loop(), (uv_tcp_t*)handle);
uv_tcp_init(loop, (uv_tcp_t*)handle);
/* associate server with stream */
handle->data = server;
@ -97,7 +98,7 @@ 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(uv_default_loop()).code);
uv_last_error(loop).code);
}
ASSERT(status == 0);
@ -118,7 +119,7 @@ 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(uv_default_loop()).code);
uv_last_error(loop).code);
}
ASSERT(r == 0);
@ -135,7 +136,7 @@ static int tcp_listener(int port) {
char ip[20];
int r;
r = uv_tcp_init(uv_default_loop(), &tcpServer);
r = uv_tcp_init(loop, &tcpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
@ -158,7 +159,7 @@ 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(uv_default_loop()).code);
uv_last_error(loop).code);
}
ASSERT(r == 0);
@ -179,7 +180,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(uv_default_loop(), &tcp);
r = uv_tcp_init(loop, &tcp);
tcp.data = &connect_req;
ASSERT(!r);
@ -201,7 +202,6 @@ static void udp_recv(uv_udp_t* handle,
ASSERT(nread >= 0);
if (nread == 0) {
uv_close((uv_handle_t*)handle, NULL);
free(buf.base);
return;
}
@ -209,7 +209,7 @@ static void udp_recv(uv_udp_t* handle,
namelen = sizeof(sockname);
r = uv_getsockname((uv_handle_t*)&udp, &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(loop).code);
}
ASSERT(r == 0);
@ -219,7 +219,8 @@ static void udp_recv(uv_udp_t* handle,
getsocknamecount++;
uv_close((uv_handle_t*)&udp, NULL);
uv_close((uv_handle_t*) &udp, NULL);
uv_close((uv_handle_t*) handle, NULL);
}
@ -235,7 +236,7 @@ static int udp_listener(int port) {
char ip[20];
int r;
r = uv_udp_init(&udpServer);
r = uv_udp_init(loop, &udpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
@ -251,7 +252,7 @@ static int udp_listener(int port) {
r = uv_getsockname((uv_handle_t*)&udpServer, &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(loop).code);
}
ASSERT(r == 0);
@ -276,7 +277,7 @@ static void udp_sender(void) {
uv_buf_t buf;
int r;
r = uv_udp_init(&udp);
r = uv_udp_init(loop, &udp);
ASSERT(!r);
buf = uv_buf_init("PING", 4);
@ -289,13 +290,14 @@ static void udp_sender(void) {
TEST_IMPL(getsockname_tcp) {
uv_init();
loop = uv_default_loop();
if (tcp_listener(TEST_PORT))
return 1;
tcp_connector();
uv_run(uv_default_loop());
uv_run(loop);
ASSERT(getsocknamecount == 3);
@ -305,13 +307,14 @@ TEST_IMPL(getsockname_tcp) {
TEST_IMPL(getsockname_udp) {
uv_init();
loop = uv_default_loop();
if (udp_listener(TEST_PORT))
return 1;
udp_sender();
uv_run();
uv_run(loop);
ASSERT(getsocknamecount == 2);

6
test/test-spawn.c
View File

@ -238,7 +238,7 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) {
init_process_options("spawn_helper2", exit_cb);
uv_pipe_init(&out);
uv_pipe_init(uv_default_loop(), &out);
options.stdout_stream = &out;
/* Create a pipe that'll cause a collision. */
@ -253,13 +253,13 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) {
NULL);
ASSERT(pipe_handle != INVALID_HANDLE_VALUE);
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);

4
test/test-threadpool.c
View File

@ -48,9 +48,9 @@ TEST_IMPL(threadpool_queue_work_simple) {
uv_init();
work_req.data = &data;
r = uv_queue_work(&work_req, work_cb, after_work_cb);
r = uv_queue_work(uv_default_loop(), &work_req, work_cb, after_work_cb);
ASSERT(r == 0);
uv_run();
uv_run(uv_default_loop());
ASSERT(work_cb_count == 1);
ASSERT(after_work_cb_count == 1);