From 6518ed8a4d3206fd99e40975f7b42de5ee33dd37 Mon Sep 17 00:00:00 2001 From: vorboyvo Date: Tue, 23 Sep 2025 18:14:10 -0400 Subject: [PATCH] Moved tests to new file. --- src/main.rs | 131 +------------------------------------------------- src/parser.rs | 12 ++++- src/test.rs | 128 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 139 insertions(+), 132 deletions(-) create mode 100644 src/test.rs diff --git a/src/main.rs b/src/main.rs index af2531a..1dc351e 100644 --- a/src/main.rs +++ b/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 { - 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 { - 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 { - 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; diff --git a/src/parser.rs b/src/parser.rs index 963c512..e26bf4a 100644 --- a/src/parser.rs +++ b/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> { let alternative = map( take_while1::<_, &str, Error<&str>>(AsChar::is_alpha), |a| Tree:: { - root: Vertex::Terminal(Alternative{name: a.to_string()}) + root: Vertex::Terminal(Alternative{name: a.to_owned()}) } ); map( diff --git a/src/test.rs b/src/test.rs new file mode 100644 index 0000000..189d1db --- /dev/null +++ b/src/test.rs @@ -0,0 +1,128 @@ + use super::*; + use assert_approx_eq::assert_approx_eq; + + fn simple_symmetric_tree() -> Tree { + 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 { + 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 { + 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() + ) + }