refactor: create submodules for tests

src/nodes/eval.rs

@@ -192,32 +192,34 @@ impl Function {
 }
 
 #[cfg(test)]
-use super::PREC;
+mod tests {
-#[cfg(test)]
+    use super::super::PREC;
-use std::assert_matches;
+    use super::*;
+    use std::assert_matches;
 
-#[test]
+    #[test]
-fn test() {
+    fn basic() {
-    assert_eq!(
+        assert_eq!(
-        Nodes(vec![
+            Nodes(vec![
-            Node::Function(Function::Sine),
+                Node::Function(Function::Sine),
-            Node::ParenthesisStart,
+                Node::ParenthesisStart,
-            Node::Number(Float::with_val(PREC, 2)),
+                Node::Number(Float::with_val(PREC, 2)),
-            Node::ParenthesisEnd,
+                Node::ParenthesisEnd,
-            Node::Operator(Operator::Plus),
+                Node::Operator(Operator::Plus),
-            Node::Number(Float::with_val(PREC, 1))
+                Node::Number(Float::with_val(PREC, 1))
-        ])
+            ])
-        .evaluate()
+            .evaluate()
-        .unwrap()
+            .unwrap()
-        .to_f64(),
+            .to_f64(),
-        1.9092974268256817,
+            1.9092974268256817,
-    );
+        );
-}
+    }
 
-#[test]
+    #[test]
-fn test_zerosized() {
+    fn zerosized() {
-    assert_matches!(
+        assert_matches!(
-        Nodes(vec![Node::ParenthesisStart, Node::ParenthesisEnd]).evaluate(),
+            Nodes(vec![Node::ParenthesisStart, Node::ParenthesisEnd]).evaluate(),
-        Err(Error::CollapseFailed(Nodes(v))) if v.is_empty()
+            Err(Error::CollapseFailed(Nodes(v))) if v.is_empty()
-    )
+        )
+    }
 }

src/nodes/parse.rs

@@ -195,43 +195,49 @@ impl FromStr for Nodes {
     }
 }
 
-#[test]
+#[cfg(test)]
-fn test() {
+mod tests {
-    assert_eq!(
+    use super::*;
-        Nodes::from_str("sin(2) + 1").unwrap().as_ref(),
+
-        &[
+    #[test]
-            Node::Function(Function::Sine),
+    fn basic() {
-            Node::ParenthesisStart,
+        assert_eq!(
-            Node::from(2),
+            Nodes::from_str("sin(2) + 1").unwrap().as_ref(),
-            Node::ParenthesisEnd,
+            &[
-            Node::Operator(Operator::Plus),
+                Node::Function(Function::Sine),
-            Node::from(1),
+                Node::ParenthesisStart,
-        ],
+                Node::from(2),
-    )
+                Node::ParenthesisEnd,
-}
+                Node::Operator(Operator::Plus),
-#[test]
+                Node::from(1),
-fn test_e() {
+            ],
-    assert_eq!(
+        )
-        Nodes::from_str("5e * 5").unwrap().as_ref(),
+    }
-        &[
+
-            Node::from(5),
+    #[test]
-            Node::Operator(Operator::Mult),
+    fn e_constant() {
-            Node::from(f64::consts::E),
+        assert_eq!(
-            Node::Operator(Operator::Mult),
+            Nodes::from_str("5e * 5").unwrap().as_ref(),
-            Node::from(5),
+            &[
-        ],
+                Node::from(5),
-    )
+                Node::Operator(Operator::Mult),
-}
+                Node::from(f64::consts::E),
-#[test]
+                Node::Operator(Operator::Mult),
-fn test_unary_op() {
+                Node::from(5),
-    assert_eq!(
+            ],
-        Nodes::from_str("5(-5)").unwrap().as_ref(),
+        )
-        &[
+    }
-            Node::from(5),
+    #[test]
-            Node::Operator(Operator::Mult),
+    fn unary_op() {
-            Node::ParenthesisStart,
+        assert_eq!(
-            Node::from(-5),
+            Nodes::from_str("5(-5)").unwrap().as_ref(),
-            Node::ParenthesisEnd,
+            &[
-        ],
+                Node::from(5),
-    )
+                Node::Operator(Operator::Mult),
+                Node::ParenthesisStart,
+                Node::from(-5),
+                Node::ParenthesisEnd,
+            ],
+        )
+    }
 }