binary-search-tree: add generator

Author: ErikSchierboom

exercises/practice/binary-search-tree/.meta/Generator.tpl

@@ -0,0 +1,37 @@
+{{ func assertions(node, path)
+    checks = [$"Assert.Equal({string.to_int node.data}, tree.{path}Value);"]
+
+    if node.left
+        checks = array.add_range checks (assertions node.left (path + "Left."))
+    end
+
+    if node.right
+        checks = array.add_range checks (assertions node.right (path + "Right."))
+    end
+
+    ret checks
+end }}
+
+using System.Linq;
+using Xunit;
+
+public class {{ testClass }}
+{
+    {{- for test in tests }}
+    [Fact{{ if !for.first }}(Skip = "Remove this Skip property to run this test"){{ end }}]
+    public void {{ test.testMethod }}()
+    {
+        {{- if test.input.treeData | array.size == 1 }}
+        var tree = new {{ testedClass }}({{ test.input.treeData[0] | @string.to_int }});
+        {{- else -}}
+        var tree = new {{ testedClass }}(new[] { {{ test.input.treeData | array.each @string.to_int | array.join "," }} });
+        {{- end -}}
+        {{- if test.property == "data" }}    
+        {{ test.expected | assertions "" | array.join "\n" }}
+        {{- else }}
+        int[] expected = {{ test.expected | array.each @string.to_int }};
+        Assert.Equal(expected, tree.AsEnumerable());
+        {{ end -}}
+    }
+    {{ end -}}
+}

exercises/practice/binary-search-tree/BinarySearchTreeTests.cs

@@ -11,23 +11,23 @@ public void Data_is_retained()
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Smaller_number_at_left_node()
+    public void Insert_data_at_proper_node_smaller_number_at_left_node()
     {
         var tree = new BinarySearchTree(new[] { 4, 2 });
         Assert.Equal(4, tree.Value);
         Assert.Equal(2, tree.Left.Value);
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Same_number_at_left_node()
+    public void Insert_data_at_proper_node_same_number_at_left_node()
     {
         var tree = new BinarySearchTree(new[] { 4, 4 });
         Assert.Equal(4, tree.Value);
         Assert.Equal(4, tree.Left.Value);
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Greater_number_at_right_node()
+    public void Insert_data_at_proper_node_greater_number_at_right_node()
     {
         var tree = new BinarySearchTree(new[] { 4, 5 });
         Assert.Equal(4, tree.Value);
@@ -48,37 +48,42 @@ public void Can_create_complex_tree()
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Can_sort_single_number()
+    public void Can_sort_data_can_sort_single_number()
     {
         var tree = new BinarySearchTree(2);
-        Assert.Equal(new[] { 2 }, tree.AsEnumerable());
+        int[] expected = [2];
+        Assert.Equal(expected, tree.AsEnumerable());
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Can_sort_if_second_number_is_smaller_than_first()
+    public void Can_sort_data_can_sort_if_second_number_is_smaller_than_first()
     {
         var tree = new BinarySearchTree(new[] { 2, 1 });
-        Assert.Equal(new[] { 1, 2 }, tree.AsEnumerable());
+        int[] expected = [1, 2];
+        Assert.Equal(expected, tree.AsEnumerable());
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Can_sort_if_second_number_is_same_as_first()
+    public void Can_sort_data_can_sort_if_second_number_is_same_as_first()
     {
         var tree = new BinarySearchTree(new[] { 2, 2 });
-        Assert.Equal(new[] { 2, 2 }, tree.AsEnumerable());
+        int[] expected = [2, 2];
+        Assert.Equal(expected, tree.AsEnumerable());
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Can_sort_if_second_number_is_greater_than_first()
+    public void Can_sort_data_can_sort_if_second_number_is_greater_than_first()
     {
         var tree = new BinarySearchTree(new[] { 2, 3 });
-        Assert.Equal(new[] { 2, 3 }, tree.AsEnumerable());
+        int[] expected = [2, 3];
+        Assert.Equal(expected, tree.AsEnumerable());
     }
 
     [Fact(Skip = "Remove this Skip property to run this test")]
-    public void Can_sort_complex_tree()
+    public void Can_sort_data_can_sort_complex_tree()
     {
         var tree = new BinarySearchTree(new[] { 2, 1, 3, 6, 7, 5 });
-        Assert.Equal(new[] { 1, 2, 3, 5, 6, 7 }, tree.AsEnumerable());
+        int[] expected = [1, 2, 3, 5, 6, 7];
+        Assert.Equal(expected, tree.AsEnumerable());
     }
 }