diff --git a/tests/async_io.rs b/tests/async_io.rs deleted file mode 100644 index 88fe96a..0000000 --- a/tests/async_io.rs +++ /dev/null @@ -1,332 +0,0 @@ -use std::future::Future; -use std::io; -use std::net::{Shutdown, TcpListener, TcpStream, UdpSocket}; -#[cfg(unix)] -use std::os::unix::net::{UnixDatagram, UnixListener, UnixStream}; -use std::sync::Arc; -use std::time::Duration; - -use futures::{AsyncReadExt, AsyncWriteExt, StreamExt}; -use smol::{Async, Task, Timer}; -#[cfg(unix)] -use tempfile::tempdir; - -const LOREM_IPSUM: &[u8] = b" -Lorem ipsum dolor sit amet, consectetur adipiscing elit. -Donec pretium ante erat, vitae sodales mi varius quis. -Etiam vestibulum lorem vel urna tempor, eu fermentum odio aliquam. -Aliquam consequat urna vitae ipsum pulvinar, in blandit purus eleifend. -"; - -/// Runs future inside a local task. -/// -/// The main future passed to `smol::run()` is sometimes polled even if it was not woken - e.g. -/// this can happen when the executor is waiting on the reactor and then wakes up for whatever -/// reason. -fn run(future: impl Future + 'static) -> T { - smol::run(async { Task::local(async { future.await }).await }) -} - -#[test] -fn tcp_connect() -> io::Result<()> { - run(async { - let listener = Async::::bind("127.0.0.1:0")?; - let addr = listener.get_ref().local_addr()?; - let task = Task::local(async move { listener.accept().await }); - - let stream2 = Async::::connect(&addr).await?; - let stream1 = task.await?.0; - - assert_eq!( - stream1.get_ref().peer_addr()?, - stream2.get_ref().local_addr()?, - ); - assert_eq!( - stream2.get_ref().peer_addr()?, - stream1.get_ref().local_addr()?, - ); - - // Now that the listener is closed, connect should fail. - let err = Async::::connect(&addr).await.unwrap_err(); - assert_eq!(err.kind(), io::ErrorKind::ConnectionRefused); - - Ok(()) - }) -} - -#[test] -fn tcp_peek_read() -> io::Result<()> { - run(async { - let listener = Async::::bind("127.0.0.1:0")?; - let addr = listener.get_ref().local_addr()?; - - let mut stream = Async::::connect(addr).await?; - stream.write_all(LOREM_IPSUM).await?; - - let mut buf = [0; 1024]; - let mut incoming = listener.incoming(); - let mut stream = incoming.next().await.unwrap()?; - - let n = stream.peek(&mut buf).await?; - assert_eq!(&buf[..n], LOREM_IPSUM); - let n = stream.read(&mut buf).await?; - assert_eq!(&buf[..n], LOREM_IPSUM); - - Ok(()) - }) -} - -#[test] -fn tcp_reader_hangup() -> io::Result<()> { - run(async { - let listener = Async::::bind("127.0.0.1:0")?; - let addr = listener.get_ref().local_addr()?; - let task = Task::local(async move { listener.accept().await }); - - let mut stream2 = Async::::connect(&addr).await?; - let stream1 = task.await?.0; - - let task = Task::local(async move { - Timer::after(Duration::from_secs(1)).await; - drop(stream1); - }); - - while stream2.write_all(LOREM_IPSUM).await.is_ok() {} - task.await; - - Ok(()) - }) -} - -#[test] -fn tcp_writer_hangup() -> io::Result<()> { - run(async { - let listener = Async::::bind("127.0.0.1:0")?; - let addr = listener.get_ref().local_addr()?; - let task = Task::local(async move { listener.accept().await }); - - let mut stream2 = Async::::connect(&addr).await?; - let stream1 = task.await?.0; - - let task = Task::local(async move { - Timer::after(Duration::from_secs(1)).await; - drop(stream1); - }); - - let mut v = vec![]; - stream2.read_to_end(&mut v).await?; - assert!(v.is_empty()); - - task.await; - Ok(()) - }) -} - -#[test] -fn udp_send_recv() -> io::Result<()> { - run(async { - let socket1 = Async::::bind("127.0.0.1:0")?; - let socket2 = Async::::bind("127.0.0.1:0")?; - socket1.get_ref().connect(socket2.get_ref().local_addr()?)?; - - let mut buf = [0u8; 1024]; - - socket1.send(LOREM_IPSUM).await?; - let n = socket2.peek(&mut buf).await?; - assert_eq!(&buf[..n], LOREM_IPSUM); - let n = socket2.recv(&mut buf).await?; - assert_eq!(&buf[..n], LOREM_IPSUM); - - socket2 - .send_to(LOREM_IPSUM, socket1.get_ref().local_addr()?) - .await?; - let n = socket1.peek_from(&mut buf).await?.0; - assert_eq!(&buf[..n], LOREM_IPSUM); - let n = socket1.recv_from(&mut buf).await?.0; - assert_eq!(&buf[..n], LOREM_IPSUM); - - Ok(()) - }) -} - -#[cfg(unix)] -#[test] -fn udp_connect() -> io::Result<()> { - run(async { - let dir = tempdir()?; - let path = dir.path().join("socket"); - - let listener = Async::::bind(&path)?; - - let mut stream = Async::::connect(&path).await?; - stream.write_all(LOREM_IPSUM).await?; - - let mut buf = [0; 1024]; - let mut incoming = listener.incoming(); - let mut stream = incoming.next().await.unwrap()?; - - let n = stream.read(&mut buf).await?; - assert_eq!(&buf[..n], LOREM_IPSUM); - - Ok(()) - }) -} - -#[cfg(unix)] -#[test] -fn uds_connect() -> io::Result<()> { - run(async { - let dir = tempdir()?; - let path = dir.path().join("socket"); - let listener = Async::::bind(&path)?; - - let addr = listener.get_ref().local_addr()?; - let task = Task::local(async move { listener.accept().await }); - - let stream2 = Async::::connect(addr.as_pathname().unwrap()).await?; - let stream1 = task.await?.0; - - assert_eq!( - stream1.get_ref().peer_addr()?.as_pathname(), - stream2.get_ref().local_addr()?.as_pathname(), - ); - assert_eq!( - stream2.get_ref().peer_addr()?.as_pathname(), - stream1.get_ref().local_addr()?.as_pathname(), - ); - - // Now that the listener is closed, connect should fail. - let err = Async::::connect(addr.as_pathname().unwrap()) - .await - .unwrap_err(); - assert_eq!(err.kind(), io::ErrorKind::ConnectionRefused); - - Ok(()) - }) -} - -#[cfg(unix)] -#[test] -fn uds_send_recv() -> io::Result<()> { - run(async { - let (socket1, socket2) = Async::::pair()?; - - socket1.send(LOREM_IPSUM).await?; - let mut buf = [0; 1024]; - let n = socket2.recv(&mut buf).await?; - assert_eq!(&buf[..n], LOREM_IPSUM); - - Ok(()) - }) -} - -#[cfg(unix)] -#[test] -fn uds_send_to_recv_from() -> io::Result<()> { - run(async { - let dir = tempdir()?; - let path = dir.path().join("socket"); - let socket1 = Async::::bind(&path)?; - let socket2 = Async::::unbound()?; - - socket2.send_to(LOREM_IPSUM, &path).await?; - let mut buf = [0; 1024]; - let n = socket1.recv_from(&mut buf).await?.0; - assert_eq!(&buf[..n], LOREM_IPSUM); - - Ok(()) - }) -} - -#[cfg(unix)] -#[test] -fn uds_reader_hangup() -> io::Result<()> { - run(async { - let (socket1, mut socket2) = Async::::pair()?; - - let task = Task::local(async move { - Timer::after(Duration::from_secs(1)).await; - drop(socket1); - }); - - while socket2.write_all(LOREM_IPSUM).await.is_ok() {} - task.await; - - Ok(()) - }) -} - -#[cfg(unix)] -#[test] -fn uds_writer_hangup() -> io::Result<()> { - run(async { - let (socket1, mut socket2) = Async::::pair()?; - - let task = Task::local(async move { - Timer::after(Duration::from_secs(1)).await; - drop(socket1); - }); - - let mut v = vec![]; - socket2.read_to_end(&mut v).await?; - assert!(v.is_empty()); - - task.await; - Ok(()) - }) -} - -// Test that we correctly re-register interests when we are previously -// interested in both readable and writable events and then we get only one of -// them. (we need to re-register interest on the other.) -#[test] -fn tcp_duplex() -> io::Result<()> { - run(async { - let listener = Async::::bind("127.0.0.1:0")?; - let stream0 = - Arc::new(Async::::connect(listener.get_ref().local_addr()?).await?); - let stream1 = Arc::new(listener.accept().await?.0); - - async fn do_read(s: Arc>) -> io::Result<()> { - let mut buf = vec![0u8; 4096]; - loop { - let len = (&*s).read(&mut buf).await?; - if len == 0 { - return Ok(()); - } - } - } - - async fn do_write(s: Arc>) -> io::Result<()> { - let buf = vec![0u8; 4096]; - for _ in 0..4096 { - (&*s).write_all(&buf).await?; - } - s.get_ref().shutdown(Shutdown::Write)?; - Ok(()) - } - - // Read from and write to stream0. - let r0 = Task::local(do_read(stream0.clone())); - let w0 = Task::local(do_write(stream0)); - - // Sleep a bit, so that reading and writing are both blocked. - smol::Timer::after(Duration::from_millis(5)).await; - - // Start reading stream1, make stream0 writable. - let r1 = Task::local(do_read(stream1.clone())); - - // Finish writing to stream0. - w0.await?; - r1.await?; - - // Start writing to stream1, make stream0 readable. - let w1 = Task::local(do_write(stream1)); - - // Will r0 be correctly woken? - r0.await?; - w1.await?; - - Ok(()) - }) -} diff --git a/tests/block_on.rs b/tests/block_on.rs deleted file mode 100644 index 8ceab27..0000000 --- a/tests/block_on.rs +++ /dev/null @@ -1,37 +0,0 @@ -use futures_util::future; - -#[test] -fn smoke() { - std::thread::spawn(|| { - smol::run(future::pending::<()>()); - }); - let res = smol::block_on(async { 1 + 2 }); - assert_eq!(res, 3); -} - -#[test] -#[should_panic = "boom"] -fn panic() { - std::thread::spawn(|| { - smol::run(future::pending::<()>()); - }); - smol::block_on(async { - // This panic should get propagated into the parent thread. - panic!("boom"); - }); -} - -#[test] -fn nested_block_on() { - std::thread::spawn(|| { - smol::run(future::pending::<()>()); - }); - - let x = smol::block_on(async { - let a = smol::block_on(async { smol::block_on(async { future::ready(3).await }) }); - let b = smol::block_on(async { smol::block_on(async { future::ready(2).await }) }); - a + b - }); - - assert_eq!(x, 3 + 2); -} diff --git a/tests/task.rs b/tests/task.rs deleted file mode 100644 index e46cc63..0000000 --- a/tests/task.rs +++ /dev/null @@ -1,23 +0,0 @@ -#[test] -fn spawn() { - assert_eq!(42, smol::run(smol::Task::spawn(async { 42 }))); -} - -#[test] -fn spawn_detach() { - let (s, r) = piper::chan(1); - smol::Task::spawn(async move { s.send(()).await }).detach(); - assert_eq!(Some(()), smol::run(r.recv())); -} - -#[test] -fn blocking() { - assert_eq!(42, smol::run(smol::Task::blocking(async { 42 }))); -} - -#[test] -fn blocking_detach() { - let (s, r) = piper::chan(1); - smol::Task::blocking(async move { s.send(()).await }).detach(); - assert_eq!(Some(()), smol::run(r.recv())); -} diff --git a/tests/timer.rs b/tests/timer.rs deleted file mode 100644 index f202b40..0000000 --- a/tests/timer.rs +++ /dev/null @@ -1,25 +0,0 @@ -use smol::{self, Timer}; -use std::time::{Duration, Instant}; - -#[test] -fn timer_at() { - let before = smol::run(async { - let now = Instant::now(); - let when = now + Duration::from_secs(1); - Timer::at(when).await; - now - }); - - assert!(before.elapsed() >= Duration::from_secs(1)); -} - -#[test] -fn timer_after() { - let before = smol::run(async { - let now = Instant::now(); - Timer::after(Duration::from_secs(1)).await; - now - }); - - assert!(before.elapsed() >= Duration::from_secs(1)); -}