#136: fix typo

rstest/src/timeout.rs

@@ -11,7 +11,7 @@ pub fn execute_with_timeout_sync<T: 'static + Send, F: Fn() -> T + Send + 'stati
     std::thread::spawn(move || sender.send(code()));
     receiver
         .recv_timeout(timeout)
-        .unwrap_or_else(|_| panic!("Timeout {:?} Expired", timeout))
+        .unwrap_or_else(|_| panic!("Timeout {:?} expired", timeout))
 }
 
 pub async fn execute_with_timeout_async<T, Fut: Future<Output = T>, F: Fn() -> Fut>(
@@ -52,16 +52,18 @@ mod tests {
             async fn should_fail() {
                 execute_with_timeout_async(
                     || test(Duration::from_millis(20)),
-                    Duration::from_millis(10)
-                ).await
+                    Duration::from_millis(10),
+                )
+                .await
             }
 
             #[async_std::test]
             async fn should_pass() {
                 execute_with_timeout_async(
                     || test(Duration::from_millis(10)),
-                    Duration::from_millis(20)
-                ).await
+                    Duration::from_millis(20),
+                )
+                .await
             }
         }
 
@@ -73,16 +75,18 @@ mod tests {
             async fn should_fail() {
                 execute_with_timeout_async(
                     || test(Duration::from_millis(20)),
-                    Duration::from_millis(10)
-                ).await
+                    Duration::from_millis(10),
+                )
+                .await
             }
 
             #[tokio::test]
             async fn should_pass() {
                 execute_with_timeout_async(
                     || test(Duration::from_millis(10)),
-                    Duration::from_millis(20)
-                ).await
+                    Duration::from_millis(20),
+                )
+                .await
             }
         }
     }

rstest/tests/resources/rstest/timeout.rs

@@ -0,0 +1,130 @@
+use rstest::*;
+use std::time::Duration;
+
+fn ms(ms: u32) -> Duration {
+    Duration::from_millis(ms)
+}
+
+mod thread {
+    use super::*;
+
+    fn delayed_sum(a: u32, b: u32, delay: Duration) -> u32 {
+        std::thread::sleep(delay);
+        a + b
+    }
+
+    #[rstest]
+    #[timeout(ms(80))]
+    #[case(ms(10))]
+    fn one_pass(#[case] delay: Duration) {
+        assert_eq!(4, delayed_sum(2, 2, delay));
+    }
+
+    #[rstest]
+    #[timeout(ms(10))]
+    #[case(ms(80))]
+    fn one_fail_timeout(#[case] delay: Duration) {
+        assert_eq!(4, delayed_sum(2, 2, delay));
+    }
+
+    #[rstest]
+    #[timeout(ms(100))]
+    #[case(ms(1))]
+    fn one_fail_value(#[case] delay: Duration) {
+        assert_eq!(5, delayed_sum(2, 2, delay));
+    }
+
+    #[rstest]
+    #[case::pass(ms(1), 4)]
+    #[case::fail_timeout(ms(80), 4)]
+    #[case::fail_value(ms(1), 5)]
+    #[timeout(ms(40))]
+    fn group_same_timeout(#[case] delay: Duration, expected: u32) {
+        assert_eq!(expected, delayed_sum(2, 2, delay));
+    }
+
+    #[rstest]
+    #[timeout(ms(100))]
+    #[case::pass(ms(1), 4)]
+    #[timeout(ms(30))]
+    #[case::fail_timeout(ms(70), 4)]
+    #[timeout(ms(100))]
+    #[case::fail_value(ms(1), 5)]
+    fn group_single_timeout(#[case] delay: Duration, expected: u32) {
+        assert_eq!(expected, delayed_sum(2, 2, delay));
+    }
+
+    #[rstest]
+    #[case::pass(ms(1), 4)]
+    #[timeout(ms(10))]
+    #[case::fail_timeout(ms(60), 4)]
+    #[case::fail_value(ms(1), 5)]
+    #[timeout(ms(100))]
+    fn group_one_timeout_override(#[case] delay: Duration, expected: u32) {
+        assert_eq!(expected, delayed_sum(2, 2, delay));
+    }
+}
+
+mod async_cases {
+    use super::*;
+
+    mod async_std {
+        use super::*;
+
+        async fn delayed_sum(a: u32, b: u32, delay: Duration) -> u32 {
+            async_std::task::sleep(delay).await;
+            a + b
+        }
+
+        #[rstest]
+        #[timeout(ms(80))]
+        #[case(ms(10))]
+        async fn one_pass(#[case] delay: Duration) {
+            assert_eq!(4, delayed_sum(2, 2, delay).await);
+        }
+
+        #[rstest]
+        #[timeout(ms(10))]
+        #[case(ms(80))]
+        async fn one_fail_timeout(#[case] delay: Duration) {
+            assert_eq!(4, delayed_sum(2, 2, delay).await);
+        }
+
+        #[rstest]
+        #[timeout(ms(100))]
+        #[case(ms(1))]
+        async fn one_fail_value(#[case] delay: Duration) {
+            assert_eq!(5, delayed_sum(2, 2, delay).await);
+        }
+
+        #[rstest]
+        #[case::pass(ms(1), 4)]
+        #[case::fail_timeout(ms(80), 4)]
+        #[case::fail_value(ms(1), 5)]
+        #[timeout(ms(40))]
+        async fn group_same_timeout(#[case] delay: Duration, expected: u32) {
+            assert_eq!(expected, delayed_sum(2, 2, delay).await);
+        }
+
+        #[rstest]
+        #[timeout(ms(100))]
+        #[case::pass(ms(1), 4)]
+        #[timeout(ms(30))]
+        #[case::fail_timeout(ms(70), 4)]
+        #[timeout(ms(100))]
+        #[case::fail_value(ms(1), 5)]
+        async fn group_single_timeout(#[case] delay: Duration, expected: u32) {
+            assert_eq!(expected, delayed_sum(2, 2, delay).await);
+        }
+
+        #[rstest]
+        #[case::pass(ms(1), 4)]
+        #[timeout(ms(10))]
+        #[case::fail_timeout(ms(60), 4)]
+        #[case::fail_value(ms(1), 5)]
+        #[timeout(ms(100))]
+        async fn group_one_timeout_override(#[case] delay: Duration, expected: u32) {
+            assert_eq!(expected, delayed_sum(2, 2, delay).await);
+        }
+    }
+}