Moved tests to new file.

src/main.rs

@@ -85,133 +85,4 @@ fn main() {
 }
 
 #[cfg(test)]
-mod tests {
-  use super::*;
-  use assert_approx_eq::assert_approx_eq;
-
-  fn simple_symmetric_tree() -> Tree<String, f64> {
-    let a = Alternative {
-      name: "A".to_owned()
-    };
-    let b = Alternative {
-      name: "B".to_owned()
-    };
-    let edge_a = Edge {
-      weight: 1.0,
-      destination: Tree {root: Vertex::Terminal(a)}
-    };
-    let edge_b = Edge {
-      weight: 1.0,
-      destination: Tree {root: Vertex::Terminal(b)}
-    };
-    let root = Vertex::NonTerminal(Box::new(edge_a), Box::new(edge_b));
-    Tree {root: root}
-  }
-
-  fn simple_asymmetric_tree() -> Tree<String, f64> {
-    let a = Alternative {
-      name: "A".to_owned()
-    };
-    let b = Alternative {
-      name: "B".to_owned()
-    };
-    let edge_a = Edge {
-      weight: 3.0,
-      destination: Tree {root: Vertex::Terminal(a)}
-    };
-    let edge_b = Edge {
-      weight: 1.0,
-      destination: Tree {root: Vertex::Terminal(b)}
-    };
-    let root = Vertex::NonTerminal(Box::new(edge_a), Box::new(edge_b));
-    Tree {root: root}
-  }
-
-  fn complex_tree() -> Tree<String, f64> {
-    let a = Alternative {
-      name: "A".to_owned()
-    };
-    let b = Alternative {
-      name: "B".to_owned()
-    };
-    let c = Alternative {
-      name: "C".to_owned()
-    };
-    let edge_a = Edge {
-      weight: 2.5,
-      destination: Tree {root: Vertex::Terminal(a)}
-    };
-    let edge_b = Edge {
-      weight: 1.0,
-      destination: Tree {root: Vertex::Terminal(b)}
-    };
-    let edge_ab = Edge{
-      weight: 0.5,
-      destination: Tree {
-        root: Vertex::NonTerminal(Box::new(edge_a), Box::new(edge_b))
-      }
-    };
-    let edge_c = Edge{
-      weight: 1.0,
-      destination: Tree {root: Vertex::Terminal(c)}
-    };
-    let root = Vertex::NonTerminal(Box::new(edge_ab), Box::new(edge_c));
-    Tree {root: root}
-  }
-
-
-  // A test for the simplest symmetric case
-  #[test]
-  fn choice_probability_test_1() {
-    assert_eq!(simple_symmetric_tree().choice_probability(&("A".to_owned())), 0.5);
-  }
-
-  // A test for the simplest asymmetric case
-  #[test]
-  fn choice_probability_test_2() {
-    assert_eq!(simple_asymmetric_tree().choice_probability(&("A".to_owned())), 0.75);
-  }
-
-  // A test for depth higher than 1
-  #[test]
-  fn choice_probability_test_3() {
-    assert_approx_eq!(
-      complex_tree().choice_probability(&("A".to_owned())),
-      (2.5/(2.5+1.0))*((2.5+1.0+0.5)/(2.5+1.0+0.5+1.0))
-    );
-  }
-
-  // A test for parsing the simplest symmetric case
-  #[test]
-  fn parser_test_1() {
-    assert_eq!(
-      {
-        let (_, b) = parser::subtree("([1.0]A[1.0]B)").unwrap();
-        b
-      },
-      simple_symmetric_tree()
-    )
-  }
-
-  #[test]
-  fn parser_test_2() {
-    assert_eq!(
-      {
-        let (_, b) = parser::subtree("([3.0]A[1.0]B)").unwrap();
-        b
-      },
-      simple_asymmetric_tree()
-    )
-  }
-
-  #[test]
-  fn parser_test_3() {
-    assert_eq!(
-      {
-        let (_, b) = parser::subtree("([0.5]([2.5]A[1.0]B)[1.0]C)").unwrap();
-        b
-      },
-      complex_tree()
-    )
-  }
-}
+mod test;

src/parser.rs

@@ -1,6 +1,14 @@
 /*
  * WHAT WE ARE PARSING:
- * 
+ * letter = "A"-"Z" | "a"-"z" ;
+ * digit = "0"-"9" ;
+ * decimal = digit + , ".", digit + ;
+ * weight = "[" , decimal , "]" ;
+ * alternative = letter + ;
+ * edge to alternative = weight , alternative ;
+ * out edge = edge to alternative | edge to subtree ;
+ * subtree = "(" , out edge , out edge , ")" ;
+ * edge to subtree = weight , subtree ;
  */
 
 use nom::{branch::alt, bytes::complete::take_while1, character::char, combinator::map, error::Error, number::complete::double, sequence::{delimited, pair}, AsChar, IResult, Parser};
@@ -16,7 +24,7 @@ fn weighted_edge(input: &str) -> IResult<&str, Edge<String, f64>> {
   let alternative = map(
     take_while1::<_, &str, Error<&str>>(AsChar::is_alpha),
     |a| Tree::<String, f64> {
-      root: Vertex::Terminal(Alternative{name: a.to_string()})
+      root: Vertex::Terminal(Alternative{name: a.to_owned()})
     }
   );
   map(

src/test.rs

@@ -0,0 +1,128 @@
+  use super::*;
+  use assert_approx_eq::assert_approx_eq;
+
+  fn simple_symmetric_tree() -> Tree<String, f64> {
+    let a = Alternative {
+      name: "A".to_owned()
+    };
+    let b = Alternative {
+      name: "B".to_owned()
+    };
+    let edge_a = Edge {
+      weight: 1.0,
+      destination: Tree {root: Vertex::Terminal(a)}
+    };
+    let edge_b = Edge {
+      weight: 1.0,
+      destination: Tree {root: Vertex::Terminal(b)}
+    };
+    let root = Vertex::NonTerminal(Box::new(edge_a), Box::new(edge_b));
+    Tree {root: root}
+  }
+
+  fn simple_asymmetric_tree() -> Tree<String, f64> {
+    let a = Alternative {
+      name: "A".to_owned()
+    };
+    let b = Alternative {
+      name: "B".to_owned()
+    };
+    let edge_a = Edge {
+      weight: 3.0,
+      destination: Tree {root: Vertex::Terminal(a)}
+    };
+    let edge_b = Edge {
+      weight: 1.0,
+      destination: Tree {root: Vertex::Terminal(b)}
+    };
+    let root = Vertex::NonTerminal(Box::new(edge_a), Box::new(edge_b));
+    Tree {root: root}
+  }
+
+  fn complex_tree() -> Tree<String, f64> {
+    let a = Alternative {
+      name: "A".to_owned()
+    };
+    let b = Alternative {
+      name: "B".to_owned()
+    };
+    let c = Alternative {
+      name: "C".to_owned()
+    };
+    let edge_a = Edge {
+      weight: 2.5,
+      destination: Tree {root: Vertex::Terminal(a)}
+    };
+    let edge_b = Edge {
+      weight: 1.0,
+      destination: Tree {root: Vertex::Terminal(b)}
+    };
+    let edge_ab = Edge{
+      weight: 0.5,
+      destination: Tree {
+        root: Vertex::NonTerminal(Box::new(edge_a), Box::new(edge_b))
+      }
+    };
+    let edge_c = Edge{
+      weight: 1.0,
+      destination: Tree {root: Vertex::Terminal(c)}
+    };
+    let root = Vertex::NonTerminal(Box::new(edge_ab), Box::new(edge_c));
+    Tree {root: root}
+  }
+
+
+  // A test for the simplest symmetric case
+  #[test]
+  fn choice_probability_test_1() {
+    assert_eq!(simple_symmetric_tree().choice_probability(&("A".to_owned())), 0.5);
+  }
+
+  // A test for the simplest asymmetric case
+  #[test]
+  fn choice_probability_test_2() {
+    assert_eq!(simple_asymmetric_tree().choice_probability(&("A".to_owned())), 0.75);
+  }
+
+  // A test for depth higher than 1
+  #[test]
+  fn choice_probability_test_3() {
+    assert_approx_eq!(
+      complex_tree().choice_probability(&("A".to_owned())),
+      (2.5/(2.5+1.0))*((2.5+1.0+0.5)/(2.5+1.0+0.5+1.0))
+    );
+  }
+
+  // A test for parsing the simplest symmetric case
+  #[test]
+  fn parser_test_1() {
+    assert_eq!(
+      {
+        let (_, b) = parser::subtree("([1.0]A[1.0]B)").unwrap();
+        b
+      },
+      simple_symmetric_tree()
+    )
+  }
+
+  #[test]
+  fn parser_test_2() {
+    assert_eq!(
+      {
+        let (_, b) = parser::subtree("([3.0]A[1.0]B)").unwrap();
+        b
+      },
+      simple_asymmetric_tree()
+    )
+  }
+
+  #[test]
+  fn parser_test_3() {
+    assert_eq!(
+      {
+        let (_, b) = parser::subtree("([0.5]([2.5]A[1.0]B)[1.0]C)").unwrap();
+        b
+      },
+      complex_tree()
+    )
+  }