tawasuyu/taffy

* Add rstest as test dependency

* Change rstest to be a dev dependency

* Add tests for MaybeMath with LHS Option<f32> and RHS Option<f32>

* Add tests for MaybeMath with LHS Option<f32> and RHS f32

* Add tests for MaybeMath with LHS f32 and RHS Option<f32>

* Import std for tests when the std feature is disabled

diff --git a/Cargo.toml b/Cargo.toml
index 7faadc303..744ad6fcc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,6 +30,7 @@ serde = ["dep:serde"]
 
 [dev-dependencies]
 criterion = "0.3"
+rstest = "0.13.0"
 
 [profile.release]
 lto = true
diff --git a/src/lib.rs b/src/lib.rs
index ba8e64eec..46bc39bdc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,12 @@
 #![warn(missing_docs)]
 #![warn(clippy::missing_docs_in_private_items)]
 
+// We always need std for the tests
+// See <https://github.com/la10736/rstest/issues/149#issuecomment-1156402989>
+#[cfg(all(test, not(feature = "std")))]
+#[macro_use]
+extern crate std;
+
 #[cfg(all(not(feature = "std"), feature = "alloc"))]
 extern crate alloc;
 
diff --git a/src/math.rs b/src/math.rs
index 06920daa5..687192bba 100644
--- a/src/math.rs
+++ b/src/math.rs
@@ -121,3 +121,128 @@ impl MaybeMath<Option<f32>, f32> for f32 {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    mod lhs_option_f32_rhs_option_f32 {
+
+        use crate::math::MaybeMath;
+        use rstest::rstest;
+
+        #[rstest]
+        #[case(Some(3.0), Some(5.0), Some(3.0))]
+        #[case(Some(5.0), Some(3.0), Some(3.0))]
+        #[case(Some(3.0), None, Some(3.0))]
+        #[case(None, Some(3.0), None)]
+        #[case(None, None, None)]
+        fn test_maybe_min(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_min(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(Some(3.0), Some(5.0), Some(5.0))]
+        #[case(Some(5.0), Some(3.0), Some(5.0))]
+        #[case(Some(3.0), None, Some(3.0))]
+        #[case(None, Some(3.0), None)]
+        #[case(None, None, None)]
+        fn test_maybe_max(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_max(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(Some(3.0), Some(5.0), Some(8.0))]
+        #[case(Some(5.0), Some(3.0), Some(8.0))]
+        #[case(Some(3.0), None, Some(3.0))]
+        #[case(None, Some(3.0), None)]
+        #[case(None, None, None)]
+        fn test_maybe_add(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_add(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(Some(3.0), Some(5.0), Some(-2.0))]
+        #[case(Some(5.0), Some(3.0), Some(2.0))]
+        #[case(Some(3.0), None, Some(3.0))]
+        #[case(None, Some(3.0), None)]
+        #[case(None, None, None)]
+        fn test_maybe_sub(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_sub(rhs), expected);
+        }
+    }
+
+    mod lhs_option_f32_rhs_f32 {
+
+        use crate::math::MaybeMath;
+        use rstest::rstest;
+
+        #[rstest]
+        #[case(Some(3.0), 5.0, Some(3.0))]
+        #[case(Some(5.0), 3.0, Some(3.0))]
+        #[case(None, 3.0, None)]
+        fn test_maybe_min(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_min(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(Some(3.0), 5.0, Some(5.0))]
+        #[case(Some(5.0), 3.0, Some(5.0))]
+        #[case(None, 3.0, None)]
+        fn test_maybe_max(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_max(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(Some(3.0), 5.0, Some(8.0))]
+        #[case(Some(5.0), 3.0, Some(8.0))]
+        #[case(None, 3.0, None)]
+        fn test_maybe_add(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_add(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(Some(3.0), 5.0, Some(-2.0))]
+        #[case(Some(5.0), 3.0, Some(2.0))]
+        #[case(None, 3.0, None)]
+        fn test_maybe_sub(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
+            assert_eq!(lhs.maybe_sub(rhs), expected);
+        }
+    }
+
+    mod lhs_f32_rhs_option_f32 {
+
+        use crate::math::MaybeMath;
+        use rstest::rstest;
+
+        #[rstest]
+        #[case(3.0, Some(5.0), 3.0)]
+        #[case(5.0, Some(3.0), 3.0)]
+        #[case(3.0, None, 3.0)]
+        fn test_maybe_min(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
+            assert_eq!(lhs.maybe_min(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(3.0, Some(5.0), 5.0)]
+        #[case(5.0, Some(3.0), 5.0)]
+        #[case(3.0, None, 3.0)]
+        fn test_maybe_max(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
+            assert_eq!(lhs.maybe_max(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(3.0, Some(5.0), 8.0)]
+        #[case(5.0, Some(3.0), 8.0)]
+        #[case(3.0, None, 3.0)]
+        fn test_maybe_add(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
+            assert_eq!(lhs.maybe_add(rhs), expected);
+        }
+
+        #[rstest]
+        #[case(3.0, Some(5.0), -2.0)]
+        #[case(5.0, Some(3.0), 2.0)]
+        #[case(3.0, None, 3.0)]
+        fn test_maybe_sub(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
+            assert_eq!(lhs.maybe_sub(rhs), expected);
+        }
+    }
+}