Add Saddle Points test generator (#463)

* - fix file name (missing 's') SaddlePointsTest
- add SaddlePoint test generator
- add multidimensional value formater

* - fix indentation for multidimensional array formatter
- cleanup test generator

Author: GKotfis

exercises/saddle-points/SaddlePointTest.cs

@@ -0,0 +1,75 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+using System;
+
+public class SaddlePointsTest
+{
+    [Fact]
+    public void Can_identify_single_saddle_point()
+    {
+        var input = new[,]
+        {
+            { 9, 8, 7 },
+            { 5, 3, 2 },
+            { 6, 6, 7 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        var expected = new[] { Tuple.Create(1, 0) };
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_that_empty_matrix_has_no_saddle_points()
+    {
+        var input = new int[,] { };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        Assert.Empty(actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_lack_of_saddle_points_when_there_are_none()
+    {
+        var input = new[,]
+        {
+            { 1, 2, 3 },
+            { 3, 1, 2 },
+            { 2, 3, 1 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        Assert.Empty(actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_multiple_saddle_points()
+    {
+        var input = new[,]
+        {
+            { 4, 5, 4 },
+            { 3, 5, 5 },
+            { 1, 5, 4 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        var expected = new[] { Tuple.Create(0, 1), Tuple.Create(1, 1), Tuple.Create(2, 1) };
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_saddle_point_in_bottom_right_corner()
+    {
+        var input = new[,]
+        {
+            { 8, 7, 9 },
+            { 6, 7, 6 },
+            { 3, 2, 5 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        var expected = new[] { Tuple.Create(2, 2) };
+        Assert.Equal(expected, actual);
+    }
+}

exercises/saddle-points/SaddlePointsTest.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using Generators.Input;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class SaddlePoints : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.TestedMethodType = TestedMethodType.Instance;
+                canonicalDataCase.Property = "Calculate";
+                canonicalDataCase.SetConstructorInputParameters("input");
+                canonicalDataCase.UseVariablesForConstructorParameters = true;
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForTested = true;
+                canonicalDataCase.UseVariableForExpected = true;
+
+                canonicalDataCase.Properties["input"] = (canonicalDataCase.Properties["input"] as JArray).ToObject<int[,]>();
+
+                var array = canonicalDataCase.Expected as Array;
+
+                if (array != null)
+                {
+                    canonicalDataCase.Expected = ToTupleCollection(array);
+                }
+            }
+        }
+
+        protected override HashSet<string> AddAdditionalNamespaces()
+        {
+            return new HashSet<string>
+            {
+                typeof(System.String).Namespace
+            };
+        }
+
+        private IEnumerable<Tuple<string, object>> ToTupleCollection(Array array)
+        {
+            for (int x = 0; x < array.GetLength(0); x++)
+            {
+                var current = ((Array)array).GetValue(x) as Dictionary<string, object>;
+                yield return new Tuple<string, object>(current["row"].ToString(), current["column"].ToString());
+            }
+        }
+    }
+}

generators/Exercises/SaddlePoints.cs

@@ -22,6 +22,14 @@ public static object Format(object val)
                     return $"{enumeration.GetType().Name}.{enumeration}";
                 case JArray jArray:
                     return $"new[] {{ {string.Join(", ", jArray.Select(Format))} }}";
+                case int[,] multidimensionalArray:
+                    return multidimensionalArray.GetLength(0) > 1
+                            ? $"new[,]\r\n{{\r\n    {string.Join(",\r\n    ", Enumerable.Range(0, multidimensionalArray.GetUpperBound(0) + 1).Select(x => multidimensionalArray.SliceRow(x).ToNestedArray()))}\r\n}}"
+                            : "new int[,] { }";
+                case IEnumerable<Tuple<string, object>> tuples:
+                    return $"new[] {{ {string.Join(", ", tuples.Select(Format))} }}";
+                case Tuple<string, object> tuple:
+                    return $"Tuple.Create({tuple.Item1}, {tuple.Item2})";
                 case string str:
                     return str.FormatString();
                 case IEnumerable<int> ints:
@@ -89,5 +97,26 @@ private static IEnumerable<string> AddTrailingSemicolon(this IEnumerable<string>
             array[array.Length - 1] += ";";
             return array;
         }
+
+        private static IEnumerable<T> SliceRow<T>(this T[,] array, int row)
+        {
+            for (var i = array.GetLowerBound(1); i <= array.GetUpperBound(1); i++)
+            {
+                yield return array[row, i];
+            }
+        }
+
+        private static IEnumerable<T> SliceColumn<T>(this T[,] array, int column)
+        {
+            for (var i = array.GetLowerBound(0); i <= array.GetUpperBound(0); i++)
+            {
+                yield return array[i, column];
+            }
+        }
+
+        private static string ToNestedArray<T>(this IEnumerable<T> enumerable)
+        {
+            return enumerable.Any() ? $"{{ {string.Join(", ", enumerable)} }}" : string.Empty;
+        }
     }
 }