std: dump old std::uv API.. move remaining tests into uv::ll
This commit is contained in:
Jeff Olson
Brian Anderson
parent
791ea3466d
commit
a1c43cc7c9
2 changed files with 610 additions and 1240 deletions
1238
src/libstd/uv.rs
1238
src/libstd/uv.rs
File diff suppressed because it is too large
Load diff
|
|
@ -581,6 +581,16 @@ native mod rustrt {
|
|||
data: *libc::c_void);
|
||||
fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8;
|
||||
fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> libc::size_t;
|
||||
|
||||
// sizeof testing helpers
|
||||
fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint;
|
||||
fn rust_uv_helper_uv_connect_t_size() -> libc::c_uint;
|
||||
fn rust_uv_helper_uv_buf_t_size() -> libc::c_uint;
|
||||
fn rust_uv_helper_uv_write_t_size() -> libc::c_uint;
|
||||
fn rust_uv_helper_uv_err_t_size() -> libc::c_uint;
|
||||
fn rust_uv_helper_sockaddr_in_size() -> libc::c_uint;
|
||||
fn rust_uv_helper_uv_async_t_size() -> libc::c_uint;
|
||||
fn rust_uv_helper_uv_timer_t_size() -> libc::c_uint;
|
||||
}
|
||||
|
||||
unsafe fn loop_new() -> *libc::c_void {
|
||||
|
|
@ -673,7 +683,7 @@ unsafe fn async_send(async_handle: *uv_async_t) {
|
|||
unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
|
||||
let out_buf = { base: ptr::null(), len: 0 as libc::size_t };
|
||||
let out_buf_ptr = ptr::addr_of(out_buf);
|
||||
log(debug, #fmt("ll::buf_init - input %u len %u out_buf: %u",
|
||||
log(debug, #fmt("buf_init - input %u len %u out_buf: %u",
|
||||
input as uint,
|
||||
len as uint,
|
||||
out_buf_ptr as uint));
|
||||
|
|
@ -684,7 +694,7 @@ unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
|
|||
let res_base = get_base_from_buf(out_buf);
|
||||
let res_len = get_len_from_buf(out_buf);
|
||||
//let res_base = get_base_from_buf(result);
|
||||
log(debug, #fmt("ll::buf_init - result %u len %u",
|
||||
log(debug, #fmt("buf_init - result %u len %u",
|
||||
res_base as uint,
|
||||
res_len as uint));
|
||||
ret out_buf;
|
||||
|
|
@ -790,4 +800,602 @@ unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> str {
|
|||
let err_msg = str::unsafe::from_c_str(strerror(err_ptr));
|
||||
ret #fmt("LIBUV ERROR: name: %s msg: %s",
|
||||
err_name, err_msg);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
enum tcp_read_data {
|
||||
tcp_read_eof,
|
||||
tcp_read_more([u8]),
|
||||
tcp_read_error
|
||||
}
|
||||
|
||||
type request_wrapper = {
|
||||
write_req: *uv_write_t,
|
||||
req_buf: *[uv_buf_t],
|
||||
read_chan: *comm::chan<str>
|
||||
};
|
||||
|
||||
crust fn after_close_cb(handle: *libc::c_void) {
|
||||
log(debug, #fmt("after uv_close! handle ptr: %?",
|
||||
handle));
|
||||
}
|
||||
|
||||
crust fn on_alloc_cb(handle: *libc::c_void,
|
||||
++suggested_size: libc::size_t)
|
||||
-> uv_buf_t unsafe {
|
||||
log(debug, "on_alloc_cb!");
|
||||
let char_ptr = malloc_buf_base_of(suggested_size);
|
||||
log(debug, #fmt("on_alloc_cb h: %? char_ptr: %u sugsize: %u",
|
||||
handle,
|
||||
char_ptr as uint,
|
||||
suggested_size as uint));
|
||||
ret buf_init(char_ptr, suggested_size);
|
||||
}
|
||||
|
||||
crust fn on_read_cb(stream: *uv_stream_t,
|
||||
nread: libc::ssize_t,
|
||||
++buf: uv_buf_t) unsafe {
|
||||
log(debug, #fmt("CLIENT entering on_read_cb nred: %d", nread));
|
||||
if (nread > 0) {
|
||||
// we have data
|
||||
log(debug, #fmt("CLIENT read: data! nread: %d", nread));
|
||||
read_stop(stream);
|
||||
let client_data =
|
||||
get_data_for_uv_handle(stream as *libc::c_void)
|
||||
as *request_wrapper;
|
||||
let buf_base = get_base_from_buf(buf);
|
||||
let buf_len = get_len_from_buf(buf);
|
||||
let bytes = vec::unsafe::from_buf(buf_base, buf_len);
|
||||
let read_chan = *((*client_data).read_chan);
|
||||
let msg_from_server = str::from_bytes(bytes);
|
||||
comm::send(read_chan, msg_from_server);
|
||||
close(stream as *libc::c_void, after_close_cb)
|
||||
}
|
||||
else if (nread == -1) {
|
||||
// err .. possibly EOF
|
||||
log(debug, "read: eof!");
|
||||
}
|
||||
else {
|
||||
// nread == 0 .. do nothing, just free buf as below
|
||||
log(debug, "read: do nothing!");
|
||||
}
|
||||
// when we're done
|
||||
free_base_of_buf(buf);
|
||||
log(debug, "CLIENT exiting on_read_cb");
|
||||
}
|
||||
|
||||
crust fn on_write_complete_cb(write_req: *uv_write_t,
|
||||
status: libc::c_int) unsafe {
|
||||
log(debug, #fmt("CLIENT beginning on_write_complete_cb status: %d",
|
||||
status as int));
|
||||
let stream = get_stream_handle_from_write_req(write_req);
|
||||
log(debug, #fmt("CLIENT on_write_complete_cb: tcp:%d write_handle:%d",
|
||||
stream as int, write_req as int));
|
||||
let result = read_start(stream, on_alloc_cb, on_read_cb);
|
||||
log(debug, #fmt("CLIENT ending on_write_complete_cb .. status: %d",
|
||||
result as int));
|
||||
}
|
||||
|
||||
crust fn on_connect_cb(connect_req_ptr: *uv_connect_t,
|
||||
status: libc::c_int) unsafe {
|
||||
log(debug, #fmt("beginning on_connect_cb .. status: %d",
|
||||
status as int));
|
||||
let stream =
|
||||
get_stream_handle_from_connect_req(connect_req_ptr);
|
||||
if (status == 0i32) {
|
||||
log(debug, "on_connect_cb: in status=0 if..");
|
||||
let client_data = get_data_for_req(
|
||||
connect_req_ptr as *libc::c_void)
|
||||
as *request_wrapper;
|
||||
let write_handle = (*client_data).write_req as *libc::c_void;
|
||||
log(debug, #fmt("on_connect_cb: tcp: %d write_hdl: %d",
|
||||
stream as int, write_handle as int));
|
||||
let write_result = write(write_handle,
|
||||
stream as *libc::c_void,
|
||||
(*client_data).req_buf,
|
||||
on_write_complete_cb);
|
||||
log(debug, #fmt("on_connect_cb: write() status: %d",
|
||||
write_result as int));
|
||||
}
|
||||
else {
|
||||
let test_loop = get_loop_for_uv_handle(
|
||||
stream as *libc::c_void);
|
||||
let err_msg = get_last_err_info(test_loop);
|
||||
log(debug, err_msg);
|
||||
assert false;
|
||||
}
|
||||
log(debug, "finishing on_connect_cb");
|
||||
}
|
||||
|
||||
fn impl_uv_tcp_request(ip: str, port: int, req_str: str,
|
||||
client_chan: *comm::chan<str>) unsafe {
|
||||
let test_loop = loop_new();
|
||||
let tcp_handle = tcp_t();
|
||||
let tcp_handle_ptr = ptr::addr_of(tcp_handle);
|
||||
let connect_handle = connect_t();
|
||||
let connect_req_ptr = ptr::addr_of(connect_handle);
|
||||
|
||||
// this is the persistent payload of data that we
|
||||
// need to pass around to get this example to work.
|
||||
// In C, this would be a malloc'd or stack-allocated
|
||||
// struct that we'd cast to a void* and store as the
|
||||
// data field in our uv_connect_t struct
|
||||
let req_str_bytes = str::bytes(req_str);
|
||||
let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes);
|
||||
log(debug, #fmt("req_msg ptr: %u", req_msg_ptr as uint));
|
||||
let req_msg = [
|
||||
buf_init(req_msg_ptr, vec::len(req_str_bytes))
|
||||
];
|
||||
// this is the enclosing record, we'll pass a ptr to
|
||||
// this to C..
|
||||
let write_handle = write_t();
|
||||
let write_handle_ptr = ptr::addr_of(write_handle);
|
||||
log(debug, #fmt("tcp req: tcp stream: %d write_handle: %d",
|
||||
tcp_handle_ptr as int,
|
||||
write_handle_ptr as int));
|
||||
let client_data = { writer_handle: write_handle_ptr,
|
||||
req_buf: ptr::addr_of(req_msg),
|
||||
read_chan: client_chan };
|
||||
|
||||
let tcp_init_result = tcp_init(
|
||||
test_loop as *libc::c_void, tcp_handle_ptr);
|
||||
if (tcp_init_result == 0i32) {
|
||||
log(debug, "sucessful tcp_init_result");
|
||||
|
||||
log(debug, "building addr...");
|
||||
let addr = ip4_addr(ip, port);
|
||||
// FIXME ref #2064
|
||||
let addr_ptr = ptr::addr_of(addr);
|
||||
log(debug, #fmt("after build addr in rust. port: %u",
|
||||
addr.sin_port as uint));
|
||||
|
||||
// this should set up the connection request..
|
||||
log(debug, #fmt("b4 call tcp_connect connect cb: %u ",
|
||||
on_connect_cb as uint));
|
||||
let tcp_connect_result = tcp_connect(
|
||||
connect_req_ptr, tcp_handle_ptr,
|
||||
addr_ptr, on_connect_cb);
|
||||
if (tcp_connect_result == 0i32) {
|
||||
// not set the data on the connect_req
|
||||
// until its initialized
|
||||
set_data_for_req(
|
||||
connect_req_ptr as *libc::c_void,
|
||||
ptr::addr_of(client_data) as *libc::c_void);
|
||||
set_data_for_uv_handle(
|
||||
tcp_handle_ptr as *libc::c_void,
|
||||
ptr::addr_of(client_data) as *libc::c_void);
|
||||
log(debug, "before run tcp req loop");
|
||||
run(test_loop);
|
||||
log(debug, "after run tcp req loop");
|
||||
}
|
||||
else {
|
||||
log(debug, "tcp_connect() failure");
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
log(debug, "tcp_init() failure");
|
||||
assert false;
|
||||
}
|
||||
loop_delete(test_loop);
|
||||
|
||||
}
|
||||
|
||||
crust fn server_after_close_cb(handle: *libc::c_void) unsafe {
|
||||
log(debug, #fmt("SERVER server stream closed, should exit.. h: %?",
|
||||
handle));
|
||||
}
|
||||
|
||||
crust fn client_stream_after_close_cb(handle: *libc::c_void)
|
||||
unsafe {
|
||||
log(debug, "SERVER: closed client stream, now closing server stream");
|
||||
let client_data = get_data_for_uv_handle(
|
||||
handle) as
|
||||
*tcp_server_data;
|
||||
close((*client_data).server as *libc::c_void,
|
||||
server_after_close_cb);
|
||||
}
|
||||
|
||||
crust fn after_server_resp_write(req: *uv_write_t) unsafe {
|
||||
let client_stream_ptr =
|
||||
get_stream_handle_from_write_req(req);
|
||||
log(debug, "SERVER: resp sent... closing client stream");
|
||||
close(client_stream_ptr as *libc::c_void,
|
||||
client_stream_after_close_cb)
|
||||
}
|
||||
|
||||
crust fn on_server_read_cb(client_stream_ptr: *uv_stream_t,
|
||||
nread: libc::ssize_t,
|
||||
++buf: uv_buf_t) unsafe {
|
||||
if (nread > 0) {
|
||||
// we have data
|
||||
log(debug, #fmt("SERVER read: data! nread: %d", nread));
|
||||
|
||||
// pull out the contents of the write from the client
|
||||
let buf_base = get_base_from_buf(buf);
|
||||
let buf_len = get_len_from_buf(buf);
|
||||
log(debug, #fmt("SERVER buf base: %u, len: %u, nread: %d",
|
||||
buf_base as uint,
|
||||
buf_len as uint,
|
||||
nread));
|
||||
let bytes = vec::unsafe::from_buf(buf_base, buf_len);
|
||||
let request_str = str::from_bytes(bytes);
|
||||
|
||||
let client_data = get_data_for_uv_handle(
|
||||
client_stream_ptr as *libc::c_void) as *tcp_server_data;
|
||||
|
||||
let server_kill_msg = (*client_data).server_kill_msg;
|
||||
let write_req = (*client_data).server_write_req;
|
||||
if (str::contains(request_str, server_kill_msg)) {
|
||||
log(debug, "SERVER: client req contains kill_msg!");
|
||||
log(debug, "SERVER: sending response to client");
|
||||
read_stop(client_stream_ptr);
|
||||
let server_chan = *((*client_data).server_chan);
|
||||
comm::send(server_chan, request_str);
|
||||
let write_result = write(
|
||||
write_req as *libc::c_void,
|
||||
client_stream_ptr as *libc::c_void,
|
||||
(*client_data).server_resp_buf,
|
||||
after_server_resp_write);
|
||||
log(debug, #fmt("SERVER: resp write result: %d",
|
||||
write_result as int));
|
||||
if (write_result != 0i32) {
|
||||
log(debug, "bad result for server resp write()");
|
||||
log(debug, get_last_err_info(
|
||||
get_loop_for_uv_handle(client_stream_ptr
|
||||
as *libc::c_void)));
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
log(debug, "SERVER: client req !contain kill_msg!");
|
||||
}
|
||||
}
|
||||
else if (nread == -1) {
|
||||
// err .. possibly EOF
|
||||
log(debug, "read: eof!");
|
||||
}
|
||||
else {
|
||||
// nread == 0 .. do nothing, just free buf as below
|
||||
log(debug, "read: do nothing!");
|
||||
}
|
||||
// when we're done
|
||||
free_base_of_buf(buf);
|
||||
log(debug, "SERVER exiting on_read_cb");
|
||||
}
|
||||
|
||||
crust fn server_connection_cb(server_stream_ptr:
|
||||
*uv_stream_t,
|
||||
status: libc::c_int) unsafe {
|
||||
log(debug, "client connecting!");
|
||||
let test_loop = get_loop_for_uv_handle(
|
||||
server_stream_ptr as *libc::c_void);
|
||||
if status != 0i32 {
|
||||
let err_msg = get_last_err_info(test_loop);
|
||||
log(debug, #fmt("server_connect_cb: non-zero status: %?",
|
||||
err_msg));
|
||||
ret;
|
||||
}
|
||||
let server_data = get_data_for_uv_handle(
|
||||
server_stream_ptr as *libc::c_void) as *tcp_server_data;
|
||||
let client_stream_ptr = (*server_data).client;
|
||||
let client_init_result = tcp_init(test_loop,
|
||||
client_stream_ptr);
|
||||
set_data_for_uv_handle(
|
||||
client_stream_ptr as *libc::c_void,
|
||||
server_data as *libc::c_void);
|
||||
if (client_init_result == 0i32) {
|
||||
log(debug, "successfully initialized client stream");
|
||||
let accept_result = accept(server_stream_ptr as
|
||||
*libc::c_void,
|
||||
client_stream_ptr as
|
||||
*libc::c_void);
|
||||
if (accept_result == 0i32) {
|
||||
// start reading
|
||||
let read_result = read_start(
|
||||
client_stream_ptr as *uv_stream_t,
|
||||
on_alloc_cb,
|
||||
on_server_read_cb);
|
||||
if (read_result == 0i32) {
|
||||
log(debug, "successful server read start");
|
||||
}
|
||||
else {
|
||||
log(debug, #fmt("server_connection_cb: bad read:%d",
|
||||
read_result as int));
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
log(debug, #fmt("server_connection_cb: bad accept: %d",
|
||||
accept_result as int));
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
log(debug, #fmt("server_connection_cb: bad client init: %d",
|
||||
client_init_result as int));
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
|
||||
type tcp_server_data = {
|
||||
client: *uv_tcp_t,
|
||||
server: *uv_tcp_t,
|
||||
server_kill_msg: str,
|
||||
server_resp_buf: *[uv_buf_t],
|
||||
server_chan: *comm::chan<str>,
|
||||
server_write_req: *uv_write_t
|
||||
};
|
||||
|
||||
type async_handle_data = {
|
||||
continue_chan: *comm::chan<bool>
|
||||
};
|
||||
|
||||
crust fn async_close_cb(handle: *libc::c_void) {
|
||||
log(debug, #fmt("SERVER: closing async cb... h: %?",
|
||||
handle));
|
||||
}
|
||||
|
||||
crust fn continue_async_cb(async_handle: *uv_async_t,
|
||||
status: libc::c_int) unsafe {
|
||||
// once we're in the body of this callback,
|
||||
// the tcp server's loop is set up, so we
|
||||
// can continue on to let the tcp client
|
||||
// do its thang
|
||||
let data = get_data_for_uv_handle(
|
||||
async_handle as *libc::c_void) as *async_handle_data;
|
||||
let continue_chan = *((*data).continue_chan);
|
||||
let should_continue = status == 0i32;
|
||||
comm::send(continue_chan, should_continue);
|
||||
close(async_handle as *libc::c_void, async_close_cb);
|
||||
}
|
||||
|
||||
fn impl_uv_tcp_server(server_ip: str,
|
||||
server_port: int,
|
||||
kill_server_msg: str,
|
||||
server_resp_msg: str,
|
||||
server_chan: *comm::chan<str>,
|
||||
continue_chan: *comm::chan<bool>) unsafe {
|
||||
let test_loop = loop_new();
|
||||
let tcp_server = tcp_t();
|
||||
let tcp_server_ptr = ptr::addr_of(tcp_server);
|
||||
|
||||
let tcp_client = tcp_t();
|
||||
let tcp_client_ptr = ptr::addr_of(tcp_client);
|
||||
|
||||
let server_write_req = write_t();
|
||||
let server_write_req_ptr = ptr::addr_of(server_write_req);
|
||||
|
||||
let resp_str_bytes = str::bytes(server_resp_msg);
|
||||
let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes);
|
||||
log(debug, #fmt("resp_msg ptr: %u", resp_msg_ptr as uint));
|
||||
let resp_msg = [
|
||||
buf_init(resp_msg_ptr, vec::len(resp_str_bytes))
|
||||
];
|
||||
|
||||
let continue_async_handle = async_t();
|
||||
let continue_async_handle_ptr =
|
||||
ptr::addr_of(continue_async_handle);
|
||||
let async_data =
|
||||
{ continue_chan: continue_chan };
|
||||
let async_data_ptr = ptr::addr_of(async_data);
|
||||
|
||||
let server_data: tcp_server_data = {
|
||||
client: tcp_client_ptr,
|
||||
server: tcp_server_ptr,
|
||||
server_kill_msg: kill_server_msg,
|
||||
server_resp_buf: ptr::addr_of(resp_msg),
|
||||
server_chan: server_chan,
|
||||
server_write_req: server_write_req_ptr
|
||||
};
|
||||
let server_data_ptr = ptr::addr_of(server_data);
|
||||
set_data_for_uv_handle(tcp_server_ptr as *libc::c_void,
|
||||
server_data_ptr as *libc::c_void);
|
||||
|
||||
// uv_tcp_init()
|
||||
let tcp_init_result = tcp_init(
|
||||
test_loop as *libc::c_void, tcp_server_ptr);
|
||||
if (tcp_init_result == 0i32) {
|
||||
let server_addr = ip4_addr(server_ip, server_port);
|
||||
// FIXME ref #2064
|
||||
let server_addr_ptr = ptr::addr_of(server_addr);
|
||||
|
||||
// uv_tcp_bind()
|
||||
let bind_result = tcp_bind(tcp_server_ptr,
|
||||
server_addr_ptr);
|
||||
if (bind_result == 0i32) {
|
||||
log(debug, "successful uv_tcp_bind, listening");
|
||||
|
||||
// uv_listen()
|
||||
let listen_result = listen(tcp_server_ptr as
|
||||
*libc::c_void,
|
||||
128i32,
|
||||
server_connection_cb);
|
||||
if (listen_result == 0i32) {
|
||||
// let the test know it can set up the tcp server,
|
||||
// now.. this may still present a race, not sure..
|
||||
let async_result = async_init(test_loop,
|
||||
continue_async_handle_ptr,
|
||||
continue_async_cb);
|
||||
if (async_result == 0i32) {
|
||||
set_data_for_uv_handle(
|
||||
continue_async_handle_ptr as *libc::c_void,
|
||||
async_data_ptr as *libc::c_void);
|
||||
async_send(continue_async_handle_ptr);
|
||||
// uv_run()
|
||||
run(test_loop);
|
||||
log(debug, "server uv::run() has returned");
|
||||
}
|
||||
else {
|
||||
log(debug, #fmt("uv_async_init failure: %d",
|
||||
async_result as int));
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
log(debug, #fmt("non-zero result on uv_listen: %d",
|
||||
listen_result as int));
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
log(debug, #fmt("non-zero result on uv_tcp_bind: %d",
|
||||
bind_result as int));
|
||||
assert false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
log(debug, #fmt("non-zero result on uv_tcp_init: %d",
|
||||
tcp_init_result as int));
|
||||
assert false;
|
||||
}
|
||||
loop_delete(test_loop);
|
||||
}
|
||||
|
||||
// this is the impl for a test that is (maybe) ran on a
|
||||
// per-platform/arch basis below
|
||||
fn impl_uv_tcp_server_and_request() unsafe {
|
||||
let bind_ip = "0.0.0.0";
|
||||
let request_ip = "127.0.0.1";
|
||||
let port = 8888;
|
||||
let kill_server_msg = "does a dog have buddha nature?";
|
||||
let server_resp_msg = "mu!";
|
||||
let client_port = comm::port::<str>();
|
||||
let client_chan = comm::chan::<str>(client_port);
|
||||
let server_port = comm::port::<str>();
|
||||
let server_chan = comm::chan::<str>(server_port);
|
||||
|
||||
let continue_port = comm::port::<bool>();
|
||||
let continue_chan = comm::chan::<bool>(continue_port);
|
||||
let continue_chan_ptr = ptr::addr_of(continue_chan);
|
||||
|
||||
task::spawn_sched(task::manual_threads(1u)) {||
|
||||
impl_uv_tcp_server(bind_ip, port,
|
||||
kill_server_msg,
|
||||
server_resp_msg,
|
||||
ptr::addr_of(server_chan),
|
||||
continue_chan_ptr);
|
||||
};
|
||||
|
||||
// block until the server up is.. possibly a race?
|
||||
log(debug, "before receiving on server continue_port");
|
||||
comm::recv(continue_port);
|
||||
log(debug, "received on continue port, set up tcp client");
|
||||
|
||||
task::spawn_sched(task::manual_threads(1u)) {||
|
||||
impl_uv_tcp_request(request_ip, port,
|
||||
kill_server_msg,
|
||||
ptr::addr_of(client_chan));
|
||||
};
|
||||
|
||||
let msg_from_client = comm::recv(server_port);
|
||||
let msg_from_server = comm::recv(client_port);
|
||||
|
||||
assert str::contains(msg_from_client, kill_server_msg);
|
||||
assert str::contains(msg_from_server, server_resp_msg);
|
||||
}
|
||||
|
||||
// don't run this test on fbsd or 32bit linux
|
||||
#[cfg(target_os="win32")]
|
||||
#[cfg(target_os="darwin")]
|
||||
#[cfg(target_os="linux")]
|
||||
mod tcp_and_server_client_test {
|
||||
#[cfg(target_arch="x86_64")]
|
||||
mod impl64 {
|
||||
#[test]
|
||||
fn test_uv_ll_tcp_server_and_request() unsafe {
|
||||
impl_uv_tcp_server_and_request();
|
||||
}
|
||||
}
|
||||
#[cfg(target_arch="x86")]
|
||||
mod impl32 {
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "linux"))]
|
||||
fn test_uv_ll_tcp_server_and_request() unsafe {
|
||||
impl_uv_tcp_server_and_request();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// struct size tests
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "freebsd"))]
|
||||
fn test_uv_ll_struct_size_uv_tcp_t() {
|
||||
let native_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size();
|
||||
let rust_handle_size = sys::size_of::<uv_tcp_t>();
|
||||
let output = #fmt("uv_tcp_t -- native: %u rust: %u",
|
||||
native_handle_size as uint, rust_handle_size);
|
||||
log(debug, output);
|
||||
assert native_handle_size as uint == rust_handle_size;
|
||||
}
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "freebsd"))]
|
||||
fn test_uv_ll_struct_size_uv_connect_t() {
|
||||
let native_handle_size =
|
||||
rustrt::rust_uv_helper_uv_connect_t_size();
|
||||
let rust_handle_size = sys::size_of::<uv_connect_t>();
|
||||
let output = #fmt("uv_connect_t -- native: %u rust: %u",
|
||||
native_handle_size as uint, rust_handle_size);
|
||||
log(debug, output);
|
||||
assert native_handle_size as uint == rust_handle_size;
|
||||
}
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "freebsd"))]
|
||||
fn test_uv_ll_struct_size_uv_buf_t() {
|
||||
let native_handle_size =
|
||||
rustrt::rust_uv_helper_uv_buf_t_size();
|
||||
let rust_handle_size = sys::size_of::<uv_buf_t>();
|
||||
let output = #fmt("uv_buf_t -- native: %u rust: %u",
|
||||
native_handle_size as uint, rust_handle_size);
|
||||
log(debug, output);
|
||||
assert native_handle_size as uint == rust_handle_size;
|
||||
}
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "freebsd"))]
|
||||
fn test_uv_ll_struct_size_uv_write_t() {
|
||||
let native_handle_size =
|
||||
rustrt::rust_uv_helper_uv_write_t_size();
|
||||
let rust_handle_size = sys::size_of::<uv_write_t>();
|
||||
let output = #fmt("uv_write_t -- native: %u rust: %u",
|
||||
native_handle_size as uint, rust_handle_size);
|
||||
log(debug, output);
|
||||
assert native_handle_size as uint == rust_handle_size;
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "freebsd"))]
|
||||
fn test_uv_ll_struct_size_sockaddr_in() {
|
||||
let native_handle_size =
|
||||
rustrt::rust_uv_helper_sockaddr_in_size();
|
||||
let rust_handle_size = sys::size_of::<sockaddr_in>();
|
||||
let output = #fmt("sockaddr_in -- native: %u rust: %u",
|
||||
native_handle_size as uint, rust_handle_size);
|
||||
log(debug, output);
|
||||
assert native_handle_size as uint == rust_handle_size;
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "freebsd"))]
|
||||
fn test_uv_ll_struct_size_uv_async_t() {
|
||||
let native_handle_size =
|
||||
rustrt::rust_uv_helper_uv_async_t_size();
|
||||
let rust_handle_size = sys::size_of::<uv_async_t>();
|
||||
let output = #fmt("uv_async_t -- native: %u rust: %u",
|
||||
native_handle_size as uint, rust_handle_size);
|
||||
log(debug, output);
|
||||
assert native_handle_size as uint == rust_handle_size;
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore(cfg(target_os = "freebsd"))]
|
||||
fn test_uv_ll_struct_size_uv_timer_t() {
|
||||
let native_handle_size =
|
||||
rustrt::rust_uv_helper_uv_timer_t_size();
|
||||
let rust_handle_size = sys::size_of::<uv_timer_t>();
|
||||
let output = #fmt("uv_timer_t -- native: %u rust: %u",
|
||||
native_handle_size as uint, rust_handle_size);
|
||||
log(debug, output);
|
||||
assert native_handle_size as uint == rust_handle_size;
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue