diff --git a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/OutputRoundingResults.cs b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/OutputRoundingResults.cs index 35fdf9965c..a9a326ed32 100644 --- a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/OutputRoundingResults.cs +++ b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/OutputRoundingResults.cs @@ -1,85 +1,87 @@ -namespace RoundDownToNearestInteger +using System.Globalization; + +namespace RoundDownToNearestInteger; + +internal static class OutputRoundingResults { - internal static class OutputRoundingResults + private static void WriteResultsToConsole(double[] testCases, int[] results, int[] desiredResults) { - private static void WriteResultsToConsole(double[] testCases, int[] results, int[] desiredResults) + for (var cnt = 0; cnt < testCases.Length; cnt++) { - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - Console.WriteLine($"Rounding {testCases[cnt]} results in {results[cnt]} (desired result: {desiredResults[cnt]})"); - } - - Console.WriteLine(); + Console.WriteLine(string.Create(CultureInfo.InvariantCulture, + $"Rounding {testCases[cnt]} results in {results[cnt]} (desired result: {desiredResults[cnt]})")); } - public static void RoundDownUsingMathFloor(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Math.Floor():"); - var results = RoundingMethods.RoundDownUsingMathFloor(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + Console.WriteLine(); + } - public static void RoundDownUsingMathTruncate(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Math.Truncate():"); - var results = RoundingMethods.RoundDownUsingMathTruncate(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingMathFloor(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Math.Floor():"); + var results = RoundingMethods.RoundDownUsingMathFloor(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingMathRoundWithToEvenMode(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Math.Round() with ToEven mode:"); - var results = RoundingMethods.RoundDownUsingMathRoundWithToEvenMode(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingMathTruncate(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Math.Truncate():"); + var results = RoundingMethods.RoundDownUsingMathTruncate(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingMathRoundWithAwayFromZeroMode(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Math.Round() with AwayFromZero mode:"); - var results = RoundingMethods.RoundDownUsingMathRoundWithAwayFromZeroMode(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingMathRoundWithToEvenMode(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Math.Round() with ToEven mode:"); + var results = RoundingMethods.RoundDownUsingMathRoundWithToEvenMode(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingMathRoundWithToZeroMode(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Math.Round() with ToZero mode:"); - var results = RoundingMethods.RoundDownUsingMathRoundWithToZeroMode(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingMathRoundWithAwayFromZeroMode(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Math.Round() with AwayFromZero mode:"); + var results = RoundingMethods.RoundDownUsingMathRoundWithAwayFromZeroMode(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingMathRoundWithToNegativeInfinityMode(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Math.Round() with ToNegativeInfinity mode:"); - var results = RoundingMethods.RoundDownUsingMathRoundWithToNegativeInfinityMode(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingMathRoundWithToZeroMode(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Math.Round() with ToZero mode:"); + var results = RoundingMethods.RoundDownUsingMathRoundWithToZeroMode(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingMathRoundWithToPositiveInfinityMode(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Math.Round() with ToPositiveInfinity mode:"); - var results = RoundingMethods.RoundDownUsingMathRoundWithToPositiveInfinityMode(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingMathRoundWithToNegativeInfinityMode(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Math.Round() with ToNegativeInfinity mode:"); + var results = RoundingMethods.RoundDownUsingMathRoundWithToNegativeInfinityMode(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingConvertToInt32(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using Convert.ToInt32():"); - var results = RoundingMethods.RoundDownUsingConvertToInt32(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingMathRoundWithToPositiveInfinityMode(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Math.Round() with ToPositiveInfinity mode:"); + var results = RoundingMethods.RoundDownUsingMathRoundWithToPositiveInfinityMode(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingCasting(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using casting:"); - var results = RoundingMethods.RoundDownUsingCasting(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingConvertToInt32(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using Convert.ToInt32():"); + var results = RoundingMethods.RoundDownUsingConvertToInt32(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } - public static void RoundDownUsingSubtractionWithModulo(double[] testCases, int[] desiredResults) - { - Console.WriteLine($"Round down using subtraction with modulo:"); - var results = RoundingMethods.RoundDownUsingSubtractionWithModulo(testCases); - WriteResultsToConsole(testCases, results, desiredResults); - } + public static void RoundDownUsingCasting(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using casting:"); + var results = RoundingMethods.RoundDownUsingCasting(testCases); + WriteResultsToConsole(testCases, results, desiredResults); + } + + public static void RoundDownUsingSubtractionWithModulo(double[] testCases, int[] desiredResults) + { + Console.WriteLine($"Round down using subtraction with modulo:"); + var results = RoundingMethods.RoundDownUsingSubtractionWithModulo(testCases); + WriteResultsToConsole(testCases, results, desiredResults); } -} \ No newline at end of file +} diff --git a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/Program.cs b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/Program.cs index a9cded4e12..eaa703c7d0 100644 --- a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/Program.cs +++ b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/Program.cs @@ -1,31 +1,30 @@ -namespace RoundDownToNearestInteger +namespace RoundDownToNearestInteger; + +internal class Program { - internal class Program + public static void Main(string[] args) { - public static void Main(string[] args) - { - var testCases = new double[] { 2.5, 1.75, 1.5, 1.25, -1.25, -1.5, -1.75, -2.5 }; - var desiredResults = new int[] { 2, 1, 1, 1, -2, -2, -2, -3 }; + double[] testCases = [2.5, 1.75, 1.5, 1.25, -1.25, -1.5, -1.75, -2.5]; + int[] desiredResults = [2, 1, 1, 1, -2, -2, -2, -3]; - OutputRoundingResults.RoundDownUsingMathFloor(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingMathFloor(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingMathTruncate(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingMathTruncate(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingMathRoundWithToEvenMode(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingMathRoundWithToEvenMode(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingMathRoundWithAwayFromZeroMode(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingMathRoundWithAwayFromZeroMode(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingMathRoundWithToZeroMode(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingMathRoundWithToZeroMode(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingMathRoundWithToNegativeInfinityMode(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingMathRoundWithToNegativeInfinityMode(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingMathRoundWithToPositiveInfinityMode(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingMathRoundWithToPositiveInfinityMode(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingConvertToInt32(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingConvertToInt32(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingCasting(testCases, desiredResults); + OutputRoundingResults.RoundDownUsingCasting(testCases, desiredResults); - OutputRoundingResults.RoundDownUsingSubtractionWithModulo(testCases, desiredResults); - } + OutputRoundingResults.RoundDownUsingSubtractionWithModulo(testCases, desiredResults); } -} \ No newline at end of file +} diff --git a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundDownToNearestInteger.csproj b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundDownToNearestInteger.csproj index f02677bf64..dfb40caafc 100644 --- a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundDownToNearestInteger.csproj +++ b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundDownToNearestInteger.csproj @@ -2,7 +2,7 @@ Exe - net7.0 + net10.0 enable enable diff --git a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundingMethods.cs b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundingMethods.cs index b7a4d63c95..6f5665562c 100644 --- a/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundingMethods.cs +++ b/numbers-csharp/RoundDownToNearestInteger/RoundDownToNearestInteger/RoundingMethods.cs @@ -1,125 +1,146 @@ -namespace RoundDownToNearestInteger +namespace RoundDownToNearestInteger; + +public static class RoundingMethods { - public class RoundingMethods + public static int[] RoundDownUsingMathFloor(double[] testCases) { - public static int[] RoundDownUsingMathFloor(double[] testCases) + var results = new int[testCases.Length]; + + for (var cnt = 0; cnt < testCases.Length; cnt++) { - var results = new int[testCases.Length]; + results[cnt] = (int)Math.Floor(testCases[cnt]); + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)Math.Floor(testCases[cnt]); - } + return results; + } - return results; - } + public static int[] RoundDownUsingMathTruncate(double[] testCases) + { + var results = new int[testCases.Length]; - public static int[] RoundDownUsingMathTruncate(double[] testCases) + for (var cnt = 0; cnt < testCases.Length; cnt++) { - var results = new int[testCases.Length]; + results[cnt] = (int)Math.Truncate(testCases[cnt]); + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)Math.Truncate(testCases[cnt]); - } + return results; + } - return results; - } + public static int[] RoundDownUsingMathRoundWithToEvenMode(double[] testCases) + { + var results = new int[testCases.Length]; - public static int[] RoundDownUsingMathRoundWithToEvenMode(double[] testCases) + for (var cnt = 0; cnt < testCases.Length; cnt++) { - var results = new int[testCases.Length]; + results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToEven); + } + + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToEven); - } + public static int[] RoundDownUsingMathRoundWithAwayFromZeroMode(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.AwayFromZero); } - public static int[] RoundDownUsingMathRoundWithAwayFromZeroMode(double[] testCases) - { - var results = new int[testCases.Length]; + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.AwayFromZero); - } + public static int[] RoundDownUsingMathRoundWithToZeroMode(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToZero); } - public static int[] RoundDownUsingMathRoundWithToZeroMode(double[] testCases) - { - var results = new int[testCases.Length]; + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToZero); - } + public static int[] RoundDownUsingMathRoundWithToNegativeInfinityMode(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToNegativeInfinity); } - public static int[] RoundDownUsingMathRoundWithToNegativeInfinityMode(double[] testCases) - { - var results = new int[testCases.Length]; + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToNegativeInfinity); - } + public static int[] RoundDownUsingMathRoundWithToPositiveInfinityMode(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToPositiveInfinity); } - public static int[] RoundDownUsingMathRoundWithToPositiveInfinityMode(double[] testCases) - { - var results = new int[testCases.Length]; + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)Math.Round(testCases[cnt], MidpointRounding.ToPositiveInfinity); - } + public static int[] RoundDownUsingConvertToInt32(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = Convert.ToInt32(testCases[cnt]); } - public static int[] RoundDownUsingConvertToInt32(double[] testCases) - { - var results = new int[testCases.Length]; + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = Convert.ToInt32(testCases[cnt]); - } + public static int[] RoundDownUsingCasting(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = (int)testCases[cnt]; } - public static int[] RoundDownUsingCasting(double[] testCases) - { - var results = new int[testCases.Length]; + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)testCases[cnt]; - } + public static int[] RoundDownUsingSubtractionWithModulo(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = (int)(testCases[cnt] - (testCases[cnt] % 1)); } - public static int[] RoundDownUsingSubtractionWithModulo(double[] testCases) - { - var results = new int[testCases.Length]; + return results; + } - for (var cnt = 0; cnt < testCases.Length; cnt++) - { - results[cnt] = (int)(testCases[cnt] - (testCases[cnt] % 1)); - } + public static int[] RoundUpUsingMathCeiling(double[] testCases) + { + var results = new int[testCases.Length]; - return results; + for (var cnt = 0; cnt < testCases.Length; cnt++) + { + results[cnt] = (int)Math.Ceiling(testCases[cnt]); } + + return results; + } + + public static int DivideAndRoundDown(int dividend, int divisor) + { + var quotient = dividend / divisor; + var remainder = dividend % divisor; + + return (remainder != 0 && (remainder < 0) != (divisor < 0)) + ? quotient - 1 + : quotient; } -} \ No newline at end of file +} diff --git a/numbers-csharp/RoundDownToNearestInteger/Tests/RoundDownToNearestIntegerTests.cs b/numbers-csharp/RoundDownToNearestInteger/Tests/RoundDownToNearestIntegerTests.cs index c7db447c7d..5d13786f1d 100644 --- a/numbers-csharp/RoundDownToNearestInteger/Tests/RoundDownToNearestIntegerTests.cs +++ b/numbers-csharp/RoundDownToNearestInteger/Tests/RoundDownToNearestIntegerTests.cs @@ -1,100 +1,145 @@ using RoundDownToNearestInteger; -namespace Tests +namespace Tests; + +[TestClass] +public class RoundDownToNearestIntegerTests { - [TestClass] - public class RoundDownToNearestIntegerTests + private readonly double[] testCases = [2.5, 1.75, 1.5, 1.25, -1.25, -1.5, -1.75, -2.5]; + + [TestMethod] + public void WhenRoundingUsingMathFloor_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingMathFloor(testCases); + int[] expected = [2, 1, 1, 1, -2, -2, -2, -3]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingMathTruncate_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingMathTruncate(testCases); + int[] expected = [2, 1, 1, 1, -1, -1, -1, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingMathRoundWithToEvenMode_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingMathRoundWithToEvenMode(testCases); + int[] expected = [2, 2, 2, 1, -1, -2, -2, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingMathRoundWithAwayFromZeroMode_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingMathRoundWithAwayFromZeroMode(testCases); + int[] expected = [3, 2, 2, 1, -1, -2, -2, -3]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingMathRoundWithToZeroMode_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingMathRoundWithToZeroMode(testCases); + int[] expected = [2, 1, 1, 1, -1, -1, -1, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingMathRoundWithToNegativeInfinityMode_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingMathRoundWithToNegativeInfinityMode(testCases); + int[] expected = [2, 1, 1, 1, -2, -2, -2, -3]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingMathRoundWithToPositiveInfinityMode_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingMathRoundWithToPositiveInfinityMode(testCases); + int[] expected = [3, 2, 2, 2, -1, -1, -1, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingConvertToInt32_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingConvertToInt32(testCases); + int[] expected = [2, 2, 2, 1, -1, -2, -2, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingCasting_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingCasting(testCases); + int[] expected = [2, 1, 1, 1, -1, -1, -1, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUsingSubtractionWithModulo_ThenCorrectResult() + { + var result = RoundingMethods.RoundDownUsingSubtractionWithModulo(testCases); + int[] expected = [2, 1, 1, 1, -1, -1, -1, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + public void WhenRoundingUpUsingMathCeiling_ThenCorrectResult() + { + var result = RoundingMethods.RoundUpUsingMathCeiling(testCases); + int[] expected = [3, 2, 2, 2, -1, -1, -1, -2]; + + CollectionAssert.AreEqual(expected, result); + } + + [TestMethod] + [DataRow(7, 2, 3)] + [DataRow(-7, 2, -4)] + [DataRow(7, -2, -4)] + [DataRow(-7, -2, 3)] + [DataRow(-6, 2, -3)] + public void WhenDividingAndRoundingDown_ThenResultIsFloorOfQuotient(int dividend, int divisor, int expected) + { + Assert.AreEqual(expected, RoundingMethods.DivideAndRoundDown(dividend, divisor)); + } + + [TestMethod] + public void WhenIntegerDividingNegativeNumber_ThenResultIsTruncatedTowardZero() + { + var dividend = -7; + var divisor = 2; + + Assert.AreEqual(-3, dividend / divisor); + } + + [TestMethod] + public void WhenCastingOutOfRangeValue_ThenResultSaturates() + { + var tooBig = 1e10; + var notANumber = double.NaN; + + Assert.AreEqual(int.MaxValue, (int)tooBig); + Assert.AreEqual(int.MinValue, (int)-tooBig); + Assert.AreEqual(0, (int)notANumber); + } + + [TestMethod] + public void WhenConvertingOutOfRangeValue_ThenOverflowExceptionIsThrown() { - private double[] testCases = new double[] { 2.5, 1.75, 1.5, 1.25, -1.25, -1.5, -1.75, -2.5 }; - - [TestMethod] - public void WhenRoundingUsingMathFloor_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingMathFloor(testCases); - var expected = new int[] { 2, 1, 1, 1, -2, -2, -2, -3 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingMathTruncate_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingMathTruncate(testCases); - var expected = new int[] { 2, 1, 1, 1, -1, -1, -1, -2 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingMathRoundWithToEvenMode_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingMathRoundWithToEvenMode(testCases); - var expected = new int[] { 2, 2, 2, 1, -1, -2, -2, -2 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingMathRoundWithAwayFromZeroMode_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingMathRoundWithAwayFromZeroMode(testCases); - var expected = new int[] { 3, 2, 2, 1, -1, -2, -2, -3 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingMathRoundWithToZeroMode_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingMathRoundWithToZeroMode(testCases); - var expected = new int[] { 2, 1, 1, 1, -1, -1, -1, -2 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingMathRoundWithToNegativeInfinityMode_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingMathRoundWithToNegativeInfinityMode(testCases); - var expected = new int[] { 2, 1, 1, 1, -2, -2, -2, -3 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingMathRoundWithToPositiveInfinityMode_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingMathRoundWithToPositiveInfinityMode(testCases); - var expected = new int[] { 3, 2, 2, 2, -1, -1, -1, -2 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingConvertToInt32_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingConvertToInt32(testCases); - var expected = new int[] { 2, 2, 2, 1, -1, -2, -2, -2 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingCasting_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingCasting(testCases); - var expected = new int[] { 2, 1, 1, 1, -1, -1, -1, -2 }; - - CollectionAssert.AreEqual(expected, result); - } - - [TestMethod] - public void WhenRoundingUsingSubtractionWithModulo_ThenCorrectResult() - { - var result = RoundingMethods.RoundDownUsingSubtractionWithModulo(testCases); - var expected = new int[] { 2, 1, 1, 1, -1, -1, -1, -2 }; - - CollectionAssert.AreEqual(expected, result); - } + Assert.ThrowsExactly(() => Convert.ToInt32(1e10)); } -} \ No newline at end of file +} diff --git a/numbers-csharp/RoundDownToNearestInteger/Tests/Tests.csproj b/numbers-csharp/RoundDownToNearestInteger/Tests/Tests.csproj index 4e3f8df184..658ef2d324 100644 --- a/numbers-csharp/RoundDownToNearestInteger/Tests/Tests.csproj +++ b/numbers-csharp/RoundDownToNearestInteger/Tests/Tests.csproj @@ -1,7 +1,7 @@ - net7.0 + net10.0 enable enable @@ -10,10 +10,10 @@ - - - - + + + +