add PascalsTriangle generator

exercises/pascals-triangle/Example.cs

@@ -1,15 +1,24 @@
 using System.Collections.Generic;
+using System;
 
 public static class PascalsTriangle
 {
     public static IEnumerable<IEnumerable<int>> Calculate(int rows)
+    {
+        if (rows < 0)
+            throw new ArgumentOutOfRangeException();
+
+        return ItterateRows(rows);
+    }
+
+    private static IEnumerable<IEnumerable<int>> ItterateRows(int rows)
     {
         for (var i = 1; i <= rows; i++)
         {
             yield return Row(i);
         }
     }
-    
+
     private static IEnumerable<int> Row(int row)
     {
         yield return 1;

exercises/pascals-triangle/PascalsTriangle.cs

@@ -7,4 +7,14 @@ public static IEnumerable<IEnumerable<int>> Calculate(int rows)
     {
         throw new NotImplementedException();
     }
+
+    private static IEnumerable<int> Row(int row)
+    {
+        throw new NotImplementedException();
+    }
+
+    private static IEnumerable<IEnumerable<int>> ItterateRows(int rows) 
+    {
+        throw new NotImplementedException();
+    }
 }

exercises/pascals-triangle/PascalsTriangleTest.cs

@@ -1,80 +1,53 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class PascalsTriangleTest
 {
     [Fact]
-    public void One_row()
+    public void Zero_rows()
+    {
+        Assert.Empty(PascalsTriangle.Calculate(0));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Single_row()
     {
-        var actual = PascalsTriangle.Calculate(1);
         var expected = new[] { new[] { 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(1));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Two_rows()
     {
-        var actual = PascalsTriangle.Calculate(2).ToArray();
         var expected = new[] { new[] { 1 }, new[] { 1, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(2));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Three_rows()
     {
-        var actual = PascalsTriangle.Calculate(3);
         var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(3));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Four_rows()
     {
-        var actual = PascalsTriangle.Calculate(4);
         var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Five_rows()
+    public void Negative_rows()
     {
-        var actual = PascalsTriangle.Calculate(5);
-        var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 }, new[] { 1, 4, 6, 4, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Throws<ArgumentOutOfRangeException>(() => PascalsTriangle.Calculate(-1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Twenty_rows()
-    {
-        var actual = PascalsTriangle.Calculate(20).Last();
-        var expected = new[] { 1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1 };
-        Assert.Equal(expected, actual);
-    }
-
-    private class EnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<T>>
-    {
-        public static readonly EnumerableEqualityComparer<T> Instance = new EnumerableEqualityComparer<T>();
-
-        public bool Equals(IEnumerable<T> x, IEnumerable<T> y) => x.SequenceEqual(y);
-
-        public int GetHashCode(IEnumerable<T> obj)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class NestedEnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<IEnumerable<T>>>
+    public void Null_no_rows()
     {
-        public static readonly NestedEnumerableEqualityComparer<T> Instance = new NestedEnumerableEqualityComparer<T>();
-
-        public bool Equals(IEnumerable<IEnumerable<T>> x, IEnumerable<IEnumerable<T>> y)
-            => x.SequenceEqual(y, EnumerableEqualityComparer<T>.Instance);
-
-        public int GetHashCode(IEnumerable<IEnumerable<T>> obj)
-        {
-            throw new NotImplementedException();
-        }
+        Assert.Throws<ArgumentOutOfRangeException>(() => PascalsTriangle.Calculate(-1));
     }
 }

generators/Exercises/PascalsTriangle.cs

@@ -0,0 +1,23 @@
+using System;
+using Generators.Input;
+using Generators.Output;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class PascalsTriangle : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var dataCases in canonicalData.Cases)
+            {
+                dataCases.UseVariableForExpected = true;
+                dataCases.Property = "calculate";
+                if (!(dataCases.Expected is JArray))
+                    dataCases.ExceptionThrown = typeof(ArgumentOutOfRangeException);
+                if (dataCases.Properties["count"] == null)
+                    dataCases.Properties["count"] = -1;
+            }
+        }
+    }
+}