| use {localhost, TryWrite}; |
| use mio::*; |
| use mio::deprecated::{EventLoop, Handler}; |
| use mio::tcp::*; |
| use bytes::SliceBuf; |
| use std::time::Duration; |
| |
| const SERVER: Token = Token(0); |
| const CLIENT: Token = Token(1); |
| |
| struct TestHandler { |
| server: TcpListener, |
| client: TcpStream, |
| state: usize, |
| } |
| |
| impl TestHandler { |
| fn new(srv: TcpListener, cli: TcpStream) -> TestHandler { |
| TestHandler { |
| server: srv, |
| client: cli, |
| state: 0, |
| } |
| } |
| |
| fn handle_read(&mut self, event_loop: &mut EventLoop<TestHandler>, token: Token, _: Ready) { |
| match token { |
| SERVER => { |
| trace!("handle_read; token=SERVER"); |
| let mut sock = self.server.accept().unwrap().0; |
| sock.try_write_buf(&mut SliceBuf::wrap("foobar".as_bytes())).unwrap(); |
| } |
| CLIENT => { |
| trace!("handle_read; token=CLIENT"); |
| assert!(self.state == 0, "unexpected state {}", self.state); |
| self.state = 1; |
| event_loop.reregister(&self.client, CLIENT, Ready::writable(), PollOpt::level()).unwrap(); |
| } |
| _ => panic!("unexpected token"), |
| } |
| } |
| |
| fn handle_write(&mut self, event_loop: &mut EventLoop<TestHandler>, token: Token, _: Ready) { |
| debug!("handle_write; token={:?}; state={:?}", token, self.state); |
| |
| assert!(token == CLIENT, "unexpected token {:?}", token); |
| assert!(self.state == 1, "unexpected state {}", self.state); |
| |
| self.state = 2; |
| event_loop.deregister(&self.client).unwrap(); |
| event_loop.timeout(1, Duration::from_millis(200)).unwrap(); |
| } |
| } |
| |
| impl Handler for TestHandler { |
| type Timeout = usize; |
| type Message = (); |
| |
| fn ready(&mut self, event_loop: &mut EventLoop<TestHandler>, token: Token, events: Ready) { |
| if events.is_readable() { |
| self.handle_read(event_loop, token, events); |
| } |
| |
| if events.is_writable() { |
| self.handle_write(event_loop, token, events); |
| } |
| } |
| |
| fn timeout(&mut self, event_loop: &mut EventLoop<TestHandler>, _: usize) { |
| trace!("timeout"); |
| event_loop.shutdown(); |
| } |
| } |
| |
| #[test] |
| pub fn test_register_deregister() { |
| let _ = ::env_logger::init(); |
| |
| debug!("Starting TEST_REGISTER_DEREGISTER"); |
| let mut event_loop = EventLoop::new().unwrap(); |
| |
| let addr = localhost(); |
| |
| let server = TcpListener::bind(&addr).unwrap(); |
| |
| info!("register server socket"); |
| event_loop.register(&server, SERVER, Ready::readable(), PollOpt::edge()).unwrap(); |
| |
| let client = TcpStream::connect(&addr).unwrap(); |
| |
| // Register client socket only as writable |
| event_loop.register(&client, CLIENT, Ready::readable(), PollOpt::level()).unwrap(); |
| |
| let mut handler = TestHandler::new(server, client); |
| |
| // Start the event loop |
| event_loop.run(&mut handler).unwrap(); |
| |
| assert!(handler.state == 2, "unexpected final state {}", handler.state); |
| } |
| |
| #[test] |
| pub fn test_register_with_no_readable_writable_is_error() { |
| let poll = Poll::new().unwrap(); |
| let addr = localhost(); |
| |
| let sock = TcpListener::bind(&addr).unwrap(); |
| |
| assert!(poll.register(&sock, Token(0), Ready::hup(), PollOpt::edge()).is_err()); |
| |
| poll.register(&sock, Token(0), Ready::readable(), PollOpt::edge()).unwrap(); |
| |
| assert!(poll.reregister(&sock, Token(0), Ready::hup(), PollOpt::edge()).is_err()); |
| } |