Improved long data type support (#1311)

ErikSchierboom · robkeim · commit b9d75e9169f5 · 2019-08-19T22:57:54.000+02:00
* Convert JTokens that are in nested objects

* Add support for rendering long values
diff --git a/exercises/prime-factors/PrimeFactorsTest.cs b/exercises/prime-factors/PrimeFactorsTest.cs
@@ -7,42 +7,42 @@ public class PrimeFactorsTest
     [Fact]
     public void No_factors()
     {
-        Assert.Empty(PrimeFactors.Factors(1));
+        Assert.Empty(PrimeFactors.Factors(1L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Prime_number()
     {
-        Assert.Equal(new[] { 2 }, PrimeFactors.Factors(2));
+        Assert.Equal(new[] { 2 }, PrimeFactors.Factors(2L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Square_of_a_prime()
     {
-        Assert.Equal(new[] { 3, 3 }, PrimeFactors.Factors(9));
+        Assert.Equal(new[] { 3, 3 }, PrimeFactors.Factors(9L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Cube_of_a_prime()
     {
-        Assert.Equal(new[] { 2, 2, 2 }, PrimeFactors.Factors(8));
+        Assert.Equal(new[] { 2, 2, 2 }, PrimeFactors.Factors(8L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Product_of_primes_and_non_primes()
     {
-        Assert.Equal(new[] { 2, 2, 3 }, PrimeFactors.Factors(12));
+        Assert.Equal(new[] { 2, 2, 3 }, PrimeFactors.Factors(12L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Product_of_primes()
     {
-        Assert.Equal(new[] { 5, 17, 23, 461 }, PrimeFactors.Factors(901255));
+        Assert.Equal(new[] { 5, 17, 23, 461 }, PrimeFactors.Factors(901255L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Factors_include_a_large_prime()
     {
-        Assert.Equal(new[] { 11, 9539, 894119 }, PrimeFactors.Factors(93819012551));
+        Assert.Equal(new[] { 11, 9539, 894119 }, PrimeFactors.Factors(93819012551L));
     }
 }
diff --git a/exercises/say/SayTest.cs b/exercises/say/SayTest.cs
@@ -8,90 +8,90 @@ public class SayTest
     [Fact]
     public void Zero()
     {
-        Assert.Equal("zero", Say.InEnglish(0));
+        Assert.Equal("zero", Say.InEnglish(0L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One()
     {
-        Assert.Equal("one", Say.InEnglish(1));
+        Assert.Equal("one", Say.InEnglish(1L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Fourteen()
     {
-        Assert.Equal("fourteen", Say.InEnglish(14));
+        Assert.Equal("fourteen", Say.InEnglish(14L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Twenty()
     {
-        Assert.Equal("twenty", Say.InEnglish(20));
+        Assert.Equal("twenty", Say.InEnglish(20L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Twenty_two()
     {
-        Assert.Equal("twenty-two", Say.InEnglish(22));
+        Assert.Equal("twenty-two", Say.InEnglish(22L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One_hundred()
     {
-        Assert.Equal("one hundred", Say.InEnglish(100));
+        Assert.Equal("one hundred", Say.InEnglish(100L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One_hundred_twenty_three()
     {
-        Assert.Equal("one hundred twenty-three", Say.InEnglish(123));
+        Assert.Equal("one hundred twenty-three", Say.InEnglish(123L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One_thousand()
     {
-        Assert.Equal("one thousand", Say.InEnglish(1000));
+        Assert.Equal("one thousand", Say.InEnglish(1000L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One_thousand_two_hundred_thirty_four()
     {
-        Assert.Equal("one thousand two hundred thirty-four", Say.InEnglish(1234));
+        Assert.Equal("one thousand two hundred thirty-four", Say.InEnglish(1234L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One_million()
     {
-        Assert.Equal("one million", Say.InEnglish(1000000));
+        Assert.Equal("one million", Say.InEnglish(1000000L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One_million_two_thousand_three_hundred_forty_five()
     {
-        Assert.Equal("one million two thousand three hundred forty-five", Say.InEnglish(1002345));
+        Assert.Equal("one million two thousand three hundred forty-five", Say.InEnglish(1002345L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void One_billion()
     {
-        Assert.Equal("one billion", Say.InEnglish(1000000000));
+        Assert.Equal("one billion", Say.InEnglish(1000000000L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void A_big_number()
     {
-        Assert.Equal("nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three", Say.InEnglish(987654321123));
+        Assert.Equal("nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three", Say.InEnglish(987654321123L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Numbers_below_zero_are_out_of_range()
     {
-        Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(-1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(-1L));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Numbers_above_999_999_999_999_are_out_of_range()
     {
-        Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(1000000000000));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(1000000000000L));
     }
 }
diff --git a/generators/Exercises/Generators/DiffieHellman.cs b/generators/Exercises/Generators/DiffieHellman.cs
@@ -94,8 +94,8 @@ private static dynamic ConvertKeyExchangeInput(dynamic input, TestMethod testMet
         {
             switch (input)
             {
-                case long l:
-                    return new BigInteger(l);
+                case int i:
+                    return new BigInteger(i);
                 case string str:
                     return new UnescapedValue($"{testMethod.TestedClass}.{char.ToUpper(str[0]) + str.Substring(1)}");
                 default:
diff --git a/generators/Exercises/Generators/PrimeFactors.cs b/generators/Exercises/Generators/PrimeFactors.cs
@@ -1,6 +1,10 @@
-﻿namespace Exercism.CSharp.Exercises.Generators
+﻿using Exercism.CSharp.Output;
+
+namespace Exercism.CSharp.Exercises.Generators
 {
     public class PrimeFactors : GeneratorExercise
     {
+        protected override void UpdateTestMethod(TestMethod testMethod) =>
+            testMethod.Input["value"] = (long)testMethod.Input["value"];
     }
 }
diff --git a/generators/Exercises/Generators/Say.cs b/generators/Exercises/Generators/Say.cs
@@ -8,8 +8,9 @@ public class Say : GeneratorExercise
         protected override void UpdateTestMethod(TestMethod testMethod)
         {
             testMethod.TestedMethod = "InEnglish";
+            testMethod.Input["number"] = (long)testMethod.Input["number"]; 
 
-            if (!(testMethod.Expected is string))
+            if (testMethod.ExpectedIsError)
                 testMethod.ExceptionThrown = typeof(ArgumentOutOfRangeException);
         }
     }
diff --git a/generators/Input/JTokenHelper.cs b/generators/Input/JTokenHelper.cs
@@ -45,16 +45,12 @@ public static dynamic ConvertJToken(JToken jToken)
 
         private static dynamic ConvertJObject(JObject jObject)
         {
-            var properties = jObject.ToObject<IDictionary<string, dynamic>>();
+            var properties = new Dictionary<string, dynamic>(jObject.Count, StringComparer.OrdinalIgnoreCase);
 
-            for (var i = 0; i < properties.Count; i++)
-            {
-                var key = properties.Keys.ElementAt(i);
-                var value = properties[key];
-                properties[key] = value is JToken jToken ? ConvertJToken(jToken) : value;
-            }
+            foreach (var (key, value) in jObject)
+                properties[key] = ConvertJToken(value);
 
-            return new Dictionary<string, dynamic>(properties, StringComparer.OrdinalIgnoreCase);
+            return properties;
         }
 
         private static dynamic ConvertJArray(JArray jArray)
diff --git a/generators/Output/Rendering/Render.cs b/generators/Output/Rendering/Render.cs
@@ -22,6 +22,7 @@ public string Object(object val)
                 case uint ui: return Uint(ui);
                 case float flt: return Float(flt);
                 case ulong ulng: return Ulong(ulng);
+                case long l: return Long(l);
                 case char c: return Char(c);
                 case DateTime dateTime: return DateTime(dateTime);
                 case Regex regex: return Regex(regex);
diff --git a/generators/Output/Rendering/RenderNumber.cs b/generators/Output/Rendering/RenderNumber.cs
@@ -12,6 +12,8 @@ public partial class Render
         public string Float(float flt) => flt.ToString(CultureInfo.InvariantCulture);
 
         public string Int(int i) => i.ToString(CultureInfo.InvariantCulture);
+        
+        public string Long(long lng) => $"{lng}L";
 
         public string Ulong(ulong ulng) => $"{ulng}UL";
 

Original file line number	Diff line number	Diff line change
`@@ -7,42 +7,42 @@ public class PrimeFactorsTest`
`7`	`7`	`[Fact]`
`8`	`8`	`public void No_factors()`
`9`	`9`	`{`
`10`		`- Assert.Empty(PrimeFactors.Factors(1));`
	`10`	`+ Assert.Empty(PrimeFactors.Factors(1L));`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`[Fact(Skip = "Remove to run test")]`
`14`	`14`	`public void Prime_number()`
`15`	`15`	`{`
`16`		`- Assert.Equal(new[] { 2 }, PrimeFactors.Factors(2));`
	`16`	`+ Assert.Equal(new[] { 2 }, PrimeFactors.Factors(2L));`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`[Fact(Skip = "Remove to run test")]`
`20`	`20`	`public void Square_of_a_prime()`
`21`	`21`	`{`
`22`		`- Assert.Equal(new[] { 3, 3 }, PrimeFactors.Factors(9));`
	`22`	`+ Assert.Equal(new[] { 3, 3 }, PrimeFactors.Factors(9L));`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`[Fact(Skip = "Remove to run test")]`
`26`	`26`	`public void Cube_of_a_prime()`
`27`	`27`	`{`
`28`		`- Assert.Equal(new[] { 2, 2, 2 }, PrimeFactors.Factors(8));`
	`28`	`+ Assert.Equal(new[] { 2, 2, 2 }, PrimeFactors.Factors(8L));`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`[Fact(Skip = "Remove to run test")]`
`32`	`32`	`public void Product_of_primes_and_non_primes()`
`33`	`33`	`{`
`34`		`- Assert.Equal(new[] { 2, 2, 3 }, PrimeFactors.Factors(12));`
	`34`	`+ Assert.Equal(new[] { 2, 2, 3 }, PrimeFactors.Factors(12L));`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`[Fact(Skip = "Remove to run test")]`
`38`	`38`	`public void Product_of_primes()`
`39`	`39`	`{`
`40`		`- Assert.Equal(new[] { 5, 17, 23, 461 }, PrimeFactors.Factors(901255));`
	`40`	`+ Assert.Equal(new[] { 5, 17, 23, 461 }, PrimeFactors.Factors(901255L));`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`[Fact(Skip = "Remove to run test")]`
`44`	`44`	`public void Factors_include_a_large_prime()`
`45`	`45`	`{`
`46`		`- Assert.Equal(new[] { 11, 9539, 894119 }, PrimeFactors.Factors(93819012551));`
	`46`	`+ Assert.Equal(new[] { 11, 9539, 894119 }, PrimeFactors.Factors(93819012551L));`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,90 +8,90 @@ public class SayTest`
`8`	`8`	`[Fact]`
`9`	`9`	`public void Zero()`
`10`	`10`	`{`
`11`		`- Assert.Equal("zero", Say.InEnglish(0));`
	`11`	`+ Assert.Equal("zero", Say.InEnglish(0L));`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`[Fact(Skip = "Remove to run test")]`
`15`	`15`	`public void One()`
`16`	`16`	`{`
`17`		`- Assert.Equal("one", Say.InEnglish(1));`
	`17`	`+ Assert.Equal("one", Say.InEnglish(1L));`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`[Fact(Skip = "Remove to run test")]`
`21`	`21`	`public void Fourteen()`
`22`	`22`	`{`
`23`		`- Assert.Equal("fourteen", Say.InEnglish(14));`
	`23`	`+ Assert.Equal("fourteen", Say.InEnglish(14L));`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`[Fact(Skip = "Remove to run test")]`
`27`	`27`	`public void Twenty()`
`28`	`28`	`{`
`29`		`- Assert.Equal("twenty", Say.InEnglish(20));`
	`29`	`+ Assert.Equal("twenty", Say.InEnglish(20L));`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Fact(Skip = "Remove to run test")]`
`33`	`33`	`public void Twenty_two()`
`34`	`34`	`{`
`35`		`- Assert.Equal("twenty-two", Say.InEnglish(22));`
	`35`	`+ Assert.Equal("twenty-two", Say.InEnglish(22L));`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`[Fact(Skip = "Remove to run test")]`
`39`	`39`	`public void One_hundred()`
`40`	`40`	`{`
`41`		`- Assert.Equal("one hundred", Say.InEnglish(100));`
	`41`	`+ Assert.Equal("one hundred", Say.InEnglish(100L));`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`[Fact(Skip = "Remove to run test")]`
`45`	`45`	`public void One_hundred_twenty_three()`
`46`	`46`	`{`
`47`		`- Assert.Equal("one hundred twenty-three", Say.InEnglish(123));`
	`47`	`+ Assert.Equal("one hundred twenty-three", Say.InEnglish(123L));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`[Fact(Skip = "Remove to run test")]`
`51`	`51`	`public void One_thousand()`
`52`	`52`	`{`
`53`		`- Assert.Equal("one thousand", Say.InEnglish(1000));`
	`53`	`+ Assert.Equal("one thousand", Say.InEnglish(1000L));`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`[Fact(Skip = "Remove to run test")]`
`57`	`57`	`public void One_thousand_two_hundred_thirty_four()`
`58`	`58`	`{`
`59`		`- Assert.Equal("one thousand two hundred thirty-four", Say.InEnglish(1234));`
	`59`	`+ Assert.Equal("one thousand two hundred thirty-four", Say.InEnglish(1234L));`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`[Fact(Skip = "Remove to run test")]`
`63`	`63`	`public void One_million()`
`64`	`64`	`{`
`65`		`- Assert.Equal("one million", Say.InEnglish(1000000));`
	`65`	`+ Assert.Equal("one million", Say.InEnglish(1000000L));`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`[Fact(Skip = "Remove to run test")]`
`69`	`69`	`public void One_million_two_thousand_three_hundred_forty_five()`
`70`	`70`	`{`
`71`		`- Assert.Equal("one million two thousand three hundred forty-five", Say.InEnglish(1002345));`
	`71`	`+ Assert.Equal("one million two thousand three hundred forty-five", Say.InEnglish(1002345L));`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`[Fact(Skip = "Remove to run test")]`
`75`	`75`	`public void One_billion()`
`76`	`76`	`{`
`77`		`- Assert.Equal("one billion", Say.InEnglish(1000000000));`
	`77`	`+ Assert.Equal("one billion", Say.InEnglish(1000000000L));`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`[Fact(Skip = "Remove to run test")]`
`81`	`81`	`public void A_big_number()`
`82`	`82`	`{`
`83`		`- Assert.Equal("nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three", Say.InEnglish(987654321123));`
	`83`	`+ Assert.Equal("nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three", Say.InEnglish(987654321123L));`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`[Fact(Skip = "Remove to run test")]`
`87`	`87`	`public void Numbers_below_zero_are_out_of_range()`
`88`	`88`	`{`
`89`		`- Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(-1));`
	`89`	`+ Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(-1L));`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`[Fact(Skip = "Remove to run test")]`
`93`	`93`	`public void Numbers_above_999_999_999_999_are_out_of_range()`
`94`	`94`	`{`
`95`		`- Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(1000000000000));`
	`95`	`+ Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(1000000000000L));`
`96`	`96`	`}`
`97`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,8 +94,8 @@ private static dynamic ConvertKeyExchangeInput(dynamic input, TestMethod testMet`
`94`	`94`	`{`
`95`	`95`	`switch (input)`
`96`	`96`	`{`
`97`		`- case long l:`
`98`		`- return new BigInteger(l);`
	`97`	`+ case int i:`
	`98`	`+ return new BigInteger(i);`
`99`	`99`	`case string str:`
`100`	`100`	`return new UnescapedValue($"{testMethod.TestedClass}.{char.ToUpper(str[0]) + str.Substring(1)}");`
`101`	`101`	`default:`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,10 @@`
`1`		`-namespace Exercism.CSharp.Exercises.Generators`
	`1`	`+using Exercism.CSharp.Output;`
	`2`	`+`
	`3`	`+namespace Exercism.CSharp.Exercises.Generators`
`2`	`4`	`{`
`3`	`5`	`public class PrimeFactors : GeneratorExercise`
`4`	`6`	`{`
	`7`	`+ protected override void UpdateTestMethod(TestMethod testMethod) =>`
	`8`	`+ testMethod.Input["value"] = (long)testMethod.Input["value"];`
`5`	`9`	`}`
`6`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,9 @@ public class Say : GeneratorExercise`
`8`	`8`	`protected override void UpdateTestMethod(TestMethod testMethod)`
`9`	`9`	`{`
`10`	`10`	`testMethod.TestedMethod = "InEnglish";`
	`11`	`+ testMethod.Input["number"] = (long)testMethod.Input["number"];`
`11`	`12`
`12`		`- if (!(testMethod.Expected is string))`
	`13`	`+ if (testMethod.ExpectedIsError)`
`13`	`14`	`testMethod.ExceptionThrown = typeof(ArgumentOutOfRangeException);`
`14`	`15`	`}`
`15`	`16`	`}`