mod test {
use prelude::v1::*;
- use comm::channel;
+ use sync::mpsc::channel;
use thread::Thread;
use io::net::tcp::*;
use io::net::ip::*;
- use io::{EndOfFile, TimedOut, IoError, ShortWrite, OtherIoError, ConnectionAborted};
- use io::{ConnectionRefused, ConnectionReset, BrokenPipe, NotConnected};
- use io::{PermissionDenied, Listener, Acceptor};
use io::test::*;
+ use io::{EndOfFile, TimedOut, ShortWrite, IoError};
+ use io::{ConnectionRefused, BrokenPipe, ConnectionAborted};
+ use io::{ConnectionReset, NotConnected, PermissionDenied, OtherIoError};
+ use io::{Acceptor, Listener};
// FIXME #11530 this fails on android because tests are run as root
#[cfg_attr(any(windows, target_os = "android"), ignore)]
let (tx, rx) = channel();
let _t = Thread::spawn(move|| {
drop(TcpStream::connect(addr));
- tx.send(());
+ tx.send(()).unwrap();
});
let mut stream = acceptor.accept();
- rx.recv();
+ rx.recv().unwrap();
let buf = [0];
match stream.write(&buf) {
Ok(..) => {}
let (tx, rx) = channel();
let _t = Thread::spawn(move|| {
drop(TcpStream::connect(addr));
- tx.send(());
+ tx.send(()).unwrap();
});
let mut stream = acceptor.accept();
- rx.recv();
+ rx.recv().unwrap();
let buf = [0];
match stream.write(&buf) {
Ok(..) => {}
let (tx, rx) = channel();
let _t = Thread::spawn(move|| {
let mut srv = TcpListener::bind(addr).listen().unwrap();
- tx.send(());
+ tx.send(()).unwrap();
let mut cl = srv.accept().unwrap();
cl.write(&[10]).unwrap();
let mut b = [0];
cl.read(&mut b).unwrap();
- tx.send(());
+ tx.send(()).unwrap();
});
- rx.recv();
+ rx.recv().unwrap();
let mut c = TcpStream::connect(addr).unwrap();
let mut b = [0; 10];
assert_eq!(c.read(&mut b), Ok(1));
c.write(&[1]).unwrap();
- rx.recv();
+ rx.recv().unwrap();
}
#[test]
let (tx, rx) = channel();
let _t = Thread::spawn(move|| {
- rx.recv();
+ rx.recv().unwrap();
let _stream = TcpStream::connect(addr).unwrap();
// Close
- rx.recv();
+ rx.recv().unwrap();
});
{
let mut acceptor = TcpListener::bind(addr).listen();
- tx.send(());
+ tx.send(()).unwrap();
{
let _stream = acceptor.accept().unwrap();
// Close client
- tx.send(());
+ tx.send(()).unwrap();
}
// Close listener
}
let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| {
let mut s2 = s2;
- rx1.recv();
+ rx1.recv().unwrap();
s2.write(&[1]).unwrap();
- tx2.send(());
+ tx2.send(()).unwrap();
});
- tx1.send(());
+ tx1.send(()).unwrap();
let mut buf = [0, 0];
assert_eq!(s1.read(&mut buf), Ok(1));
- rx2.recv();
+ rx2.recv().unwrap();
}
#[test]
let _t = Thread::spawn(move|| {
let mut s = TcpStream::connect(addr);
s.write(&[1]).unwrap();
- rx.recv();
+ rx.recv().unwrap();
s.write(&[2]).unwrap();
- rx.recv();
+ rx.recv().unwrap();
});
let mut s1 = acceptor.accept().unwrap();
let mut s2 = s2;
let mut buf = [0, 0];
s2.read(&mut buf).unwrap();
- tx2.send(());
- done.send(());
+ tx2.send(()).unwrap();
+ done.send(()).unwrap();
});
let mut buf = [0, 0];
s1.read(&mut buf).unwrap();
- tx1.send(());
+ tx1.send(()).unwrap();
- rx.recv();
+ rx.recv().unwrap();
}
#[test]
let _t = Thread::spawn(move|| {
let mut s2 = s2;
s2.write(&[1]).unwrap();
- done.send(());
+ done.send(()).unwrap();
});
s1.write(&[2]).unwrap();
- rx.recv();
+ rx.recv().unwrap();
}
#[test]
if !cfg!(target_os = "freebsd") {
let (tx, rx) = channel();
let _t = Thread::spawn(move|| {
- tx.send(TcpStream::connect(addr).unwrap());
+ tx.send(TcpStream::connect(addr).unwrap()).unwrap();
});
- let _l = rx.recv();
+ let _l = rx.recv().unwrap();
for i in range(0i, 1001) {
match a.accept() {
Ok(..) => break,
Thread::spawn(move|| {
let mut a = a;
let _s = a.accept().unwrap();
- let _ = rx.recv_opt();
+ let _ = rx.recv().unwrap();
}).detach();
let mut b = [0];
Thread::spawn(move|| {
let mut a = a;
let _s = a.accept().unwrap();
- let _ = rx.recv_opt();
+ let _ = rx.recv().unwrap();
}).detach();
let mut s = TcpStream::connect(addr).unwrap();
let _t = Thread::spawn(move|| {
let mut s2 = s2;
assert!(s2.read(&mut [0]).is_err());
- tx.send(());
+ tx.send(()).unwrap();
});
// this should wake up the child task
s.close_read().unwrap();
// this test will never finish if the child doesn't wake up
- rx.recv();
+ rx.recv().unwrap();
}
#[test]
let (tx, rx) = channel::<()>();
Thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap();
- rx.recv();
+ rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
- let _ = rx.recv_opt();
+ let _ = rx.recv();
}).detach();
let mut s = a.accept().unwrap();
}
assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
- tx.send(());
+ tx.send(()).unwrap();
s.set_timeout(None);
assert_eq!(s.read(&mut [0, 0]), Ok(1));
}
let (tx, rx) = channel::<()>();
Thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap();
- rx.recv();
+ rx.recv().unwrap();
let mut amt = 0;
while amt < 100 * 128 * 1024 {
match s.read(&mut [0;128 * 1024]) {
Err(e) => panic!("{}", e),
}
}
- let _ = rx.recv_opt();
+ let _ = rx.recv();
}).detach();
let mut s = a.accept().unwrap();
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
- tx.send(());
+ tx.send(()).unwrap();
for _ in range(0i, 100) {
assert!(s.write(&[0;128 * 1024]).is_ok());
}
let (tx, rx) = channel::<()>();
Thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap();
- rx.recv();
+ rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
- let _ = rx.recv_opt();
+ let _ = rx.recv();
}).detach();
let mut s = a.accept().unwrap();
}
assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
- tx.send(());
+ tx.send(()).unwrap();
assert!(s.read(&mut [0]).is_ok());
}
let (tx, rx) = channel::<()>();
Thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap();
- rx.recv();
+ rx.recv().unwrap();
assert_eq!(s.write(&[0]), Ok(()));
- let _ = rx.recv_opt();
+ let _ = rx.recv();
}).detach();
let mut s = a.accept().unwrap();
let _t = Thread::spawn(move|| {
let mut s2 = s2;
assert_eq!(s2.read(&mut [0]), Ok(1));
- tx2.send(());
+ tx2.send(()).unwrap();
});
s.set_read_timeout(Some(20));
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
- tx.send(());
+ tx.send(()).unwrap();
- rx2.recv();
+ rx2.recv().unwrap();
}
#[test]
let txdone2 = txdone.clone();
let _t = Thread::spawn(move|| {
let mut tcp = TcpStream::connect(addr).unwrap();
- rx.recv();
+ rx.recv().unwrap();
tcp.write_u8(0).unwrap();
- txdone2.send(());
+ txdone2.send(()).unwrap();
});
// Spawn off a reading clone
let _t = Thread::spawn(move|| {
let mut tcp2 = tcp2;
tcp2.read_u8().unwrap();
- txdone3.send(());
+ txdone3.send(()).unwrap();
});
// Try to ensure that the reading clone is indeed reading
// clone the handle again while it's reading, then let it finish the
// read.
let _ = tcp.clone();
- tx.send(());
- rxdone.recv();
- rxdone.recv();
+ tx.send(()).unwrap();
+ rxdone.recv().unwrap();
+ rxdone.recv().unwrap();
}
#[test]
let (tx, rx) = channel();
let tx2 = tx.clone();
- let _t = Thread::spawn(move|| { let mut a = a; tx.send(a.accept()) });
- let _t = Thread::spawn(move|| { let mut a = a2; tx2.send(a.accept()) });
+ let _t = Thread::spawn(move|| {
+ let mut a = a;
+ tx.send(a.accept()).unwrap();
+ });
+ let _t = Thread::spawn(move|| {
+ let mut a = a2;
+ tx2.send(a.accept()).unwrap();
+ });
let _t = Thread::spawn(move|| {
let _ = TcpStream::connect(addr);
let _ = TcpStream::connect(addr);
});
- assert!(rx.recv().is_ok());
- assert!(rx.recv().is_ok());
+ assert!(rx.recv().unwrap().is_ok());
+ assert!(rx.recv().unwrap().is_ok());
}
#[test]
let (tx, rx) = channel();
let _t = Thread::spawn(move|| {
let mut a = a;
- tx.send(a.accept());
+ tx.send(a.accept()).unwrap();
});
a2.close_accept().unwrap();
- assert_eq!(rx.recv().err().unwrap().kind, EndOfFile);
+ assert_eq!(rx.recv().unwrap().err().unwrap().kind, EndOfFile);
}
}