Cleanup tests with extra helpers

Author: Hendrik van Antwerpen

stack-graphs/tests/it/cycles.rs

@@ -5,7 +5,6 @@
 // Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.
 // ------------------------------------------------------------------------------------------------
 
-use stack_graphs::graph::NodeID;
 use stack_graphs::graph::StackGraph;
 use stack_graphs::partial::PartialPaths;
 
@@ -16,158 +15,111 @@ use crate::util::*;
 
 #[test]
 fn renaming_path_is_productive() {
-    let mut g = StackGraph::new();
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").unwrap();
+    let s = create_scope_node(&mut graph, file, false);
+    let foo_def = create_pop_symbol_node(&mut graph, file, "foo", true);
+    let bar_ref = create_push_symbol_node(&mut graph, file, "bar", true);
 
-    let f = g.add_file("test").unwrap();
-
-    let s = g.add_scope_node(NodeID::new_in_file(f, 0), false).unwrap();
-
-    let foo = g.add_symbol("foo");
-    let bar = g.add_symbol("bar");
-    let foo_def = g
-        .add_pop_symbol_node(NodeID::new_in_file(f, 1), foo, true)
-        .unwrap();
-    let bar_ref = g
-        .add_push_symbol_node(NodeID::new_in_file(f, 2), bar, true)
+    let mut partials = PartialPaths::new();
+    let p = create_partial_path_and_edges(&mut graph, &mut partials, &[s, foo_def, bar_ref, s])
         .unwrap();
 
-    let mut ps = PartialPaths::new();
-    let p = create_partial_path_and_edges(&mut g, &mut ps, &[s, foo_def, bar_ref, s]).unwrap();
-
-    assert!(p.is_productive(&g, &mut ps));
+    assert!(p.is_productive(&graph, &mut partials));
 }
 
 #[test]
 fn renaming_root_path_is_productive() {
-    let mut g = StackGraph::new();
-
-    let f = g.add_file("test").unwrap();
-
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").unwrap();
     let s = StackGraph::root_node();
+    let foo_def = create_pop_symbol_node(&mut graph, file, "foo", true);
+    let bar_ref = create_push_symbol_node(&mut graph, file, "bar", true);
 
-    let foo = g.add_symbol("foo");
-    let bar = g.add_symbol("bar");
-    let foo_def = g
-        .add_pop_symbol_node(NodeID::new_in_file(f, 1), foo, true)
-        .unwrap();
-    let bar_ref = g
-        .add_push_symbol_node(NodeID::new_in_file(f, 2), bar, true)
+    let mut partials = PartialPaths::new();
+    let p = create_partial_path_and_edges(&mut graph, &mut partials, &[s, foo_def, bar_ref, s])
         .unwrap();
 
-    let mut ps = PartialPaths::new();
-    let p = create_partial_path_and_edges(&mut g, &mut ps, &[s, foo_def, bar_ref, s]).unwrap();
-
-    assert!(p.is_productive(&g, &mut ps));
+    assert!(p.is_productive(&graph, &mut partials));
 }
 
 #[test]
 fn introducing_path_is_unproductive() {
-    let mut g = StackGraph::new();
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").unwrap();
+    let s = create_scope_node(&mut graph, file, false);
+    let bar_ref = create_push_symbol_node(&mut graph, file, "bar", true);
 
-    let f = g.add_file("test").unwrap();
+    let mut partials = PartialPaths::new();
+    let p = create_partial_path_and_edges(&mut graph, &mut partials, &[s, bar_ref, s]).unwrap();
 
-    let s = g.add_scope_node(NodeID::new_in_file(f, 0), false).unwrap();
-
-    let bar = g.add_symbol("bar");
-    let bar_ref = g
-        .add_push_symbol_node(NodeID::new_in_file(f, 1), bar, true)
-        .unwrap();
-
-    let mut ps = PartialPaths::new();
-    let p = create_partial_path_and_edges(&mut g, &mut ps, &[s, bar_ref, s]).unwrap();
-
-    assert!(!p.is_productive(&g, &mut ps));
+    assert!(!p.is_productive(&graph, &mut partials));
 }
 
 #[test]
 fn eliminating_path_is_productive() {
-    let mut g = StackGraph::new();
-
-    let f = g.add_file("test").unwrap();
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").unwrap();
+    let s = create_scope_node(&mut graph, file, false);
+    let foo_def = create_pop_symbol_node(&mut graph, file, "foo", true);
 
-    let s = g.add_scope_node(NodeID::new_in_file(f, 0), false).unwrap();
-
-    let foo = g.add_symbol("foo");
-    let foo_def = g
-        .add_pop_symbol_node(NodeID::new_in_file(f, 1), foo, true)
-        .unwrap();
+    let mut partials = PartialPaths::new();
+    let p = create_partial_path_and_edges(&mut graph, &mut partials, &[s, foo_def, s]).unwrap();
 
-    let mut ps = PartialPaths::new();
-    let p = create_partial_path_and_edges(&mut g, &mut ps, &[s, foo_def, s]).unwrap();
-
-    assert!(p.is_productive(&g, &mut ps));
+    assert!(p.is_productive(&graph, &mut partials));
 }
 
 #[test]
 fn identity_path_is_unproductive() {
-    let mut g = StackGraph::new();
-
-    let f = g.add_file("test").unwrap();
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").unwrap();
+    let s = create_scope_node(&mut graph, file, false);
+    let bar_def = create_pop_symbol_node(&mut graph, file, "bar", true);
+    let bar_ref = create_push_symbol_node(&mut graph, file, "bar", true);
 
-    let s = g.add_scope_node(NodeID::new_in_file(f, 0), false).unwrap();
-
-    let bar = g.add_symbol("bar");
-    let bar_def = g
-        .add_pop_symbol_node(NodeID::new_in_file(f, 1), bar, true)
-        .unwrap();
-    let bar_ref = g
-        .add_push_symbol_node(NodeID::new_in_file(f, 2), bar, true)
+    let mut partials = PartialPaths::new();
+    let p = create_partial_path_and_edges(&mut graph, &mut partials, &[s, bar_def, bar_ref, s])
         .unwrap();
 
-    let mut ps = PartialPaths::new();
-    let p = create_partial_path_and_edges(&mut g, &mut ps, &[s, bar_def, bar_ref, s]).unwrap();
-
-    assert!(!p.is_productive(&g, &mut ps));
+    assert!(!p.is_productive(&graph, &mut partials));
 }
 
 #[test]
 fn one_step_forward_two_steps_back_path_is_unproductive() {
-    let mut g = StackGraph::new();
-
-    let f = g.add_file("test").unwrap();
-
-    let s = g.add_scope_node(NodeID::new_in_file(f, 0), false).unwrap();
-
-    let foo = g.add_symbol("foo");
-    let foo_def = g
-        .add_pop_symbol_node(NodeID::new_in_file(f, 1), foo, true)
-        .unwrap();
-    let foo_ref1 = g
-        .add_push_symbol_node(NodeID::new_in_file(f, 2), foo, true)
-        .unwrap();
-    let foo_ref2 = g
-        .add_push_symbol_node(NodeID::new_in_file(f, 3), foo, true)
-        .unwrap();
-
-    let mut ps = PartialPaths::new();
-    let p = create_partial_path_and_edges(&mut g, &mut ps, &[s, foo_def, foo_ref1, foo_ref2, s])
-        .unwrap();
-
-    assert!(!p.is_productive(&g, &mut ps));
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").unwrap();
+    let s = create_scope_node(&mut graph, file, false);
+    let foo_def = create_pop_symbol_node(&mut graph, file, "foo", true);
+    let foo_ref1 = create_push_symbol_node(&mut graph, file, "foo", true);
+    let foo_ref2 = create_push_symbol_node(&mut graph, file, "foo", true);
+
+    let mut partials = PartialPaths::new();
+    let p = create_partial_path_and_edges(
+        &mut graph,
+        &mut partials,
+        &[s, foo_def, foo_ref1, foo_ref2, s],
+    )
+    .unwrap();
+
+    assert!(!p.is_productive(&graph, &mut partials));
 }
 
 #[test]
 fn two_steps_forward_one_step_back_path_is_productive() {
-    let mut g = StackGraph::new();
-
-    let f = g.add_file("test").unwrap();
-
-    let s = g.add_scope_node(NodeID::new_in_file(f, 0), false).unwrap();
-
-    let foo = g.add_symbol("foo");
-    let foo_def1 = g
-        .add_pop_symbol_node(NodeID::new_in_file(f, 1), foo, true)
-        .unwrap();
-    let foo_def2 = g
-        .add_pop_symbol_node(NodeID::new_in_file(f, 2), foo, true)
-        .unwrap();
-    let foo_ref = g
-        .add_push_symbol_node(NodeID::new_in_file(f, 3), foo, true)
-        .unwrap();
-
-    let mut ps = PartialPaths::new();
-    let p = create_partial_path_and_edges(&mut g, &mut ps, &[s, foo_def1, foo_def2, foo_ref, s])
-        .unwrap();
-
-    assert!(p.is_productive(&g, &mut ps));
+    let mut graph = StackGraph::new();
+    let file = graph.add_file("test").unwrap();
+    let s = create_scope_node(&mut graph, file, false);
+    let foo_def1 = create_pop_symbol_node(&mut graph, file, "foo", true);
+    let foo_def2 = create_pop_symbol_node(&mut graph, file, "foo", true);
+    let foo_ref = create_push_symbol_node(&mut graph, file, "foo", true);
+
+    let mut partials = PartialPaths::new();
+    let p = create_partial_path_and_edges(
+        &mut graph,
+        &mut partials,
+        &[s, foo_def1, foo_def2, foo_ref, s],
+    )
+    .unwrap();
+
+    assert!(p.is_productive(&graph, &mut partials));
 }

stack-graphs/tests/it/util.rs

@@ -8,6 +8,7 @@
 use controlled_option::ControlledOption;
 use stack_graphs::arena::Handle;
 use stack_graphs::graph::Edge;
+use stack_graphs::graph::File;
 use stack_graphs::graph::Node;
 use stack_graphs::graph::NodeID;
 use stack_graphs::graph::StackGraph;
@@ -25,6 +26,41 @@ pub(crate) type NiceScopedSymbol<'a> = (&'a str, Option<NiceScopeStack<'a>>);
 pub(crate) type NiceScopeStack<'a> = (&'a [u32], Option<ScopeStackVariable>);
 pub(crate) type NicePartialPath<'a> = &'a [Handle<Node>];
 
+pub(crate) fn create_scope_node(
+    graph: &mut StackGraph,
+    file: Handle<File>,
+    is_exported: bool,
+) -> Handle<Node> {
+    let id = graph.new_node_id(file);
+    graph.add_scope_node(id, is_exported).unwrap()
+}
+
+pub(crate) fn create_push_symbol_node(
+    graph: &mut StackGraph,
+    file: Handle<File>,
+    symbol: &str,
+    is_reference: bool,
+) -> Handle<Node> {
+    let id = graph.new_node_id(file);
+    let symbol = graph.add_symbol(symbol);
+    graph
+        .add_push_symbol_node(id, symbol, is_reference)
+        .unwrap()
+}
+
+pub(crate) fn create_pop_symbol_node(
+    graph: &mut StackGraph,
+    file: Handle<File>,
+    symbol: &str,
+    is_definition: bool,
+) -> Handle<Node> {
+    let id = graph.new_node_id(file);
+    let symbol = graph.add_symbol(symbol);
+    graph
+        .add_pop_symbol_node(id, symbol, is_definition)
+        .unwrap()
+}
+
 pub(crate) fn create_symbol_stack(
     graph: &mut StackGraph,
     partials: &mut PartialPaths,
@@ -76,14 +112,11 @@ pub(crate) fn create_partial_path_and_edges(
     partials: &mut PartialPaths,
     contents: NicePartialPath,
 ) -> Result<PartialPath, PathResolutionError> {
-    let mut g = StackGraph::new();
-    g.add_from_graph(graph).expect("");
-
     let mut nodes = contents.iter();
     let mut prev = nodes.next().unwrap();
     let mut path = PartialPath::from_node(graph, partials, *prev);
     for next in nodes {
-        g.add_edge(*prev, *next, 0);
+        graph.add_edge(*prev, *next, 0);
         path.append(
             graph,
             partials,