1 files changed, 272 insertions, 0 deletions
diff --git a/grammar/src/tests/test_grammar_left_closure.rs b/grammar/src/tests/test_grammar_left_closure.rs
new file mode 100644
index 0000000..0bc9f4d
--- /dev/null
+++ b/grammar/src/tests/test_grammar_left_closure.rs
@@ -0,0 +1,272 @@
+use crate::test_grammar_helper::*;
+use crate::*;
+use nfa::Nfa;
+use std::{
+    collections::HashSet,
+    io::{stdout, Write},
+};
+
+#[test]
+fn test_regex() -> Result<(), Box<dyn std::error::Error>> {
+    let mut grammar = new_grammar()?;
+
+    let vec_of_regexps = new_closure_regex(&mut grammar)?;
+
+    let mut lock = stdout().lock();
+
+    writeln!(lock, "grammar firsts: {:?}", grammar.firsts)?;
+    writeln!(lock, "grammar first nodes: {:?}", grammar.first_nodes)?;
+    writeln!(lock, "grammar:")?;
+    writeln!(lock, "{grammar}")?;
+
+    for regex in vec_of_regexps.into_iter().skip(1) {
+        writeln!(
+            lock,
+            "regex: {}",
+            regex.to_string_with(|tnt| format!("{tnt}"))?
+        )?;
+        // println!("regex: {regex:?}",);
+        writeln!(lock, "regex len = {}", regex.nodes_len())?;
+    }
+
+    Ok(())
+}
+
+// We ignore this test by default as it is possibly involved with
+// printing to a graphviz file.
+#[ignore]
+#[test]
+fn test_nfa() -> Result<(), Box<dyn std::error::Error>> {
+    let mut grammar = new_notes_grammar()?;
+    let closure = new_closure_regex(&mut grammar)?;
+
+    let mut lock = stdout().lock();
+
+    for regex in closure.iter() {
+        writeln!(
+            lock,
+            "regex: {}",
+            regex.to_string_with(|tnt| {
+                match tnt {
+                    TNT::Ter(t) => {
+                        format!(
+                            "({})",
+                            grammar.name_of_tnt(grammar.unpack_tnt(t).unwrap()).unwrap()
+                        )
+                    }
+                    TNT::Non(_) => {
+                        // hyper non-terminal
+                        format!("H({})", grammar.name_of_tnt(tnt).unwrap())
+                    }
+                }
+            })?
+        )?;
+        // println!("regex: {regex:?}",);
+        writeln!(lock, "regex len = {}", regex.nodes_len())?;
+    }
+
+    grammar
+        .left_closure_to_nfa(&closure)
+        .map(|_| ())
+        .map_err(Into::into)
+
+    // let _nfa = grammar.left_closure_to_nfa(&closure)?;
+
+    // writeln!(lock, "Not printing nfa to nfa.gv")?;
+
+    // nfa.print_viz("nfa.gv").map_err(Into::into)
+
+    // Ok(())
+}
+
+#[test]
+#[ignore]
+fn test_remove_epsilon() -> Result<(), Box<dyn std::error::Error>> {
+    let mut lock = stdout().lock();
+
+    let mut grammar = new_paren_grammar()?;
+
+    writeln!(lock, "grammar:")?;
+    writeln!(lock, "{grammar}")?;
+
+    let closure = new_closure_regex(&mut grammar)?;
+
+    let mut accumulator_value: usize = 0;
+
+    for regex in closure.iter() {
+        writeln!(
+            lock,
+            "regex: {}",
+            regex.to_string_with(|tnt| {
+                match tnt {
+                    TNT::Ter(t) => {
+                        format!(
+                            "({})",
+                            grammar.name_of_tnt(grammar.unpack_tnt(t).unwrap()).unwrap()
+                        )
+                    }
+                    TNT::Non(_) => {
+                        // hyper non-terminal
+                        format!("({})", grammar.name_of_tnt(tnt).unwrap())
+                    }
+                }
+            })?
+        )?;
+        writeln!(lock, "regex len = {}", regex.nodes_len())?;
+        writeln!(lock, "offset = {accumulator_value}")?;
+
+        accumulator_value += regex.nodes_len();
+    }
+
+    writeln!(lock, "total = {accumulator_value}")?;
+
+    let mut nfa = grammar.left_closure_to_nfa(&closure)?;
+
+    nfa.print_viz("nfa_orig.gv")?;
+
+    nfa.remove_epsilon(|label| label.is_none())?;
+
+    nfa.print_viz("nfa_no_epsilon.gv")?;
+
+    Ok(())
+}
+
+#[test]
+#[ignore]
+fn test_remove_dead() -> Result<(), Box<dyn std::error::Error>> {
+    let mut grammar = new_paren_grammar()?;
+    let closure = new_closure_regex(&mut grammar)?;
+
+    let mut lock = stdout().lock();
+
+    let mut accumulator = 0usize;
+    let mut accumulators = Vec::with_capacity(closure.len() + 1);
+    accumulators.push(accumulator);
+
+    for regex in closure.iter() {
+        writeln!(
+            lock,
+            "regex: {}",
+            regex.to_string_with(|tnt| {
+                match tnt {
+                    TNT::Ter(t) => {
+                        format!(
+                            "({})",
+                            grammar.name_of_tnt(grammar.unpack_tnt(t).unwrap()).unwrap()
+                        )
+                    }
+                    TNT::Non(_) => {
+                        // hyper non-terminal
+                        format!("({})", grammar.name_of_tnt(tnt).unwrap())
+                    }
+                }
+            })?
+        )?;
+        // println!("regex: {regex:?}",);
+        writeln!(lock, "regex len = {}", regex.nodes_len())?;
+
+        accumulator += regex.nodes_len() * 2;
+
+        accumulators.push(accumulator);
+    }
+
+    let mut nfa = grammar.left_closure_to_nfa(&closure)?;
+
+    nfa.print_viz("nfa_orig.gv")?;
+
+    nfa.remove_epsilon(|label| label.is_none())?;
+
+    let accumulators: HashSet<usize> = accumulators.into_iter().collect();
+
+    println!("accumulators = {accumulators:?}");
+
+    let grammar_reserve_node = |node| accumulators.contains(&node);
+
+    nfa.remove_dead(grammar_reserve_node)?;
+
+    nfa.print_viz("nfa_no_dead.gv")?;
+
+    Ok(())
+}
+
+#[test]
+#[ignore]
+fn test_nulling() -> Result<(), Box<dyn std::error::Error>> {
+    let mut grammar = new_left_recursive_grammar()?;
+    let closure = new_closure_regex(&mut grammar)?;
+
+    let mut lock = stdout().lock();
+
+    let mut accumulators = Vec::with_capacity(closure.len() + 1);
+    accumulators.push(0);
+
+    for regex in closure.iter() {
+        writeln!(
+            lock,
+            "regex: {}",
+            regex.to_string_with(|tnt| {
+                match tnt {
+                    TNT::Ter(t) => {
+                        format!(
+                            "({})",
+                            grammar.name_of_tnt(grammar.unpack_tnt(t).unwrap()).unwrap()
+                        )
+                    }
+                    TNT::Non(_) => {
+                        // hyper non-terminal
+                        format!("H({})", grammar.name_of_tnt(tnt).unwrap())
+                    }
+                }
+            })?
+        )?;
+        // println!("regex: {regex:?}",);
+        writeln!(lock, "regex len = {}", regex.nodes_len())?;
+
+        accumulators.push(regex.nodes_len() * 2 + accumulators.last().unwrap());
+    }
+
+    write!(lock, "nullables:")?;
+    let mut first_time = true;
+    for i in 0..(grammar.non_num()) {
+        if grammar.is_nullable(i)? {
+            if first_time {
+                write!(lock, " ")?;
+            } else {
+                write!(lock, ", ")?;
+            }
+            write!(lock, " {i}")?;
+            first_time = false;
+        }
+    }
+    writeln!(lock)?;
+
+    let accumulators: HashSet<usize> = accumulators.into_iter().collect();
+
+    let mut nfa = grammar.left_closure_to_nfa(&closure)?;
+
+    nfa.nulling(|label| {
+        if let Some(label) = *label {
+            match label {
+                TNT::Ter(_) => false,
+                // Panics if a non-terminal references an invalid node
+                // here.
+                TNT::Non(n) => grammar.is_nullable(n).unwrap(),
+            }
+        } else {
+            true
+        }
+    })?;
+
+    let grammar_reserve_nodes = |node| accumulators.contains(&node);
+
+    writeln!(lock, "accumulators are {accumulators:?}")?;
+
+    nfa.remove_epsilon(|label| label.is_none())?;
+    nfa.remove_dead(grammar_reserve_nodes)?;
+
+    writeln!(lock, "Printing nfa to nfa.gv")?;
+
+    nfa.print_viz("nfa.gv")?;
+
+    Ok(())
+}