tokio-utils: add miri test suite

Author: nurmohammed840

tokio-test/macros/src/expend.rs

@@ -56,10 +56,7 @@ pub fn tokio_test(args: TokenStream, item_fn: ItemFn) -> TokenStream {
                 }
             }
         }
-        panic!(
-            "unknown config `{}`",
-            meta.path().to_token_stream().to_string()
-        )
+        panic!("unknown config `{}`", meta.path().to_token_stream())
     });
     let runtime_type = quote(|t| {
         if id_multi_thread {

tokio-util/Cargo.toml

@@ -51,6 +51,7 @@ hashbrown = { version = "0.14.0", default-features = false, optional = true }
 tokio = { version = "1.0.0", path = "../tokio", features = ["full"] }
 tokio-test = { version = "0.4.0", path = "../tokio-test" }
 tokio-stream = { version = "0.1", path = "../tokio-stream" }
+tokio-test-macros = { path = "../tokio-test/macros" }
 
 async-stream = "0.3.0"
 futures = "0.3.0"

tokio-util/src/either.rs

@@ -202,15 +202,16 @@ mod tests {
     use super::*;
     use tokio::io::{repeat, AsyncReadExt, Repeat};
     use tokio_stream::{once, Once, StreamExt};
+    use tokio_test_macros::tokio_test;
 
-    #[tokio::test]
+    #[tokio_test(miri)]
     async fn either_is_stream() {
         let mut either: Either<Once<u32>, Once<u32>> = Either::Left(once(1));
 
         assert_eq!(Some(1u32), either.next().await);
     }
 
-    #[tokio::test]
+    #[tokio_test(miri)]
     async fn either_is_async_read() {
         let mut buffer = [0; 3];
         let mut either: Either<Repeat, Repeat> = Either::Right(repeat(0b101));

tokio-util/tests/abort_on_drop.rs

@@ -1,7 +1,8 @@
 use tokio::sync::oneshot;
+use tokio_test_macros::tokio_test;
 use tokio_util::task::AbortOnDropHandle;
 
-#[tokio::test]
+#[tokio_test]
 async fn aborts_task_on_drop() {
     let (mut tx, rx) = oneshot::channel::<bool>();
     let handle = tokio::spawn(async move {
@@ -13,7 +14,7 @@ async fn aborts_task_on_drop() {
     assert!(tx.is_closed());
 }
 
-#[tokio::test]
+#[tokio_test]
 async fn aborts_task_directly() {
     let (mut tx, rx) = oneshot::channel::<bool>();
     let handle = tokio::spawn(async move {

tokio-util/tests/compat.rs

@@ -6,9 +6,10 @@ use futures_io::SeekFrom;
 use futures_util::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
 use tempfile::NamedTempFile;
 use tokio::fs::OpenOptions;
+use tokio_test_macros::tokio_test;
 use tokio_util::compat::TokioAsyncWriteCompatExt;
 
-#[tokio::test]
+#[tokio_test]
 async fn compat_file_seek() -> futures_util::io::Result<()> {
     let temp_file = NamedTempFile::new()?;
     let mut file = OpenOptions::new()

tokio-util/tests/context.rs

@@ -7,6 +7,7 @@ use tokio::time::*;
 use tokio_util::context::RuntimeExt;
 
 #[test]
+#[cfg_attr(miri, ignore)]
 fn tokio_context_with_another_runtime() {
     let rt1 = Builder::new_multi_thread()
         .worker_threads(1)

tokio-util/tests/framed.rs

@@ -2,6 +2,7 @@
 
 use tokio_stream::StreamExt;
 use tokio_test::assert_ok;
+use tokio_test_macros::tokio_test;
 use tokio_util::codec::{Decoder, Encoder, Framed, FramedParts};
 
 use bytes::{Buf, BufMut, BytesMut};
@@ -97,7 +98,7 @@ impl tokio::io::AsyncRead for DontReadIntoThis {
     }
 }
 
-#[tokio::test]
+#[tokio_test(miri)]
 async fn can_read_from_existing_buf() {
     let mut parts = FramedParts::new(DontReadIntoThis, U32Codec::default());
     parts.read_buf = BytesMut::from(&[0, 0, 0, 42][..]);
@@ -109,7 +110,7 @@ async fn can_read_from_existing_buf() {
     assert_eq!(framed.codec().read_bytes, 4);
 }
 
-#[tokio::test]
+#[tokio_test(miri)]
 async fn can_read_from_existing_buf_after_codec_changed() {
     let mut parts = FramedParts::new(DontReadIntoThis, U32Codec::default());
     parts.read_buf = BytesMut::from(&[0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 84][..]);

tokio-util/tests/framed_stream.rs

@@ -1,4 +1,5 @@
 use futures_core::stream::Stream;
+use tokio_test_macros::tokio_test;
 use std::{io, pin::Pin};
 use tokio_test::{assert_ready, io::Builder, task};
 use tokio_util::codec::{BytesCodec, FramedRead};
@@ -16,7 +17,7 @@ macro_rules! assert_read {
     }};
 }
 
-#[tokio::test]
+#[tokio_test(miri)]
 async fn return_none_after_error() {
     let mut io = FramedRead::new(
         Builder::new()

tokio-util/tests/io_inspect.rs

@@ -5,6 +5,7 @@ use std::{
     task::{Context, Poll},
 };
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
+use tokio_test_macros::tokio_test;
 use tokio_util::io::{InspectReader, InspectWriter};
 
 /// An AsyncRead implementation that works byte-by-byte, to catch out callers
@@ -28,7 +29,7 @@ impl AsyncRead for SmallReader {
     }
 }
 
-#[tokio::test]
+#[tokio_test(miri)]
 async fn read_tee() {
     let contents = b"This could be really long, you know".to_vec();
     let reader = SmallReader {
@@ -110,7 +111,7 @@ impl AsyncWrite for SmallWriter {
     }
 }
 
-#[tokio::test]
+#[tokio_test(miri)]
 async fn write_tee() {
     let mut altout: Vec<u8> = Vec::new();
     let mut writeout = SmallWriter {
@@ -157,7 +158,7 @@ async fn write_all_vectored<W: AsyncWrite + Unpin>(
     Ok(res)
 }
 
-#[tokio::test]
+#[tokio_test(miri)]
 async fn write_tee_vectored() {
     let mut altout: Vec<u8> = Vec::new();
     let mut writeout = SmallWriter {

tokio-util/tests/io_reader_stream.rs

@@ -4,6 +4,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, ReadBuf};
 use tokio_stream::StreamExt;
+use tokio_test_macros::tokio_test;
 
 /// produces at most `remaining` zeros, that returns error.
 /// each time it reads at most 31 byte.
@@ -34,7 +35,7 @@ impl AsyncRead for Reader {
     }
 }
 
-#[tokio::test]
+#[tokio_test] // Too slow on miri
 async fn correct_behavior_on_errors() {
     let reader = Reader { remaining: 8000 };
     let mut stream = tokio_util::io::ReaderStream::new(reader);