fixes

Author: petesramek

src/PolylineAlgorithm/Abstraction/AbstractPolylineDecoder.cs

@@ -9,13 +9,8 @@ namespace PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm;
 using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Internal.Logging;
-using PolylineAlgorithm.Properties;
 using System;
-using System.Globalization;
 using System.Runtime.CompilerServices;
-#if NET8_0_OR_GREATER
-using System.Text;
-#endif
 
 /// <summary>
 /// Decodes encoded polyline strings into sequences of geographic coordinates.
@@ -25,13 +20,6 @@ namespace PolylineAlgorithm.Abstraction;
 /// This abstract class provides a base implementation for decoding polylines, allowing subclasses to define how to handle specific polyline formats.
 /// </remarks>
 public abstract class AbstractPolylineDecoder<TPolyline, TCoordinate> : IPolylineDecoder<TPolyline, TCoordinate> {
-#if NET8_0_OR_GREATER
-    private static readonly CompositeFormat _polylineCannotBeShorterThanExceptionMessage = CompositeFormat.Parse(ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage);
-#else
-    private static readonly string _polylineCannotBeShorterThanExceptionMessage = ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage;
-#endif
-
-
     private readonly ILogger<AbstractPolylineDecoder<TPolyline, TCoordinate>> _logger;
     /// <summary>
     /// Initializes a new instance of the <see cref="AbstractPolylineDecoder{TPolyline, TCoordinate}"/> class with default encoding options.
@@ -131,7 +119,7 @@ static void ValidateEmptySequence(ReadOnlyMemory<char> polyline, ILogger logger)
                 logger
                     .LogPolylineCannotBeShorterThanWarning(nameof(polyline), polyline.Length, Defaults.Polyline.Block.Length.Min);
 
-                throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, _polylineCannotBeShorterThanExceptionMessage, polyline.Length, Defaults.Polyline.Block.Length.Min), nameof(polyline));
+                throw new ArgumentException(ExceptionMessages.GetPolylineCannotBeShorterThanExceptionMessage(polyline.Length, Defaults.Polyline.Block.Length.Min), nameof(polyline));
             }
         }
     }

src/PolylineAlgorithm/Internal/ExceptionMessages.cs

@@ -0,0 +1,22 @@
+namespace PolylineAlgorithm.Internal;
+
+using PolylineAlgorithm.Properties;
+using System.Globalization;
+
+#if NET8_0_OR_GREATER
+using System.Text;
+#endif
+
+
+[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "Usage and readability.")]
+internal static class ExceptionMessages {
+#if NET8_0_OR_GREATER
+    private static CompositeFormat PolylineCannotBeShorterThanExceptionMessage = CompositeFormat.Parse(ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage);
+#else
+    private static readonly string PolylineCannotBeShorterThanExceptionMessage = ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage;
+#endif
+
+    internal static string GetPolylineCannotBeShorterThanExceptionMessage(int length, int minLength) {
+        return string.Format(CultureInfo.InvariantCulture, PolylineCannotBeShorterThanExceptionMessage, length, minLength);
+    }
+}

src/PolylineAlgorithm/PolylineEncoding.cs

@@ -59,21 +59,26 @@ public static class PolylineEncoding {
     /// <exception cref="OverflowException">
     /// Thrown when the normalized result exceeds the range of a 32-bit signed integer during the conversion from double to int.
     /// </exception>
-    public static int Normalize(double value, uint precision = 5, MidpointRounding rounding = MidpointRounding.AwayFromZero) {
+    public static int Normalize(double value, uint precision = 5) {
+        // Fast return if the value is zero, return 0 as the normalized value.
+        if (value.Equals(default)) {
+            return 0;
+        }
+
         // Validate that the value is finite and not NaN or Infinity.
         if (!double.IsFinite(value)) {
             throw new ArgumentOutOfRangeException(nameof(value), ExceptionMessageResource.ArgumentValueMustBeFiniteNumber);
         }
 
-        // Fast return if the value is zero, return 0 as the normalized value.
-        if (value.Equals(default)) {
-            return 0;
+        // Fast return if precision is zero, return current value converted to Int32.
+        if (precision == 0) {
+            return Convert.ToInt32(value);
         }
 
         uint factor = Pow10.GetFactor(precision);
 
         checked {
-            return (int)Math.Round(precision == 0 ? value : value * factor, rounding);
+            return (int)Math.Round(value * factor, MidpointRounding.AwayFromZero);
         }
     }
 
@@ -82,12 +87,13 @@ public static int Normalize(double value, uint precision = 5, MidpointRounding r
     /// </summary>
     /// <remarks>
     /// <para>
-    /// This method reverses the normalization process performed by <see cref="Normalize"/>. It takes an integer value and converts it
-    /// to a double by dividing it by 10 raised to the power of the specified precision. If the precision is 0, the value is returned as a double
-    /// without division.
+    /// This method reverses the normalization performed by <see cref="Normalize"/>. It takes an integer value and converts it
+    /// to a double by dividing by 10 raised to the power of the specified precision. If <paramref name="precision"/> is 0,
+    /// the value is returned as a double without division.
     /// </para>
     /// <para>
-    /// The calculation is performed inside a <see langword="checked"/> block to ensure that any arithmetic overflow is detected and an <see cref="OverflowException"/> is thrown.
+    /// The calculation is performed inside a <see langword="checked"/> block to ensure that any arithmetic overflow is detected
+    /// and an <see cref="OverflowException"/> is thrown.
     /// </para>
     /// <para>
     /// For example, with a precision of 5:
@@ -106,21 +112,30 @@ public static int Normalize(double value, uint precision = 5, MidpointRounding r
     /// <param name="precision">
     /// The number of decimal places used during normalization. Default is 5, matching standard polyline encoding precision.
     /// </param>
+    /// <param name="rounding">
+    /// The rounding strategy to use when converting the result to a double. Default is <see cref="MidpointRounding.AwayFromZero"/>.
+    /// </param>
     /// <returns>
     /// The denormalized floating-point coordinate value.
     /// </returns>
     /// <exception cref="OverflowException">
     /// Thrown if the arithmetic operation overflows during conversion.
     /// </exception>
     public static double Denormalize(int value, uint precision = 5) {
-        if (value == 0) {
-            return 0.0;
+        if (value.Equals(default)) {
+            return default;
+        }
+
+        // Fast return if precision is zero, return current value converted to Int32.
+        if (precision == 0) {
+            return Convert.ToDouble(value);
         }
 
         uint factor = Pow10.GetFactor(precision);
 
         checked {
-            return precision == 0 ? value : (double)value / factor;
+
+            return value / (double)factor;
         }
     }
 

src/PolylineAlgorithm/Pow10.cs

@@ -13,7 +13,7 @@ public static class Pow10 {
     /// <summary>
     /// Pre-computed powers of 10 from 10^0 to 10^9.
     /// </summary>
-    private static readonly uint[] _pow10 = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+    private static readonly uint[] _pow10 = {/* 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000*/ };
 
     /// <summary>
     /// Gets the multiplication factor for a given precision level.

tests/PolylineAlgorithm.Tests/PolylineEncodingTest.cs

@@ -36,49 +36,52 @@ public class PolylineEncodingTest {
         (-16777215,"|~~~^"),
     ];
 
-    public static IEnumerable<(double denormalized, int normalized, uint precision)> DenormalizedNormalizedPairs => [
-        (0, 0, 5),
+    public static IEnumerable<(int normalized, double expected, uint precision)> NormalizedValues => [
+        (0, 0.0, 0),
+        (123456, 123456.0, 0),
+        (-123456, -123456.0, 0),
+        (90, 90.0, 0),
+        (-90, -90.0, 0),
+        ( 0, 0.00,2),
+        (123456, 1234.56, 2),
+        (-123456, -1234.56, 2),
+        (9000, 90.00, 2),
+        (-9000, -90.00, 2),
+        (0, 0.0, 5),
+        (123456789, 1234.56789, 5),
+        (-123456789, -1234.56789, 5),
+        (900000000, 9000, 5),
+        (-900000000,-9000, 5),
+    ];
+
+    public static IEnumerable<(double denormalized, int expected, uint precision)> DenormalizedValues => [
+        (0, 0, 0),
+        (1.23456, 1, 0),
+        (-1.23456789, -1, 0),
+        (90, 90, 0),
+        (-90, -90, 0),
+        (0, 0, 2),
+        (1.23456, 123, 2),
+        (-1.23456789, -123, 2),
+        (90, 9000, 2),
+        (-90, -9000, 2),
         (0, 0, 5),
-        (1.23456, 123456, 5),
+        (1.23456789, 123456, 5),
         (-1.23456789, -123456, 5),
-        (1.23456789, 12, 2),
-        (-1.23456789, -12, 2),
+        (1.23456789, 123456, 5),
         (90, 9000000, 5),
-        (-90, -900000, 5),
-        (90, 900, 2),
-        (-90, -900, 2),
+        (-90, -9000000, 5),
     ];
 
-    public static IEnumerable<(double denormalized, CoordinateValueType)> DenormalizedOutOfRangeValues => [
-        (90.00001,CoordinateValueType.Latitude),
-        (-90.00001,CoordinateValueType.Latitude),
-        (180.00001,CoordinateValueType.Longitude),
-        (-180.00001,CoordinateValueType.Longitude),
-        (double.NaN,CoordinateValueType.Latitude),
-        (double.NaN,CoordinateValueType.Longitude),
-        (double.MinValue,CoordinateValueType.Latitude),
-        (double.MaxValue,CoordinateValueType.Latitude),
-        (double.MinValue,CoordinateValueType.Longitude),
-        (double.MaxValue,CoordinateValueType.Longitude),
-        (double.NegativeInfinity,CoordinateValueType.Latitude),
-        (double.PositiveInfinity,CoordinateValueType.Latitude),
-        (double.NegativeInfinity,CoordinateValueType.Longitude),
-        (double.PositiveInfinity,CoordinateValueType.Longitude),
-        (0, CoordinateValueType.Unspecified),
-        (0, CoordinateValueType.Unspecified),
+    public static IEnumerable<object[]> DoubleNotFiniteValues => [
+        [double.NaN],
+        [double.NegativeInfinity],
+        [double.PositiveInfinity],
     ];
 
-    public static IEnumerable<(int normalized, CoordinateValueType)> NormalizedOutOfRangeValues => [
-        (9000001,CoordinateValueType.Latitude),
-        (-9000001,CoordinateValueType.Latitude),
-        (18000001,CoordinateValueType.Longitude),
-        (-18000001,CoordinateValueType.Longitude),
-        (int.MinValue,CoordinateValueType.Latitude),
-        (int.MaxValue,CoordinateValueType.Latitude),
-        (int.MinValue,CoordinateValueType.Longitude),
-        (int.MaxValue,CoordinateValueType.Longitude),
-        (0, CoordinateValueType.Unspecified),
-        (0, CoordinateValueType.Unspecified),
+    public static IEnumerable<object[]> DoubleMinMaxValues => [
+        [double.MinValue],
+        [double.MaxValue],
     ];
 
     public static IEnumerable<(int delta, int bufferSize)> DeltaBufferSizePairs => [
@@ -110,7 +113,7 @@ public class PolylineEncodingTest {
     #endregion
 
     [TestMethod]
-    [DynamicData(nameof(DenormalizedNormalizedPairs))]
+    [DynamicData(nameof(DenormalizedValues))]
     public void Normalize_Equals_Expected(double denormalized, int expected, uint precision) {
         // Arrange & Act
         int result = PolylineEncoding.Normalize(denormalized, precision);
@@ -121,8 +124,8 @@ public void Normalize_Equals_Expected(double denormalized, int expected, uint pr
 
 
     [TestMethod]
-    [DynamicData(nameof(DenormalizedNormalizedPairs))]
-    public void Denormalize_Equals_Expected(double expected, int normalized, uint precision) {
+    [DynamicData(nameof(NormalizedValues))]
+    public void Denormalize_Equals_Expected(int normalized, double expected, uint precision) {
         // Arrange & Act
         double result = PolylineEncoding.Denormalize(normalized, precision);
 
@@ -230,7 +233,7 @@ public void TryReadValue_MalformedBuffer_Returns_False() {
     }
 
     [TestMethod]
-    [DynamicData(nameof(DenormalizedOutOfRangeValues))]
+    [DynamicData(nameof(DoubleNotFiniteValues))]
     public void Normalize_Throws_ArgumentOutOfRangeException(double value) {
         // Arrange
         static int Normalize(double value) => PolylineEncoding.Normalize(value);
@@ -243,21 +246,21 @@ public void Normalize_Throws_ArgumentOutOfRangeException(double value) {
     }
 
     [TestMethod]
-    [DynamicData(nameof(NormalizedOutOfRangeValues))]
-    public void Denormalize_Throws_ArgumentOutOfRangeException(int value) {
+    [DynamicData(nameof(DoubleMinMaxValues))]
+    public void Normalize_Throws_OverflowException(double value) {
         // Arrange
-        static double Denormalize(int value) => PolylineEncoding.Denormalize(value);
+        static int Normalize(double value) => PolylineEncoding.Normalize(value);
 
         // Act
-        var exception = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Denormalize(value));
+        var exception = Assert.ThrowsExactly<OverflowException>(() => Normalize(value));
 
         // Assert
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
 
     [TestMethod]
     [DynamicData(nameof(DeltaBufferSizePairs))]
-    public void GetCharCount_Equals_Expected(int delta, int expected) {
+    public void GetRequiredBufferSize_Equals_Expected(int delta, int expected) {
         // Arrange & Act
         var bufferSize = PolylineEncoding.GetRequiredBufferSize(delta);