From f27fafc467d0bb50048235c7269bba2a99ee3f91 Mon Sep 17 00:00:00 2001 From: Vladimir Pecanac Date: Sun, 25 Oct 2026 13:25:25 +0100 Subject: [PATCH] Round down to nearest integer: move to .NET 10, add round up and floored division samples Both projects target net10.0, MSTest 4.5.1, Microsoft.NET.Test.Sdk 18.11.0 and coverlet.collector 10.1.0. Adds RoundUpUsingMathCeiling and DivideAndRoundDown with tests, tests for out-of-range casts and Convert.ToInt32 overflow, prints results with the invariant culture, and uses file-scoped namespaces. --- .../OutputRoundingResults.cs | 142 +++++------ .../RoundDownToNearestInteger/Program.cs | 35 ++- .../RoundDownToNearestInteger.csproj | 2 +- .../RoundingMethods.cs | 185 ++++++++------ .../Tests/RoundDownToNearestIntegerTests.cs | 235 +++++++++++------- .../Tests/Tests.csproj | 10 +- 6 files changed, 338 insertions(+), 271 deletions(-) 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 @@ - - - - + + + +