Started implementation on tree unit tests.

gemla/src/bracket/mod.rs

@@ -12,8 +12,8 @@ impl tree::Tree<Uuid> {
         println!("Running simulation for node: {}", self.val);
         println!(
             "With children {} and {}",
-            tree::fmt_node(&self.left),
+            tree::Tree::fmt_node(&self.left),
-            tree::fmt_node(&self.right)
+            tree::Tree::fmt_node(&self.right)
         );
     }
 }

gemla/src/main.rs

@@ -7,6 +7,9 @@ mod tree;
 mod constants;
 mod file_linked;
 
+#[cfg(test)]
+mod tests;
+
 use clap::App;
 use std::fs::metadata;
 

gemla/src/tests/bracket.rs

@@ -0,0 +1 @@
+

gemla/src/tests/file_linked.rs

@@ -0,0 +1 @@
+

gemla/src/tests/mod.rs

@@ -0,0 +1,3 @@
+mod tree;
+mod bracket;
+mod file_linked;

gemla/src/tests/tree.rs

@@ -0,0 +1,47 @@
+use super::super::tree::Tree;
+
+#[test]
+fn test_new() {
+    assert_eq!(
+        Tree::new(30, None, Some(Box::new(Tree::new(20, None, None)))),
+        Tree {
+            val: 30,
+            left: None,
+            right: Some(Box::new(Tree {
+                val: 20,
+                left: None,
+                right: None,
+            })),
+        }
+    );
+}
+
+#[test]
+fn test_fmt() {
+    assert_eq!(
+        format!(
+            "{}",
+            Tree::new("foo", Some(Box::new(Tree::new("bar", None, None))), None)
+        ),
+        "(foo: (bar: _|_)|_)"
+    );
+}
+
+#[test]
+fn test_fmt_node() {
+    assert_eq!(
+        Tree::fmt_node(&Some(Box::new(Tree::new(
+            17,
+            Some(Box::new(Tree::new(16, None, None))),
+            Some(Box::new(Tree::new(12, None, None))),
+        )))),
+        "17"
+    );
+    assert_eq!(
+        Tree::fmt_node(&Some(Box::new(
+            Tree::new(Tree::new("foo", None, None), None, None),
+        ))),
+        "(foo: _|_)"
+    );
+    assert_eq!(Tree::<i32>::fmt_node(&None), "_");
+}

gemla/src/tree/mod.rs

@@ -2,7 +2,7 @@ use std::fmt;
 use std::str::FromStr;
 use regex::Regex;
 
-#[derive(Default, Clone)]
+#[derive(Default, Clone, PartialEq, Debug)]
 pub struct Tree<T> {
     pub val: T,
     pub left: Option<Box<Tree<T>>>,
@@ -13,6 +13,16 @@ impl<T> Tree<T> {
     pub fn new(val: T, left: Option<Box<Tree<T>>>, right: Option<Box<Tree<T>>>) -> Tree<T> {
         Tree { val, left, right }
     }
+
+    pub fn fmt_node(t: &Option<Box<Tree<T>>>) -> String
+    where
+        T: fmt::Display,
+    {
+        match t {
+            Some(n) => format!("{}", (*n).val),
+            _ => String::from("_"),
+        }
+    }
 }
 
 impl<T: fmt::Display> fmt::Display for Tree<T> {
@@ -26,7 +36,7 @@ impl<T: fmt::Display> fmt::Display for Tree<T> {
 
         write!(
             f,
-            "({} :{}|{})",
+            "({}: {}|{})",
             self.val,
             node_str(&self.left),
             node_str(&self.right)
@@ -34,13 +44,6 @@ impl<T: fmt::Display> fmt::Display for Tree<T> {
     }
 }
 
-pub fn fmt_node<T: fmt::Display>(t: &Option<Box<Tree<T>>>) -> String {
-    match t {
-        Some(n) => format!("{}", (*n).val),
-        _ => String::from("_"),
-    }
-}
-
 fn seperate_nodes(s: &str) -> Result<(&str, &str), ParseTreeError> {
     let mut result = Err(ParseTreeError::new(
         format!("Unable to seperate string: {}", s),