Vendor dependencies for 0.3.0 release

vendor/polling/tests/concurrent_modification.rs

@@ -0,0 +1,131 @@
+use std::io::{self, Write};
+use std::net::{TcpListener, TcpStream};
+use std::thread;
+use std::time::Duration;
+
+use easy_parallel::Parallel;
+use polling::{Event, Events, Poller};
+
+#[test]
+fn concurrent_add() -> io::Result<()> {
+    let (reader, mut writer) = tcp_pair()?;
+    let poller = Poller::new()?;
+
+    let mut events = Events::new();
+
+    let result = Parallel::new()
+        .add(|| {
+            poller.wait(&mut events, None)?;
+            Ok(())
+        })
+        .add(|| {
+            thread::sleep(Duration::from_millis(100));
+            unsafe {
+                poller.add(&reader, Event::readable(0))?;
+            }
+            writer.write_all(&[1])?;
+            Ok(())
+        })
+        .run()
+        .into_iter()
+        .collect::<io::Result<()>>();
+
+    poller.delete(&reader)?;
+    result?;
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(0)
+    );
+
+    Ok(())
+}
+
+#[test]
+fn concurrent_modify() -> io::Result<()> {
+    let (reader, mut writer) = tcp_pair()?;
+    let poller = Poller::new()?;
+    unsafe {
+        poller.add(&reader, Event::none(0))?;
+    }
+
+    let mut events = Events::new();
+
+    Parallel::new()
+        .add(|| {
+            poller.wait(&mut events, Some(Duration::from_secs(10)))?;
+            Ok(())
+        })
+        .add(|| {
+            thread::sleep(Duration::from_millis(100));
+            poller.modify(&reader, Event::readable(0))?;
+            writer.write_all(&[1])?;
+            Ok(())
+        })
+        .run()
+        .into_iter()
+        .collect::<io::Result<()>>()?;
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(0)
+    );
+
+    Ok(())
+}
+
+#[cfg(all(unix, not(target_os = "vita")))]
+#[test]
+fn concurrent_interruption() -> io::Result<()> {
+    struct MakeItSend<T>(T);
+    unsafe impl<T> Send for MakeItSend<T> {}
+
+    let (reader, _writer) = tcp_pair()?;
+    let poller = Poller::new()?;
+    unsafe {
+        poller.add(&reader, Event::none(0))?;
+    }
+
+    let mut events = Events::new();
+    let events_borrow = &mut events;
+    let (sender, receiver) = std::sync::mpsc::channel();
+
+    Parallel::new()
+        .add(move || {
+            // Register a signal handler so that the syscall is actually interrupted. A signal that
+            // is ignored by default does not cause an interrupted syscall.
+            signal_hook::flag::register(signal_hook::consts::signal::SIGURG, Default::default())?;
+
+            // Signal to the other thread how to send a signal to us
+            sender
+                .send(MakeItSend(unsafe { libc::pthread_self() }))
+                .unwrap();
+
+            poller.wait(events_borrow, Some(Duration::from_secs(1)))?;
+            Ok(())
+        })
+        .add(move || {
+            let MakeItSend(target_thread) = receiver.recv().unwrap();
+            thread::sleep(Duration::from_millis(100));
+            assert_eq!(0, unsafe {
+                libc::pthread_kill(target_thread, libc::SIGURG)
+            });
+            Ok(())
+        })
+        .run()
+        .into_iter()
+        .collect::<io::Result<()>>()?;
+
+    assert_eq!(events.len(), 0);
+
+    Ok(())
+}
+
+fn tcp_pair() -> io::Result<(TcpStream, TcpStream)> {
+    let listener = TcpListener::bind("127.0.0.1:0")?;
+    let a = TcpStream::connect(listener.local_addr()?)?;
+    let (b, _) = listener.accept()?;
+    Ok((a, b))
+}

vendor/polling/tests/io.rs

@@ -0,0 +1,144 @@
+use polling::{Event, Events, Poller};
+use std::io::{self, Write};
+use std::net::{TcpListener, TcpStream};
+use std::sync::Arc;
+use std::time::Duration;
+
+#[test]
+fn basic_io() {
+    let poller = Poller::new().unwrap();
+    let (read, mut write) = tcp_pair().unwrap();
+    unsafe {
+        poller.add(&read, Event::readable(1)).unwrap();
+    }
+
+    // Nothing should be available at first.
+    let mut events = Events::new();
+    assert_eq!(
+        poller
+            .wait(&mut events, Some(Duration::from_secs(0)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+
+    // After a write, the event should be available now.
+    write.write_all(&[1]).unwrap();
+    assert_eq!(
+        poller
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(1)
+    );
+    poller.delete(&read).unwrap();
+}
+
+#[test]
+fn insert_twice() {
+    #[cfg(unix)]
+    use std::os::unix::io::AsRawFd;
+    #[cfg(windows)]
+    use std::os::windows::io::AsRawSocket;
+
+    let (read, mut write) = tcp_pair().unwrap();
+    let read = Arc::new(read);
+
+    let poller = Poller::new().unwrap();
+    unsafe {
+        #[cfg(unix)]
+        let read = read.as_raw_fd();
+        #[cfg(windows)]
+        let read = read.as_raw_socket();
+
+        poller.add(read, Event::readable(1)).unwrap();
+        assert_eq!(
+            poller.add(read, Event::readable(1)).unwrap_err().kind(),
+            io::ErrorKind::AlreadyExists
+        );
+    }
+
+    write.write_all(&[1]).unwrap();
+    let mut events = Events::new();
+    assert_eq!(
+        poller
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(1)
+    );
+
+    poller.delete(&read).unwrap();
+}
+
+/// Test that calling `wait` appends events, as [documented], rather than
+/// overwriting them.
+///
+/// [documented]: https://docs.rs/polling/latest/polling/struct.Poller.html#method.wait
+#[test]
+fn append_events() {
+    #[cfg(unix)]
+    use std::os::unix::io::AsRawFd;
+    #[cfg(windows)]
+    use std::os::windows::io::AsRawSocket;
+
+    // Create a few sockets.
+    let mut pairs = Vec::new();
+    for _ in 0..4 {
+        let (read, write) = tcp_pair().unwrap();
+        pairs.push((read, write));
+    }
+
+    // Add the sockets to the poller.
+    let poller = Poller::new().unwrap();
+    unsafe {
+        for (read, _write) in &pairs {
+            #[cfg(unix)]
+            let read = read.as_raw_fd();
+            #[cfg(windows)]
+            let read = read.as_raw_socket();
+
+            poller.add(read, Event::readable(1)).unwrap();
+        }
+    }
+
+    // Trigger read events on the sockets and reuse the event list to test
+    // that events are appended.
+    let mut events = Events::new();
+
+    for (index, (_read, ref mut write)) in pairs.iter_mut().enumerate() {
+        // Write to the socket prompting a reader readiness event.
+        write.write_all(&[1]).unwrap();
+        assert_eq!(
+            poller
+                .wait(&mut events, Some(Duration::from_secs(1)))
+                .unwrap(),
+            index + 1
+        );
+        assert_eq!(events.len(), index + 1);
+        for event in events.iter() {
+            assert_eq!(event.with_no_extra(), Event::readable(1));
+        }
+    }
+
+    for (read, _write) in &pairs {
+        poller.delete(read).unwrap();
+    }
+}
+
+fn tcp_pair() -> io::Result<(TcpStream, TcpStream)> {
+    let listener = TcpListener::bind("127.0.0.1:0")?;
+    let a = TcpStream::connect(listener.local_addr()?)?;
+    let (b, _) = listener.accept()?;
+    Ok((a, b))
+}

vendor/polling/tests/many_connections.rs

@@ -0,0 +1,66 @@
+//! Tests to ensure more than 32 connections can be polled at once.
+
+// Doesn't work on OpenBSD.
+#![cfg(not(target_os = "openbsd"))]
+
+use std::io::{self, prelude::*};
+use std::net::{TcpListener, TcpStream};
+use std::time::Duration;
+
+use polling::Events;
+
+#[test]
+fn many_connections() {
+    // Create 100 connections.
+    let mut connections = Vec::new();
+    for i in 0..100 {
+        let (reader, writer) = tcp_pair().unwrap();
+        connections.push((i, reader, writer));
+    }
+
+    // Create a poller and add all the connections.
+    let poller = polling::Poller::new().unwrap();
+
+    for (i, reader, _) in connections.iter() {
+        unsafe {
+            poller.add(reader, polling::Event::readable(*i)).unwrap();
+        }
+    }
+
+    let mut events = Events::new();
+    while !connections.is_empty() {
+        // Choose a random connection to write to.
+        let i = fastrand::usize(..connections.len());
+        let (id, mut reader, mut writer) = connections.remove(i);
+
+        // Write a byte to the connection.
+        writer.write_all(&[1]).unwrap();
+
+        // Wait for the connection to become readable.
+        poller
+            .wait(&mut events, Some(Duration::from_secs(10)))
+            .unwrap();
+
+        // Check that the connection is readable.
+        let current_events = events.iter().collect::<Vec<_>>();
+        assert_eq!(current_events.len(), 1, "events: {current_events:?}");
+        assert_eq!(
+            current_events[0].with_no_extra(),
+            polling::Event::readable(id)
+        );
+
+        // Read the byte from the connection.
+        let mut buf = [0];
+        reader.read_exact(&mut buf).unwrap();
+        assert_eq!(buf, [1]);
+        poller.delete(&reader).unwrap();
+        events.clear();
+    }
+}
+
+fn tcp_pair() -> io::Result<(TcpStream, TcpStream)> {
+    let listener = TcpListener::bind("127.0.0.1:0")?;
+    let a = TcpStream::connect(listener.local_addr()?)?;
+    let (b, _) = listener.accept()?;
+    Ok((a, b))
+}

vendor/polling/tests/multiple_pollers.rs

@@ -0,0 +1,358 @@
+//! Test registering one source into multiple pollers.
+
+use polling::{Event, Events, PollMode, Poller};
+
+use std::io::{self, prelude::*};
+use std::net::{TcpListener, TcpStream};
+use std::time::Duration;
+
+#[test]
+fn level_triggered() {
+    let poller1 = Poller::new().unwrap();
+    let poller2 = Poller::new().unwrap();
+    let mut events = Events::new();
+
+    if !poller1.supports_level() || !poller2.supports_level() {
+        return;
+    }
+
+    // Register the source into both pollers.
+    let (mut reader, mut writer) = tcp_pair().unwrap();
+    unsafe {
+        poller1
+            .add_with_mode(&reader, Event::readable(1), PollMode::Level)
+            .unwrap();
+        poller2
+            .add_with_mode(&reader, Event::readable(2), PollMode::Level)
+            .unwrap();
+    }
+
+    // Neither poller should have any events.
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+
+    // Write to the source.
+    writer.write_all(&[1]).unwrap();
+
+    // At least one poller should have an event.
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(1)
+    );
+
+    events.clear();
+    // poller2 should have zero or one events.
+    match poller2.wait(&mut events, Some(Duration::from_secs(1))) {
+        Ok(1) => {
+            assert_eq!(events.len(), 1);
+            assert_eq!(
+                events.iter().next().unwrap().with_no_extra(),
+                Event::readable(2)
+            );
+        }
+        Ok(0) => assert!(events.is_empty()),
+        _ => panic!("unexpected error"),
+    }
+
+    // Writing more data should cause the same event.
+    writer.write_all(&[1]).unwrap();
+    events.clear();
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(1)
+    );
+
+    // poller2 should have zero or one events.
+    events.clear();
+    match poller2.wait(&mut events, Some(Duration::from_secs(1))) {
+        Ok(1) => {
+            assert_eq!(events.len(), 1);
+            assert_eq!(
+                events.iter().next().unwrap().with_no_extra(),
+                Event::readable(2)
+            );
+        }
+        Ok(0) => assert!(events.is_empty()),
+        _ => panic!("unexpected error"),
+    }
+
+    // Read from the source.
+    reader.read_exact(&mut [0; 2]).unwrap();
+
+    // Both pollers should not have any events.
+    events.clear();
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+
+    // Dereference the pollers.
+    poller1.delete(&reader).unwrap();
+    poller2.delete(&reader).unwrap();
+}
+
+#[test]
+fn edge_triggered() {
+    let poller1 = Poller::new().unwrap();
+    let poller2 = Poller::new().unwrap();
+    let mut events = Events::new();
+
+    if !poller1.supports_edge() || !poller2.supports_edge() {
+        return;
+    }
+
+    // Register the source into both pollers.
+    let (mut reader, mut writer) = tcp_pair().unwrap();
+    unsafe {
+        poller1
+            .add_with_mode(&reader, Event::readable(1), PollMode::Edge)
+            .unwrap();
+        poller2
+            .add_with_mode(&reader, Event::readable(2), PollMode::Edge)
+            .unwrap();
+    }
+
+    // Neither poller should have any events.
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+
+    // Write to the source.
+    writer.write_all(&[1]).unwrap();
+
+    // Both pollers should have an event.
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(1)
+    );
+
+    events.clear();
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(2)
+    );
+
+    // Writing to the poller again should cause an event.
+    writer.write_all(&[1]).unwrap();
+
+    // Both pollers should have one event.
+    events.clear();
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(1)
+    );
+
+    events.clear();
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        1
+    );
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(2)
+    );
+
+    // Read from the source.
+    reader.read_exact(&mut [0; 2]).unwrap();
+
+    // Both pollers should not have any events.
+    events.clear();
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+
+    // Dereference the pollers.
+    poller1.delete(&reader).unwrap();
+    poller2.delete(&reader).unwrap();
+}
+
+#[test]
+fn oneshot_triggered() {
+    let poller1 = Poller::new().unwrap();
+    let poller2 = Poller::new().unwrap();
+    let mut events = Events::new();
+
+    // Register the source into both pollers.
+    let (mut reader, mut writer) = tcp_pair().unwrap();
+    unsafe {
+        poller1
+            .add_with_mode(&reader, Event::readable(1), PollMode::Oneshot)
+            .unwrap();
+        poller2
+            .add_with_mode(&reader, Event::readable(2), PollMode::Oneshot)
+            .unwrap();
+    }
+
+    // Neither poller should have any events.
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+
+    // Write to the source.
+    writer.write_all(&[1]).unwrap();
+
+    // Sources should have either one or no events.
+    match poller1.wait(&mut events, Some(Duration::from_secs(1))) {
+        Ok(1) => {
+            assert_eq!(events.len(), 1);
+            assert_eq!(
+                events.iter().next().unwrap().with_no_extra(),
+                Event::readable(1)
+            );
+        }
+        Ok(0) => assert!(events.is_empty()),
+        _ => panic!("unexpected error"),
+    }
+    events.clear();
+
+    match poller2.wait(&mut events, Some(Duration::from_secs(1))) {
+        Ok(1) => {
+            assert_eq!(events.len(), 1);
+            assert_eq!(
+                events.iter().next().unwrap().with_no_extra(),
+                Event::readable(2)
+            );
+        }
+        Ok(0) => assert!(events.is_empty()),
+        _ => panic!("unexpected error"),
+    }
+    events.clear();
+
+    // Writing more data should not cause an event.
+    writer.write_all(&[1]).unwrap();
+
+    // Sources should have no events.
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+
+    // Read from the source.
+    reader.read_exact(&mut [0; 2]).unwrap();
+
+    // Sources should have no events.
+    assert_eq!(
+        poller1
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        poller2
+            .wait(&mut events, Some(Duration::from_secs(1)))
+            .unwrap(),
+        0
+    );
+    assert!(events.is_empty());
+}
+
+fn tcp_pair() -> io::Result<(TcpStream, TcpStream)> {
+    let listener = TcpListener::bind("127.0.0.1:0")?;
+    let a = TcpStream::connect(listener.local_addr()?)?;
+    let (b, _) = listener.accept()?;
+    Ok((a, b))
+}

vendor/polling/tests/notify.rs

@@ -0,0 +1,38 @@
+use std::io;
+use std::thread;
+use std::time::Duration;
+
+use easy_parallel::Parallel;
+use polling::Events;
+use polling::Poller;
+
+#[test]
+fn simple() -> io::Result<()> {
+    let poller = Poller::new()?;
+    let mut events = Events::new();
+
+    for _ in 0..10 {
+        poller.notify()?;
+        poller.wait(&mut events, None)?;
+        assert!(events.is_empty());
+    }
+
+    Ok(())
+}
+
+#[test]
+fn concurrent() -> io::Result<()> {
+    let poller = Poller::new()?;
+    let mut events = Events::new();
+
+    for _ in 0..2 {
+        Parallel::new()
+            .add(|| {
+                thread::sleep(Duration::from_secs(0));
+                poller.notify().unwrap();
+            })
+            .finish(|| poller.wait(&mut events, None).unwrap());
+    }
+
+    Ok(())
+}

vendor/polling/tests/other_modes.rs

@@ -0,0 +1,273 @@
+//! Tests for level triggered and edge triggered mode.
+
+#![allow(clippy::unused_io_amount)]
+
+use std::io::{self, prelude::*};
+use std::net::{TcpListener, TcpStream};
+use std::time::Duration;
+
+use polling::{Event, Events, PollMode, Poller};
+
+#[test]
+fn level_triggered() {
+    // Create our streams.
+    let (mut reader, mut writer) = tcp_pair().unwrap();
+    let reader_token = 1;
+
+    // Create our poller and register our streams.
+    let poller = Poller::new().unwrap();
+    if unsafe { poller.add_with_mode(&reader, Event::readable(reader_token), PollMode::Level) }
+        .is_err()
+    {
+        // Only panic if we're on a platform that should support level mode.
+        cfg_if::cfg_if! {
+            if #[cfg(any(target_os = "solaris", target_os = "illumos"))] {
+                return;
+            } else {
+                panic!("Level mode should be supported on this platform");
+            }
+        }
+    }
+
+    // Write some data to the writer.
+    let data = [1, 2, 3, 4, 5];
+    writer.write_all(&data).unwrap();
+
+    // A "readable" notification should be delivered.
+    let mut events = Events::new();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(10)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+
+    // If we read some of the data, the notification should still be available.
+    reader.read_exact(&mut [0; 3]).unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(10)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+
+    // If we read the rest of the data, the notification should be gone.
+    reader.read_exact(&mut [0; 2]).unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(0)))
+        .unwrap();
+
+    assert!(events.is_empty());
+
+    // After modifying the stream and sending more data, it should be oneshot.
+    poller
+        .modify_with_mode(&reader, Event::readable(reader_token), PollMode::Oneshot)
+        .unwrap();
+
+    writer.write(&data).unwrap();
+    events.clear();
+
+    // BUG: Somehow, the notification here is delayed?
+    poller
+        .wait(&mut events, Some(Duration::from_secs(10)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+
+    // After reading, the notification should vanish.
+    reader.read(&mut [0; 5]).unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(0)))
+        .unwrap();
+
+    assert!(events.is_empty());
+}
+
+#[test]
+fn edge_triggered() {
+    // Create our streams.
+    let (mut reader, mut writer) = tcp_pair().unwrap();
+    let reader_token = 1;
+
+    // Create our poller and register our streams.
+    let poller = Poller::new().unwrap();
+    if unsafe { poller.add_with_mode(&reader, Event::readable(reader_token), PollMode::Edge) }
+        .is_err()
+    {
+        // Only panic if we're on a platform that should support level mode.
+        cfg_if::cfg_if! {
+            if #[cfg(all(
+                any(
+                    target_os = "linux",
+                    target_os = "android",
+                    target_vendor = "apple",
+                    target_os = "freebsd",
+                    target_os = "netbsd",
+                    target_os = "openbsd",
+                    target_os = "dragonfly"
+                ),
+                not(polling_test_poll_backend)
+            ))] {
+                panic!("Edge mode should be supported on this platform");
+            } else {
+                return;
+            }
+        }
+    }
+
+    // Write some data to the writer.
+    let data = [1, 2, 3, 4, 5];
+    writer.write_all(&data).unwrap();
+
+    // A "readable" notification should be delivered.
+    let mut events = Events::new();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(10)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+
+    // If we read some of the data, the notification should not still be available.
+    reader.read_exact(&mut [0; 3]).unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(0)))
+        .unwrap();
+    assert!(events.is_empty());
+
+    // If we write more data, a notification should be delivered.
+    writer.write_all(&data).unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(10)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+
+    // After modifying the stream and sending more data, it should be oneshot.
+    poller
+        .modify_with_mode(&reader, Event::readable(reader_token), PollMode::Oneshot)
+        .unwrap();
+
+    writer.write_all(&data).unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(10)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+}
+
+#[test]
+fn edge_oneshot_triggered() {
+    // Create our streams.
+    let (mut reader, mut writer) = tcp_pair().unwrap();
+    let reader_token = 1;
+
+    // Create our poller and register our streams.
+    let poller = Poller::new().unwrap();
+    if unsafe {
+        poller.add_with_mode(
+            &reader,
+            Event::readable(reader_token),
+            PollMode::EdgeOneshot,
+        )
+    }
+    .is_err()
+    {
+        // Only panic if we're on a platform that should support level mode.
+        cfg_if::cfg_if! {
+            if #[cfg(all(
+                any(
+                    target_os = "linux",
+                    target_os = "android",
+                    target_vendor = "apple",
+                    target_os = "freebsd",
+                    target_os = "netbsd",
+                    target_os = "openbsd",
+                    target_os = "dragonfly"
+                ),
+                not(polling_test_poll_backend)
+            ))] {
+                panic!("Edge mode should be supported on this platform");
+            } else {
+                return;
+            }
+        }
+    }
+
+    // Write some data to the writer.
+    let data = [1, 2, 3, 4, 5];
+    writer.write_all(&data).unwrap();
+
+    // A "readable" notification should be delivered.
+    let mut events = Events::new();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(10)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+
+    // If we read some of the data, the notification should not still be available.
+    reader.read_exact(&mut [0; 3]).unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(0)))
+        .unwrap();
+    assert!(events.is_empty());
+
+    // If we modify to re-enable the notification, it should be delivered.
+    poller
+        .modify_with_mode(
+            &reader,
+            Event::readable(reader_token),
+            PollMode::EdgeOneshot,
+        )
+        .unwrap();
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_secs(0)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(reader_token)
+    );
+}
+
+fn tcp_pair() -> io::Result<(TcpStream, TcpStream)> {
+    let listener = TcpListener::bind("127.0.0.1:0")?;
+    let a = TcpStream::connect(listener.local_addr()?)?;
+    let (b, _) = listener.accept()?;
+    Ok((a, b))
+}

vendor/polling/tests/precision.rs

@@ -0,0 +1,72 @@
+use std::io;
+use std::time::{Duration, Instant};
+
+use polling::{Events, Poller};
+
+#[test]
+fn below_ms() -> io::Result<()> {
+    let poller = Poller::new()?;
+    let mut events = Events::new();
+
+    let dur = Duration::from_micros(100);
+    let margin = Duration::from_micros(500);
+    let mut lowest = Duration::from_secs(1000);
+
+    for _ in 0..1_000 {
+        let now = Instant::now();
+        let n = poller.wait(&mut events, Some(dur))?;
+        let elapsed = now.elapsed();
+
+        assert_eq!(n, 0);
+        assert!(elapsed >= dur, "{elapsed:?} < {dur:?}");
+        lowest = lowest.min(elapsed);
+    }
+
+    if cfg!(all(
+        any(
+            target_os = "linux",
+            target_os = "android",
+            target_vendor = "apple",
+            target_os = "freebsd",
+        ),
+        not(polling_test_poll_backend)
+    )) {
+        assert!(lowest < dur + margin);
+    }
+    Ok(())
+}
+
+#[test]
+fn above_ms() -> io::Result<()> {
+    let poller = Poller::new()?;
+    let mut events = Events::new();
+
+    let dur = Duration::from_micros(3_100);
+    let margin = Duration::from_micros(500);
+    let mut lowest = Duration::from_secs(1000);
+
+    for _ in 0..1_000 {
+        let now = Instant::now();
+        let n = poller.wait(&mut events, Some(dur))?;
+        let elapsed = now.elapsed();
+
+        assert_eq!(n, 0);
+        assert!(elapsed >= dur, "{elapsed:?} < {dur:?}");
+        lowest = lowest.min(elapsed);
+    }
+
+    if cfg!(all(
+        any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_vendor = "apple",
+            target_os = "freebsd",
+        ),
+        not(polling_test_poll_backend)
+    )) {
+        assert!(lowest < dur + margin);
+    }
+    Ok(())
+}

vendor/polling/tests/timeout.rs

@@ -0,0 +1,32 @@
+use std::io;
+use std::time::{Duration, Instant};
+
+use polling::{Events, Poller};
+
+#[test]
+fn twice() -> io::Result<()> {
+    let poller = Poller::new()?;
+    let mut events = Events::new();
+
+    for _ in 0..2 {
+        let start = Instant::now();
+        poller.wait(&mut events, Some(Duration::from_secs(1)))?;
+        let elapsed = start.elapsed();
+
+        assert!(elapsed >= Duration::from_secs(1));
+    }
+
+    Ok(())
+}
+
+#[test]
+fn non_blocking() -> io::Result<()> {
+    let poller = Poller::new()?;
+    let mut events = Events::new();
+
+    for _ in 0..100 {
+        poller.wait(&mut events, Some(Duration::from_secs(0)))?;
+    }
+
+    Ok(())
+}

vendor/polling/tests/windows_post.rs

@@ -0,0 +1,64 @@
+//! Tests for the post() function on Windows.
+
+#![cfg(windows)]
+
+use polling::os::iocp::{CompletionPacket, PollerIocpExt};
+use polling::{Event, Events, Poller};
+
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+#[test]
+fn post_smoke() {
+    let poller = Poller::new().unwrap();
+    let mut events = Events::new();
+
+    poller
+        .post(CompletionPacket::new(Event::readable(1)))
+        .unwrap();
+    poller.wait(&mut events, None).unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(
+        events.iter().next().unwrap().with_no_extra(),
+        Event::readable(1)
+    );
+}
+
+#[test]
+fn post_multithread() {
+    let poller = Arc::new(Poller::new().unwrap());
+    let mut events = Events::new();
+
+    thread::spawn({
+        let poller = Arc::clone(&poller);
+        move || {
+            for i in 0..3 {
+                poller
+                    .post(CompletionPacket::new(Event::writable(i)))
+                    .unwrap();
+
+                thread::sleep(Duration::from_millis(100));
+            }
+        }
+    });
+
+    for i in 0..3 {
+        poller
+            .wait(&mut events, Some(Duration::from_secs(5)))
+            .unwrap();
+
+        assert_eq!(events.len(), 1);
+        assert_eq!(
+            events.iter().next().unwrap().with_no_extra(),
+            Event::writable(i)
+        );
+        events.clear();
+    }
+
+    poller
+        .wait(&mut events, Some(Duration::from_millis(10)))
+        .unwrap();
+    assert_eq!(events.len(), 0);
+}

vendor/polling/tests/windows_waitable.rs

@@ -0,0 +1,138 @@
+//! Tests for the waitable polling on Windows.
+
+#![cfg(windows)]
+
+use polling::os::iocp::PollerIocpExt;
+use polling::{Event, Events, PollMode, Poller};
+
+use windows_sys::Win32::Foundation::CloseHandle;
+use windows_sys::Win32::System::Threading::{CreateEventW, ResetEvent, SetEvent};
+
+use std::io;
+use std::os::windows::io::{AsRawHandle, RawHandle};
+use std::os::windows::prelude::{AsHandle, BorrowedHandle};
+use std::time::Duration;
+
+/// A basic wrapper around the Windows event object.
+struct EventHandle(RawHandle);
+
+impl Drop for EventHandle {
+    fn drop(&mut self) {
+        unsafe {
+            CloseHandle(self.0 as _);
+        }
+    }
+}
+
+impl EventHandle {
+    fn new(manual_reset: bool) -> io::Result<Self> {
+        let handle = unsafe {
+            CreateEventW(
+                std::ptr::null_mut(),
+                manual_reset as _,
+                false as _,
+                std::ptr::null(),
+            )
+        };
+
+        if handle.is_null() {
+            Err(io::Error::last_os_error())
+        } else {
+            Ok(Self(handle as _))
+        }
+    }
+
+    /// Reset the event object.
+    fn reset(&self) -> io::Result<()> {
+        if unsafe { ResetEvent(self.0 as _) } != 0 {
+            Ok(())
+        } else {
+            Err(io::Error::last_os_error())
+        }
+    }
+
+    /// Set the event object.
+    fn set(&self) -> io::Result<()> {
+        if unsafe { SetEvent(self.0 as _) } != 0 {
+            Ok(())
+        } else {
+            Err(io::Error::last_os_error())
+        }
+    }
+}
+
+impl AsRawHandle for EventHandle {
+    fn as_raw_handle(&self) -> RawHandle {
+        self.0
+    }
+}
+
+impl AsHandle for EventHandle {
+    fn as_handle(&self) -> BorrowedHandle<'_> {
+        unsafe { BorrowedHandle::borrow_raw(self.0) }
+    }
+}
+
+#[test]
+fn smoke() {
+    let poller = Poller::new().unwrap();
+
+    let event = EventHandle::new(true).unwrap();
+
+    unsafe {
+        poller
+            .add_waitable(&event, Event::all(0), PollMode::Oneshot)
+            .unwrap();
+    }
+
+    let mut events = Events::new();
+    poller
+        .wait(&mut events, Some(Duration::from_millis(100)))
+        .unwrap();
+
+    assert!(events.is_empty());
+
+    // Signal the event.
+    event.set().unwrap();
+
+    poller
+        .wait(&mut events, Some(Duration::from_millis(100)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(events.iter().next().unwrap().with_no_extra(), Event::all(0));
+
+    // Interest should be cleared.
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_millis(100)))
+        .unwrap();
+
+    assert!(events.is_empty());
+
+    // If we modify the waitable, it should be added again.
+    poller
+        .modify_waitable(&event, Event::all(0), PollMode::Oneshot)
+        .unwrap();
+
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_millis(100)))
+        .unwrap();
+
+    assert_eq!(events.len(), 1);
+    assert_eq!(events.iter().next().unwrap().with_no_extra(), Event::all(0));
+
+    // If we reset the event, it should not be signaled.
+    event.reset().unwrap();
+    poller
+        .modify_waitable(&event, Event::all(0), PollMode::Oneshot)
+        .unwrap();
+
+    events.clear();
+    poller
+        .wait(&mut events, Some(Duration::from_millis(100)))
+        .unwrap();
+
+    assert!(events.is_empty());
+}