Rewrite test to remove outdated dependencies

Author: Expyron

Cargo.toml

@@ -27,8 +27,6 @@ schannel = "0.1.13"
 windows-sys = { version = "0.59", features = ["Win32_Foundation", "Win32_System_LibraryLoader", "Win32_Security_Cryptography"] }
 
 [dev-dependencies]
-mio = "0.6"
-mio-extras = "2.0.3"
 anyhow = "1.0.31"
 
 [workspace]

tests/multi.rs

@@ -2,6 +2,7 @@
 
 use std::collections::HashMap;
 use std::io::{Cursor, Read};
+use std::sync::mpsc::TryRecvError;
 use std::time::Duration;
 
 use curl::easy::{Easy, List};
@@ -95,8 +96,7 @@ fn upload_lots() {
     }
 
     let mut m = Multi::new();
-    let poll = t!(mio::Poll::new());
-    let (tx, rx) = mio_extras::channel::channel();
+    let (tx, rx) = std::sync::mpsc::channel();
     let tx2 = tx.clone();
     t!(m.socket_function(move |socket, events, token| {
         t!(tx2.send(Message::Wait(socket, events, token)));
@@ -136,84 +136,55 @@ fn upload_lots() {
     t!(h.upload(true));
     t!(h.http_headers(list));
 
-    t!(poll.register(&rx, mio::Token(0), mio::Ready::all(), mio::PollOpt::level()));
-
     let e = t!(m.add(h));
 
     let mut next_token = 1;
     let mut token_map = HashMap::new();
     let mut cur_timeout = None;
-    let mut events = mio::Events::with_capacity(128);
-    let mut running = true;
-
-    while running {
-        let n = t!(poll.poll(&mut events, cur_timeout));
 
-        if n == 0 && t!(m.timeout()) == 0 {
-            running = false;
+    loop {
+        match cur_timeout {
+            Some(cur_timeout) => std::thread::sleep(cur_timeout),
+            None => {}
         }
 
-        for event in events.iter() {
-            while event.token() == mio::Token(0) {
-                match rx.try_recv() {
-                    Ok(Message::Timeout(dur)) => cur_timeout = dur,
-                    Ok(Message::Wait(socket, events, token)) => {
-                        let evented = mio::unix::EventedFd(&socket);
-                        if events.remove() {
-                            token_map.remove(&token).unwrap();
-                        } else {
-                            let mut e = mio::Ready::empty();
-                            if events.input() {
-                                e |= mio::Ready::readable();
-                            }
-                            if events.output() {
-                                e |= mio::Ready::writable();
-                            }
-                            if token == 0 {
-                                let token = next_token;
-                                next_token += 1;
-                                t!(m.assign(socket, token));
-                                token_map.insert(token, socket);
-                                t!(poll.register(
-                                    &evented,
-                                    mio::Token(token),
-                                    e,
-                                    mio::PollOpt::level()
-                                ));
-                            } else {
-                                t!(poll.reregister(
-                                    &evented,
-                                    mio::Token(token),
-                                    e,
-                                    mio::PollOpt::level()
-                                ));
-                            }
-                        }
+        t!(m.timeout());
+
+        let message = rx.try_recv();
+
+        match message {
+            Ok(Message::Timeout(dur)) => cur_timeout = dur,
+            Ok(Message::Wait(socket, events, token)) => {
+                if events.remove() {
+                    token_map.remove(&token);
+                } else {
+                    if token == 0 {
+                        let token = next_token;
+                        next_token += 1;
+                        t!(m.assign(socket, token));
+                        token_map.insert(token, socket);
                     }
-                    Err(_) => break,
                 }
-            }
 
-            if event.token() == mio::Token(0) {
-                continue;
-            }
+                let mut e = Events::new();
+                if events.input() {
+                    e.input(true);
+                }
+                if events.output() {
+                    e.output(true);
+                }
+                let remaining = t!(m.action(socket, &e));
 
-            let token = event.token();
-            let socket = token_map[&token.into()];
-            let mut e = Events::new();
-            if event.readiness().is_readable() {
-                e.input(true);
-            }
-            if event.readiness().is_writable() {
-                e.output(true);
-            }
-            if mio::unix::UnixReady::from(event.readiness()).is_error() {
-                e.error(true);
+                if remaining == 0 {
+                    break;
+                }
             }
-            let remaining = t!(m.action(socket, &e));
-            if remaining == 0 {
-                running = false;
+            Err(TryRecvError::Empty) => {
+                for socket in token_map.values().copied() {
+                    t!(m.action(socket, &Events::new()));
+                }
             }
+            Err(TryRecvError::Disconnected) => break,
         }
     }