fix: update remaining coordinate references in code, log messages, and tests

Agent-Logs-Url: https://github.com/petesramek/polyline-algorithm-csharp/sessions/a91e90b4-cfd4-4daa-8202-ce52524fb335

Co-authored-by: petesramek <2333452+petesramek@users.noreply.github.com>

Author: Copilot

src/PolylineAlgorithm/Internal/Defaults.cs

@@ -53,7 +53,7 @@ internal static class Algorithm {
     /// <summary>
     /// Contains default values and constants for geographic value validation.
     /// </summary>
-    internal static class Coordinate {
+    internal static class Value {
         /// <summary>
         /// Provides constants representing latitude values, including the default, minimum, and maximum valid values.
         /// </summary>

src/PolylineAlgorithm/Internal/Diagnostics/ExceptionGuard.cs

@@ -82,8 +82,8 @@ internal static void ThrowBufferOverflow(string message) {
     [MethodImpl(MethodImplOptions.NoInlining)]
 #endif
     [DoesNotReturn]
-    internal static void ThrowCoordinateValueOutOfRange(double value, double min, double max, string paramName) {
-        throw new ArgumentOutOfRangeException(paramName, ExceptionMessage.FormatCoordinateValueMustBeBetween(paramName, min, max));
+    internal static void ThrowValueOutOfRange(double value, double min, double max, string paramName) {
+        throw new ArgumentOutOfRangeException(paramName, ExceptionMessage.FormatValueMustBeBetween(paramName, min, max));
     }
 
     /// <summary>
@@ -271,7 +271,7 @@ internal static string FormatMalformedPolyline(long position) =>
         /// <summary>
         /// Formats a message indicating a value parameter must be within a range.
         /// </summary>
-        internal static string FormatCoordinateValueMustBeBetween(string name, double min, double max) =>
+        internal static string FormatValueMustBeBetween(string name, double min, double max) =>
             string.Format(CultureInfo.InvariantCulture, CoordinateValueMustBeBetweenFormat, name, min, max);
 
         /// <summary>

src/PolylineAlgorithm/Internal/Diagnostics/LogDebugExtensions.cs

@@ -52,6 +52,6 @@ internal static partial class LogDebugExtensions {
     /// <param name="latitude">The decoded latitude value.</param>
     /// <param name="longitude">The decoded longitude value.</param>
     /// <param name="position">The position in the polyline buffer at which the value was decoded.</param>
-    [LoggerMessage(EVENT_ID_BASE + 4, LOG_LEVEL, "Decoded coordinate: (Latitude: {latitude}, Longitude: {longitude}) at position {position}.")]
+    [LoggerMessage(EVENT_ID_BASE + 4, LOG_LEVEL, "Decoded value: (Latitude: {latitude}, Longitude: {longitude}) at position {position}.")]
     internal static partial void LogDecodedCoordinateDebug(this ILogger logger, double latitude, double longitude, int position);
 }

tests/PolylineAlgorithm.Tests/Extensions/PolylineEncoderExtensionsTests.cs

@@ -59,7 +59,7 @@ public void Encode_With_Array_Null_Coordinates_Throws_ArgumentNullException() {
         // Act & Assert
         ArgumentNullException ex = Assert.ThrowsExactly<ArgumentNullException>(
             () => PolylineEncoderExtensions.Encode<(double, double), string>(encoder, coordinates!));
-        Assert.AreEqual("coordinates", ex.ParamName);
+        Assert.AreEqual("values", ex.ParamName);
     }
 
     /// <summary>

tests/PolylineAlgorithm.Tests/Internal/Diagnostics/ExceptionGuardTests.cs

@@ -54,18 +54,18 @@ public void ThrowBufferOverflow_With_Message_Throws_OverflowException() {
     }
 
     /// <summary>
-    /// Tests that ThrowCoordinateValueOutOfRange throws ArgumentOutOfRangeException with correct parameter name.
+    /// Tests that ThrowValueOutOfRange throws ArgumentOutOfRangeException with correct parameter name.
     /// </summary>
     [TestMethod]
-    public void ThrowCoordinateValueOutOfRange_With_Parameters_Throws_ArgumentOutOfRangeException() {
+    public void ThrowValueOutOfRange_With_Parameters_Throws_ArgumentOutOfRangeException() {
         // Arrange
         const double value = 100.0;
         const double min = -90.0;
         const double max = 90.0;
         const string paramName = "latitude";
 
         // Act & Assert
-        var ex = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => ExceptionGuard.ThrowCoordinateValueOutOfRange(value, min, max, paramName));
+        var ex = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => ExceptionGuard.ThrowValueOutOfRange(value, min, max, paramName));
         Assert.AreEqual(paramName, ex.ParamName);
         Assert.IsNotNull(ex.Message);
     }
@@ -288,17 +288,17 @@ public void FormatMalformedPolyline_With_Large_Position_Returns_Formatted_Messag
     }
 
     /// <summary>
-    /// Tests that FormatCoordinateValueMustBeBetween returns formatted message with all parameters.
+    /// Tests that FormatValueMustBeBetween returns formatted message with all parameters.
     /// </summary>
     [TestMethod]
-    public void FormatCoordinateValueMustBeBetween_With_Parameters_Returns_Formatted_Message() {
+    public void FormatValueMustBeBetween_With_Parameters_Returns_Formatted_Message() {
         // Arrange
         const string name = "latitude";
         const double min = -90.0;
         const double max = 90.0;
 
         // Act
-        string result = ExceptionGuard.ExceptionMessage.FormatCoordinateValueMustBeBetween(name, min, max);
+        string result = ExceptionGuard.ExceptionMessage.FormatValueMustBeBetween(name, min, max);
 
         // Assert
         Assert.IsNotNull(result);
@@ -308,17 +308,17 @@ public void FormatCoordinateValueMustBeBetween_With_Parameters_Returns_Formatted
     }
 
     /// <summary>
-    /// Tests that FormatCoordinateValueMustBeBetween with positive values returns formatted message.
+    /// Tests that FormatValueMustBeBetween with positive values returns formatted message.
     /// </summary>
     [TestMethod]
-    public void FormatCoordinateValueMustBeBetween_With_Positive_Values_Returns_Formatted_Message() {
+    public void FormatValueMustBeBetween_With_Positive_Values_Returns_Formatted_Message() {
         // Arrange
         const string name = "longitude";
         const double min = 0.0;
         const double max = 180.0;
 
         // Act
-        string result = ExceptionGuard.ExceptionMessage.FormatCoordinateValueMustBeBetween(name, min, max);
+        string result = ExceptionGuard.ExceptionMessage.FormatValueMustBeBetween(name, min, max);
 
         // Assert
         Assert.IsNotNull(result);
@@ -328,17 +328,17 @@ public void FormatCoordinateValueMustBeBetween_With_Positive_Values_Returns_Form
     }
 
     /// <summary>
-    /// Tests that FormatCoordinateValueMustBeBetween with fractional values returns formatted message.
+    /// Tests that FormatValueMustBeBetween with fractional values returns formatted message.
     /// </summary>
     [TestMethod]
-    public void FormatCoordinateValueMustBeBetween_With_Fractional_Values_Returns_Formatted_Message() {
+    public void FormatValueMustBeBetween_With_Fractional_Values_Returns_Formatted_Message() {
         // Arrange
         const string name = "value";
         const double min = 1.5;
         const double max = 10.75;
 
         // Act
-        string result = ExceptionGuard.ExceptionMessage.FormatCoordinateValueMustBeBetween(name, min, max);
+        string result = ExceptionGuard.ExceptionMessage.FormatValueMustBeBetween(name, min, max);
 
         // Assert
         Assert.IsNotNull(result);

tests/PolylineAlgorithm.Tests/Internal/Diagnostics/LogDebugExtensionsTests.cs

@@ -93,7 +93,7 @@ public void LogDecodedCoordinateDebug_With_Coordinates_And_Position_Logs_Decoded
 
         Assert.HasCount(1, logger.Logs);
         Assert.AreEqual(LogLevel.Debug, logger.Logs[0].Level);
-        Assert.Contains(string.Create(CultureInfo.InvariantCulture, $"Decoded coordinate: (Latitude: {latitude}, Longitude: {longitude}) at position {position}."), logger.Logs[0].Message, StringComparison.Ordinal);
+        Assert.Contains(string.Create(CultureInfo.InvariantCulture, $"Decoded value: (Latitude: {latitude}, Longitude: {longitude}) at position {position}."), logger.Logs[0].Message, StringComparison.Ordinal);
     }
 
     /// <summary>
@@ -155,7 +155,7 @@ public void LogDecodedCoordinateDebug_With_Zero_Coordinates_Logs_Message() {
 
         Assert.HasCount(1, logger.Logs);
         Assert.AreEqual(LogLevel.Debug, logger.Logs[0].Level);
-        Assert.Contains("Decoded coordinate", logger.Logs[0].Message, StringComparison.Ordinal);
+        Assert.Contains("Decoded value", logger.Logs[0].Message, StringComparison.Ordinal);
     }
 
     /// <summary>

tests/PolylineAlgorithm.Tests/Internal/Diagnostics/LogWarningExtensionsTests.cs

@@ -69,7 +69,7 @@ public void LogInternalBufferOverflowWarning_Logs_Expected_Message() {
     public void LogCannotWriteValueToBufferWarning_Logs_Expected_Message() {
         var logger = new TestLogger();
         logger.LogCannotWriteValueToBufferWarning(4, 5);
-        Assert.IsTrue(logger.Logs.Exists(l => l.Message.Contains("Cannot write to internal buffer at position 4. Current coordinate is at index 5.", StringComparison.Ordinal)));
+        Assert.IsTrue(logger.Logs.Exists(l => l.Message.Contains("Cannot write to internal buffer at position 4. Current value is at index 5.", StringComparison.Ordinal)));
     }
 
     /// <summary>