Always use a timeout calling Poll::poll in tests

tests/close_on_drop.rs

@@ -1,12 +1,13 @@
 #![cfg(feature = "tcp")]
 
+use self::TestState::{AfterRead, Initial};
 use log::debug;
 use mio::net::{TcpListener, TcpStream};
 use mio::{Events, Interest, Poll, Token};
 use std::io::Read;
+
 mod util;
-use self::TestState::{AfterRead, Initial};
-use util::{any_local_address, init};
+use util::{any_local_address, init, NO_TIMEOUT};
 
 const SERVER: Token = Token(0);
 const CLIENT: Token = Token(1);
@@ -112,7 +113,8 @@ pub fn close_on_drop() {
 
     // == Run test
     while !handler.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.is_readable() {

tests/poll.rs

@@ -13,6 +13,7 @@ mod util;
 
 use util::{
     any_local_address, assert_send, assert_sync, expect_events, init, init_with_poll, ExpectEvent,
+    NO_TIMEOUT,
 };
 
 const ID1: Token = Token(1);
@@ -142,7 +143,8 @@ fn drop_cancels_interest_and_shuts_down() {
         .unwrap();
     let mut events = Events::with_capacity(16);
     'outer: loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
         for event in &events {
             if event.token() == Token(1) {
                 // connected

tests/registering.rs

@@ -10,7 +10,7 @@ use std::thread::sleep;
 use std::time::Duration;
 
 mod util;
-use util::{any_local_address, init};
+use util::{any_local_address, init, NO_TIMEOUT};
 
 const SERVER: Token = Token(0);
 const CLIENT: Token = Token(1);
@@ -91,7 +91,8 @@ pub fn register_deregister() {
     let mut handler = TestHandler::new(server, client);
 
     loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         if let Some(event) = events.iter().next() {
             if event.is_readable() {

tests/regressions.rs

@@ -8,7 +8,7 @@ use std::time::Duration;
 use std::{net, thread};
 
 mod util;
-use util::{any_local_address, init, init_with_poll};
+use util::{any_local_address, init, init_with_poll, NO_TIMEOUT};
 
 const ID1: Token = Token(1);
 const WAKE_TOKEN: Token = Token(10);
@@ -35,7 +35,8 @@ fn issue_776() {
         .unwrap();
     let mut events = Events::with_capacity(16);
     'outer: loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
         for event in &events {
             if event.token() == Token(1) {
                 // connected
@@ -68,7 +69,7 @@ fn issue_1205() {
         .register(&mut listener, ID1, Interest::READABLE)
         .unwrap();
 
-    poll.poll(&mut events, Some(std::time::Duration::from_millis(0)))
+    poll.poll(&mut events, Some(Duration::from_millis(0)))
         .unwrap();
     assert!(events.iter().count() == 0);
 
@@ -82,7 +83,7 @@ fn issue_1205() {
         waker1.wake().expect("unable to wake");
     });
 
-    poll.poll(&mut events, None).unwrap();
+    poll.poll(&mut events, NO_TIMEOUT).unwrap();
 
     // the poll should return only one event that being the waker event.
     // the poll should not retrieve event for the listener above because it was

tests/tcp.rs

@@ -16,7 +16,7 @@ use std::time::Duration;
 mod util;
 use util::{
     any_local_address, assert_send, assert_sync, expect_events, expect_no_events, init,
-    init_with_poll, ExpectEvent,
+    init_with_poll, ExpectEvent, NO_TIMEOUT,
 };
 
 const LISTEN: Token = Token(0);
@@ -63,7 +63,8 @@ fn accept() {
         shutdown: false,
     };
     while !h.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             h.hit = true;
@@ -113,7 +114,8 @@ fn connect() {
         shutdown: false,
     };
     while !h.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             assert_eq!(event.token(), Token(1));
@@ -131,7 +133,8 @@ fn connect() {
     rx2.recv().unwrap();
     h.shutdown = false;
     while !h.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             assert_eq!(event.token(), Token(1));
@@ -186,7 +189,8 @@ fn read() {
         shutdown: false,
     };
     while !h.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             assert_eq!(event.token(), Token(1));
@@ -245,7 +249,8 @@ fn peek() {
         shutdown: false,
     };
     while !h.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             assert_eq!(event.token(), Token(1));
@@ -310,7 +315,8 @@ fn write() {
         shutdown: false,
     };
     while !h.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             assert_eq!(event.token(), Token(1));
@@ -358,7 +364,8 @@ fn connect_then_close() {
         shutdown: false,
     };
     while !h.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.token() == Token(1) {
@@ -440,7 +447,8 @@ fn multiple_writes_immediate_success() {
 
     // Wait for our TCP stream to connect
     'outer: loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
         for event in events.iter() {
             if event.token() == Token(1) && event.is_writable() {
                 break 'outer;
@@ -495,7 +503,8 @@ fn connection_reset_by_peer() {
     // Wait for listener to be ready
     let mut server;
     'outer: loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.token() == Token(0) {
@@ -523,7 +532,8 @@ fn connection_reset_by_peer() {
         .unwrap();
 
     loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.token() == Token(3) {
@@ -563,7 +573,8 @@ fn connect_error() {
         .unwrap();
 
     'outer: loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.token() == Token(0) {
@@ -598,7 +609,8 @@ fn write_error() {
         .unwrap();
 
     let mut wait_writable = || 'outer: loop {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.token() == Token(0) && event.is_writable() {
@@ -731,7 +743,8 @@ fn local_addr_ready() {
     };
 
     while !handler.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             match event.token() {
@@ -784,9 +797,7 @@ fn write_then_drop() {
         .unwrap();
 
     let mut events = Events::with_capacity(1024);
-    while events.is_empty() {
-        poll.poll(&mut events, None).unwrap();
-    }
+    poll.poll(&mut events, NO_TIMEOUT).unwrap();
     assert_eq!(events.iter().count(), 1);
     assert_eq!(events.iter().next().unwrap().token(), Token(1));
 
@@ -797,9 +808,7 @@ fn write_then_drop() {
         .unwrap();
 
     let mut events = Events::with_capacity(1024);
-    while events.is_empty() {
-        poll.poll(&mut events, None).unwrap();
-    }
+    poll.poll(&mut events, NO_TIMEOUT).unwrap();
     assert_eq!(events.iter().count(), 1);
     assert_eq!(events.iter().next().unwrap().token(), Token(2));
 
@@ -811,9 +820,7 @@ fn write_then_drop() {
         .unwrap();
 
     let mut events = Events::with_capacity(1024);
-    while events.is_empty() {
-        poll.poll(&mut events, None).unwrap();
-    }
+    poll.poll(&mut events, NO_TIMEOUT).unwrap();
     assert_eq!(events.iter().count(), 1);
     assert_eq!(events.iter().next().unwrap().token(), Token(3));
 
@@ -839,9 +846,7 @@ fn write_then_deregister() {
         .unwrap();
 
     let mut events = Events::with_capacity(1024);
-    while events.is_empty() {
-        poll.poll(&mut events, None).unwrap();
-    }
+    poll.poll(&mut events, NO_TIMEOUT).unwrap();
     assert_eq!(events.iter().count(), 1);
     assert_eq!(events.iter().next().unwrap().token(), Token(1));
 
@@ -852,9 +857,7 @@ fn write_then_deregister() {
         .unwrap();
 
     let mut events = Events::with_capacity(1024);
-    while events.is_empty() {
-        poll.poll(&mut events, None).unwrap();
-    }
+    poll.poll(&mut events, NO_TIMEOUT).unwrap();
     assert_eq!(events.iter().count(), 1);
     assert_eq!(events.iter().next().unwrap().token(), Token(2));
 
@@ -866,9 +869,7 @@ fn write_then_deregister() {
         .unwrap();
 
     let mut events = Events::with_capacity(1024);
-    while events.is_empty() {
-        poll.poll(&mut events, None).unwrap();
-    }
+    poll.poll(&mut events, NO_TIMEOUT).unwrap();
     assert_eq!(events.iter().count(), 1);
     assert_eq!(events.iter().next().unwrap().token(), Token(3));
 

tests/udp_socket.rs

@@ -18,6 +18,7 @@ mod util;
 use util::{
     any_local_address, any_local_ipv6_address, assert_error, assert_send, assert_sync,
     assert_would_block, expect_events, expect_no_events, init, init_with_poll, ExpectEvent,
+    NO_TIMEOUT,
 };
 
 const DATA1: &[u8] = b"Hello world!";
@@ -751,7 +752,8 @@ fn send_recv_udp(mut tx: UdpSocket, mut rx: UdpSocket, connected: bool) {
     let mut handler = UdpHandlerSendRecv::new(tx, rx, connected, "hello world");
 
     while !handler.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.is_readable() {
@@ -954,7 +956,8 @@ pub fn multicast() {
     info!("Starting event loop to test with...");
 
     while !handler.shutdown {
-        poll.poll(&mut events, None).unwrap();
+        poll.poll(&mut events, NO_TIMEOUT).unwrap();
+        assert!(!events.is_empty(), "expected at least one event");
 
         for event in &events {
             if event.is_readable() {

tests/util/mod.rs

@@ -12,6 +12,16 @@ use log::{error, warn};
 use mio::event::Event;
 use mio::{Events, Interest, Poll, Token};
 
+/// This timeout represents cases where we want to use no timeout, i.e. `None`,
+/// but we don't actually want to use no timeout as that could cause a failing
+/// test, one in which an event never comes, to run forever. This causes the CI
+/// to remain idle, up to one hour, after which its forcefully killed. This
+/// leaves us with a single line of logs; `test $name has been running for over
+/// 60 seconds`, not the best debugging experience. Instead we use this high,
+/// but not infinite, timeout after which assertions (that check the returned
+/// events) should start failing.
+pub const NO_TIMEOUT: Option<Duration> = Some(Duration::from_secs(10));
+
 pub fn init() {
     static INIT: Once = Once::new();