Improved long data type support (#1311)

* Convert JTokens that are in nested objects

* Add support for rendering long values

Author: ErikSchierboom

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));
     }
 }

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));
     }
 }

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:

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"];
     }
 }

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);
         }
     }

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)

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);

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";