commit the latest test state

a lot of tests are now passing, but still some work to do
on the clone routines.
This commit is contained in:
bunnie 2022-08-05 05:03:10 +08:00
parent 24a0848a43
commit 89cba7250e

View file

@ -10,26 +10,55 @@ use std::sync::atomic::{AtomicUsize, Ordering};
pub(crate) fn start_batch_tests() {
let _ = thread::spawn({
move || {
log::info!("################################################## bind_error");
bind_error();
log::info!("################################################## connect_error");
connect_error();
log::info!("################################################## listen_localhost");
listen_localhost();
log::info!("################################################## connect_loopback");
connect_loopback();
log::info!("################################################## smoke_test");
smoke_test();
log::info!("################################################## read_eof");
read_eof();
log::info!("################################################## write_close");
write_close();
log::info!("################################################## partial_read");
partial_read();
log::info!("################################################## read_vectored");
read_vectored();
log::info!("################################################## write_vectored");
write_vectored();
let run_passing = false;
if run_passing {
log::info!("################################################## bind_error");
bind_error();
log::info!("################################################## connect_error");
connect_error();
log::info!("################################################## listen_localhost");
listen_localhost();
log::info!("################################################## connect_loopback");
connect_loopback();
log::info!("################################################## smoke_test");
smoke_test();
log::info!("################################################## read_eof");
read_eof();
log::info!("################################################## write_close");
write_close();
log::info!("################################################## partial_read");
partial_read();
// note: these tests don't pass in their native form because our Close is blocking
// tried to make it non-blocking but other things break because the smoltcp layer doesn't
// clear enough state if you just let things move on (I think).
log::info!("################################################## read_vectored");
read_vectored();
log::info!("################################################## write_vectored");
write_vectored();
// This test cannot be run until issue #210 is fixed see https://github.com/betrusted-io/xous-core/issues/210
//log::info!("################################################## nodelay");
//nodelay();
log::info!("################################################## ttl");
ttl();
log::info!("################################################## set_nonblocking");
set_nonblocking();
log::info!("################################################## peek");
peek();
log::info!("################################################## timeouts");
timeouts();
log::info!("################################################## test_read_timeout");
test_read_timeout();
log::info!("################################################## test_read_with_timeout");
test_read_with_timeout();
log::info!("################################################## test_timeout_zero_duration");
test_timeout_zero_duration();
log::info!("################################################## connect_timeout_valid");
connect_timeout_valid();
}
log::info!("################################################## tcp_clone_smoke");
tcp_clone_smoke();
log::info!("################################################## tcp_clone_two_read");
@ -42,24 +71,6 @@ pub(crate) fn start_batch_tests() {
clone_accept_smoke();
log::info!("################################################## clone_accept_concurrent");
clone_accept_concurrent();
log::info!("################################################## timeouts");
timeouts();
log::info!("################################################## test_read_timeout");
test_read_timeout();
log::info!("################################################## test_read_with_timeout");
test_read_with_timeout();
log::info!("################################################## test_timeout_zero_duration");
test_timeout_zero_duration();
log::info!("################################################## nodelay");
nodelay();
log::info!("################################################## ttl");
ttl();
log::info!("################################################## set_nonblocking");
set_nonblocking();
log::info!("################################################## peek");
peek();
log::info!("################################################## connect_timeout_valid");
connect_timeout_valid();
log::info!("################################################## multiple_connect_serial");
multiple_connect_serial();
log::info!("################################################## multiple_connect_interleaved_greedy_schedule");
@ -357,8 +368,10 @@ fn read_vectored() {
let mut s1 = t!(TcpStream::connect(&addr));
let mut s2 = t!(srv.accept()).0;
let len = s1.write(&[10, 11, 12]).unwrap();
assert_eq!(len, 3);
let _ = thread::spawn(move || {
let len = s1.write(&[10, 11, 12]).unwrap();
assert_eq!(len, 3);
});
let mut a = [];
let mut b = [0];
@ -382,10 +395,12 @@ fn write_vectored() {
let mut s1 = t!(TcpStream::connect(&addr));
let mut s2 = t!(srv.accept()).0;
let a = [];
let b = [10];
let c = [11, 12];
t!(s1.write_vectored(&[IoSlice::new(&a), IoSlice::new(&b), IoSlice::new(&c)]));
let _ = thread::spawn(move || {
let a = [];
let b = [10];
let c = [11, 12];
t!(s1.write_vectored(&[IoSlice::new(&a), IoSlice::new(&b), IoSlice::new(&c)]));
});
let mut buf = [0; 4];
let len = t!(s2.read(&mut buf));
@ -578,27 +593,39 @@ fn clone_accept_concurrent() {
// VxWorks ignores SO_SNDTIMEO.
fn timeouts() {
let addr = next_test_ip4();
log::info!("timeout to addr {:?}", addr);
let listener = t!(TcpListener::bind(&addr));
let stream = t!(TcpStream::connect(&("localhost", addr.port())));
let dur = Duration::new(15410, 0);
let handle = thread::spawn(move || {
log::info!("making stream");
let stream = t!(TcpStream::connect(&("localhost", addr.port())));
let dur = Duration::new(15410, 0);
assert_eq!(None, t!(stream.read_timeout()));
log::info!("checking null read timeout");
assert_eq!(None, t!(stream.read_timeout()));
t!(stream.set_read_timeout(Some(dur)));
assert_eq!(Some(dur), t!(stream.read_timeout()));
log::info!("setting and reading read timeout");
t!(stream.set_read_timeout(Some(dur)));
assert_eq!(Some(dur), t!(stream.read_timeout()));
assert_eq!(None, t!(stream.write_timeout()));
log::info!("checking null write timeout");
assert_eq!(None, t!(stream.write_timeout()));
t!(stream.set_write_timeout(Some(dur)));
assert_eq!(Some(dur), t!(stream.write_timeout()));
log::info!("setting and reading write timeout");
t!(stream.set_write_timeout(Some(dur)));
assert_eq!(Some(dur), t!(stream.write_timeout()));
t!(stream.set_read_timeout(None));
assert_eq!(None, t!(stream.read_timeout()));
log::info!("resetting timeouts to zero");
t!(stream.set_read_timeout(None));
assert_eq!(None, t!(stream.read_timeout()));
t!(stream.set_write_timeout(None));
assert_eq!(None, t!(stream.write_timeout()));
t!(stream.set_write_timeout(None));
assert_eq!(None, t!(stream.write_timeout()));
log::info!("closing connection");
});
let _ = handle.join();
drop(listener);
log::info!("closed");
}
fn test_read_timeout() {
@ -664,17 +691,24 @@ fn test_timeout_zero_duration() {
drop(listener);
}
#[allow(dead_code)] // until issue #210 is resolved
fn nodelay() {
let addr = next_test_ip4();
let _listener = t!(TcpListener::bind(&addr));
log::info!("starting listener");
let listener = t!(TcpListener::bind(&addr));
let stream = t!(TcpStream::connect(&("localhost", addr.port())));
let handle = thread::spawn(move || {
log::info!("connect to localhost port {}", addr.port());
let stream = t!(TcpStream::connect(&("localhost", addr.port())));
assert_eq!(false, t!(stream.nodelay()));
t!(stream.set_nodelay(true));
assert_eq!(true, t!(stream.nodelay()));
t!(stream.set_nodelay(false));
assert_eq!(false, t!(stream.nodelay()));
assert_eq!(false, t!(stream.nodelay()));
t!(stream.set_nodelay(true));
assert_eq!(true, t!(stream.nodelay()));
t!(stream.set_nodelay(false));
assert_eq!(false, t!(stream.nodelay()));
});
let _ = handle.join();
drop(listener);
}
fn ttl() {
@ -686,59 +720,81 @@ fn ttl() {
t!(listener.set_ttl(ttl));
assert_eq!(ttl, t!(listener.ttl()));
let stream = t!(TcpStream::connect(&("localhost", addr.port())));
let handle = thread::spawn(move || {
let stream = t!(TcpStream::connect(&("localhost", addr.port())));
t!(stream.set_ttl(ttl));
assert_eq!(ttl, t!(stream.ttl()));
t!(stream.set_ttl(ttl));
assert_eq!(ttl, t!(stream.ttl()));
});
let _ = handle.join();
drop(listener);
}
#[allow(dead_code)] // not yet implemented
fn set_nonblocking() {
let addr = next_test_ip4();
let listener = t!(TcpListener::bind(&addr));
log::info!("setting nonblocking on listener");
t!(listener.set_nonblocking(true));
t!(listener.set_nonblocking(false));
let mut stream = t!(TcpStream::connect(&("localhost", addr.port())));
let handle = thread::spawn(move || {
let mut stream = t!(TcpStream::connect(&("localhost", addr.port())));
log::info!("setting nonblocking on client");
t!(stream.set_nonblocking(false));
t!(stream.set_nonblocking(true));
t!(stream.set_nonblocking(false));
t!(stream.set_nonblocking(true));
let mut buf = [0];
match stream.read(&mut buf) {
Ok(_) => panic!("expected error"),
Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
Err(e) => panic!("unexpected error {}", e),
}
let mut buf = [0];
log::info!("attempting to read on a socket with no data");
match stream.read(&mut buf) {
Ok(_) => panic!("expected error"),
Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
Err(e) => panic!("unexpected error {}", e),
}
});
let _ = handle.join();
drop(listener);
}
#[cfg_attr(target_env = "sgx", ignore)] // FIXME: https://github.com/fortanix/rust-sgx/issues/31
fn peek() {
each_ip(&mut |addr| {
log::info!("starting mpsc");
let (txdone, rxdone) = channel();
log::info!("building server");
let srv = t!(TcpListener::bind(&addr));
let _t = thread::spawn(move || {
log::info!("waiting for a connection");
let mut cl = t!(srv.accept()).0;
log::info!("filling numbers in connection");
cl.write(&[1, 3, 3, 7]).unwrap();
log::info!("waiting for signal to close");
t!(rxdone.recv());
log::info!("closing");
});
log::info!("connecting to server");
let mut c = t!(TcpStream::connect(&addr));
let mut b = [0; 10];
for _ in 1..3 {
for i in 1..3 {
log::info!("peek iter {}", i);
let len = c.peek(&mut b).unwrap();
log::info!("peek data {:?}", b);
assert_eq!(len, 4);
}
let len = c.read(&mut b).unwrap();
log::info!("read data {:?} of len {}", b, len);
assert_eq!(len, 4);
log::info!("testing nonblocking peek of now empty stream");
t!(c.set_nonblocking(true));
match c.peek(&mut b) {
Ok(_) => panic!("expected error"),
Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
Err(e) => panic!("unexpected error {}", e),
}
log::info!("informing server it can close");
t!(txdone.send(()));
})
}