refactor: create submodules for tests

src/nodes/eval.rs

@@ -28,8 +28,8 @@ impl Nodes {
         let len = nodes.len();
         collapse_toplevel(nodes, len)?;
 
-        match nodes.pop().unwrap() {
-            Node::Number(n) => Ok(n),
+        match nodes.pop() {
+            Some(Node::Number(n)) => Ok(n),
             _ => Err(Error::CollapseFailed(self)),
         }
     }
@@ -41,7 +41,7 @@ fn collapse_toplevel(nodes: &mut Vec<Node>, mut end: usize) -> Result<(), Error>
         .rposition(|n| *n == Node::ParenthesisStart)
         .unwrap_or(0);
 
-    while let Some((index, variant)) = nodes[start..end]
+    while let Some((index, function)) = nodes[start..end]
         .iter()
         .enumerate()
         .filter_map(|(i, n)| match n {
@@ -58,20 +58,7 @@ fn collapse_toplevel(nodes: &mut Vec<Node>, mut end: usize) -> Result<(), Error>
             return Err(Error::MissingArgument(node.clone()));
         };
 
-        match variant {
-            Function::Sqrt => n.sqrt_mut(),
-
-            Function::Ln => n.ln_mut(),
-
-            Function::Sine => n.sin_mut(),
-            Function::ArcSine => n.asin_mut(),
-            Function::Cosine => n.cos_mut(),
-            Function::ArcCosine => n.acos_mut(),
-            Function::Tangent => n.tan_mut(),
-            Function::ArcTangent => n.atan_mut(),
-            Function::Secant => n.sec_mut(),
-            Function::CoSecant => n.csc_mut(),
-        };
+        function.for_float()(n);
 
         nodes.remove(start + index);
         end -= 1;
@@ -185,11 +172,33 @@ fn collapse_toplevel(nodes: &mut Vec<Node>, mut end: usize) -> Result<(), Error>
     Ok(())
 }
 
-#[cfg(test)]
-use super::PREC;
+impl Function {
+    fn for_float(&self) -> impl FnMut(&mut Float) {
+        match self {
+            Function::Sqrt => Float::sqrt_mut,
 
-#[test]
-fn test() {
+            Function::Ln => Float::ln_mut,
+
+            Function::Sine => Float::sin_mut,
+            Function::ArcSine => Float::asin_mut,
+            Function::Cosine => Float::cos_mut,
+            Function::ArcCosine => Float::acos_mut,
+            Function::Tangent => Float::tan_mut,
+            Function::ArcTangent => Float::atan_mut,
+            Function::Secant => Float::sec_mut,
+            Function::CoSecant => Float::csc_mut,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::PREC;
+    use super::*;
+    use std::assert_matches;
+
+    #[test]
+    fn basic() {
         assert_eq!(
             Nodes(vec![
                 Node::Function(Function::Sine),
@@ -204,4 +213,13 @@ fn test() {
             .to_f64(),
             1.9092974268256817,
         );
+    }
+
+    #[test]
+    fn zerosized() {
+        assert_matches!(
+            Nodes(vec![Node::ParenthesisStart, Node::ParenthesisEnd]).evaluate(),
+            Err(Error::CollapseFailed(Nodes(v))) if v.is_empty()
+        )
+    }
 }

src/nodes/parse.rs

@@ -195,8 +195,12 @@ impl FromStr for Nodes {
     }
 }
 
-#[test]
-fn test() {
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic() {
         assert_eq!(
             Nodes::from_str("sin(2) + 1").unwrap().as_ref(),
             &[
@@ -208,9 +212,10 @@ fn test() {
                 Node::from(1),
             ],
         )
-}
-#[test]
-fn test_e() {
+    }
+
+    #[test]
+    fn e_constant() {
         assert_eq!(
             Nodes::from_str("5e * 5").unwrap().as_ref(),
             &[
@@ -221,9 +226,9 @@ fn test_e() {
                 Node::from(5),
             ],
         )
-}
-#[test]
-fn test_unary_op() {
+    }
+    #[test]
+    fn unary_op() {
         assert_eq!(
             Nodes::from_str("5(-5)").unwrap().as_ref(),
             &[
@@ -234,4 +239,5 @@ fn test_unary_op() {
                 Node::ParenthesisEnd,
             ],
         )
+    }
 }