Add dominoes test generator (#466)

Resolves #408

Author: hymccord

exercises/dominoes/DominoesTest.cs

@@ -1,96 +1,91 @@
-using System;
+// This file was auto-generated based on version 2.0.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class DominoesTest
 {
     [Fact]
-    public void Empty_input_equals_empty_output()
+    public void Empty_input_empty_output()
     {
-        var actual = new Tuple<int, int>[0];
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] {  };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
-    public void Singleton_input_equals_singleton_output()
+    public void Singleton_input_singleton_output()
     {
-        var actual = new[] { Tuple.Create(1, 1) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 1) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Singleton_that_cant_be_chained()
     {
-        var actual = new[] { Tuple.Create(1, 2) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Three_elements()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(3, 1), Tuple.Create(2, 3) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(3, 1), Tuple.Create(2, 3) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Can_reverse_dominoes()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(1, 3), Tuple.Create(2, 3) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(1, 3), Tuple.Create(2, 3) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Cant_be_chained()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(4, 1), Tuple.Create(2, 3) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(4, 1), Tuple.Create(2, 3) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Disconnected_simple()
     {
-        var actual = new[] { Tuple.Create(1, 1), Tuple.Create(2, 2) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 1), Tuple.Create(2, 2) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Disconnected_double_loop()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(2, 1), Tuple.Create(3, 4), Tuple.Create(4, 3) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 1), Tuple.Create(3, 4), Tuple.Create(4, 3) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Disconnected_single_isolated()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(4, 4) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(4, 4) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Need_backtrack()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(2, 4), Tuple.Create(2, 4) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(2, 4), Tuple.Create(2, 4) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Separate_loops()
     {
-        var actual = new[]
-        {
-            Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(1, 1), Tuple.Create(2, 2), Tuple.Create(3, 3)
-        };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(1, 1), Tuple.Create(2, 2), Tuple.Create(3, 3) };
+        Assert.True(Dominoes.CanChain(input));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Ten_elements()
+    public void Nine_elements()
     {
-        var actual = new[]
-        {
-            Tuple.Create(1, 2), Tuple.Create(5, 3), Tuple.Create(3, 1), Tuple.Create(1, 2), Tuple.Create(2, 4),
-            Tuple.Create(1, 6), Tuple.Create(2, 3), Tuple.Create(3, 4), Tuple.Create(5, 6)
-        };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(5, 3), Tuple.Create(3, 1), Tuple.Create(1, 2), Tuple.Create(2, 4), Tuple.Create(1, 6), Tuple.Create(2, 3), Tuple.Create(3, 4), Tuple.Create(5, 6) };
+        Assert.True(Dominoes.CanChain(input));
     }
 }

generators/Exercises/Dominoes.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
+using Generators.Output;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class Dominoes : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.Properties["input"] = ConvertInput(canonicalDataCase.Properties["input"]);
+            }
+        }
+        
+        protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string>() { typeof(Tuple).Namespace };
+
+        private UnescapedValue ConvertInput(dynamic input)
+        {
+            var dominoes = (input as JArray).Children();
+
+            // Manually format array of ints to array of tuples since the ValueFormatter doesn't handle Tuple<int,int>[]
+            // Project each jtoken element to an int array, then format to a string that will create a tuple from the 2-element array (via UnescapedValues)
+            var tuplesStringLiteral = dominoes.Select(s => s.ToObject<int[]>()).Select(s => $"Tuple.Create({s[0]}, {s[1]})");
+            return new UnescapedValue($"new Tuple<int, int>[] {{ {string.Join(", ", tuplesStringLiteral)} }}");
+        }
+    }
+}