added test

Author: petesramek

src/PolylineAlgorithm.Abstraction/PolylineEncoding.cs

@@ -95,7 +95,7 @@ public static double Denormalize(int value, ValueType type) {
     /// <param name="type">The type of value to validate, such as <see cref="ValueType.Latitude"/> or <see cref="ValueType.Longitude"/>.</param>
     /// <returns><see langword="true"/> if the normalized value is within the valid range for the specified value type;
     /// otherwise, <see langword="false"/>.</returns>
-    public static bool ValidateNormalizedValue(int value, ValueType type) => (type, value) switch {
+    private static bool ValidateNormalizedValue(int value, ValueType type) => (type, value) switch {
         (ValueType.Latitude, int normalized) when normalized >= Defaults.Coordinate.Latitude.Normalized.Min && normalized <= Defaults.Coordinate.Latitude.Normalized.Max => true,
         (ValueType.Longitude, int normalized) when normalized >= Defaults.Coordinate.Longitude.Normalized.Min && normalized <= Defaults.Coordinate.Longitude.Normalized.Max => true,
         _ => false,
@@ -111,7 +111,7 @@ public static double Denormalize(int value, ValueType type) {
     /// <param name="type">The type of value to validate, such as latitude or longitude.</param>
     /// <returns><see langword="true"/> if the <paramref name="value"/> is within the valid range for the specified <paramref
     /// name="type"/>; otherwise, <see langword="false"/>.</returns>
-    public static bool ValidateDenormalizedValue(double value, ValueType type) => (type, value) switch {
+    private static bool ValidateDenormalizedValue(double value, ValueType type) => (type, value) switch {
         (ValueType.Latitude, double denormalized) when denormalized >= Defaults.Coordinate.Latitude.Min && denormalized <= Defaults.Coordinate.Latitude.Max => true,
         (ValueType.Longitude, double denormalized) when denormalized >= Defaults.Coordinate.Longitude.Min && denormalized <= Defaults.Coordinate.Longitude.Max => true,
         _ => false,

src/PolylineAlgorithm/Polyline.cs

@@ -75,7 +75,7 @@ public override string ToString() {
             return string.Empty;
         }
 
-        return Value.ToString() ?? string.Empty;
+        return Value.ToString();
     }
 
     /// <summary>

…Abstraction.Tests/PolylineDecoderTest.cs …ion.Tests/AbstractPolylineDecoderTest.cstests/PolylineAlgorithm.Abstraction.Tests/PolylineDecoderTest.cs renamed to tests/PolylineAlgorithm.Abstraction.Tests/AbstractPolylineDecoderTest.cs tests/PolylineAlgorithm.Abstraction.Tests/PolylineDecoderTest.cs renamed to tests/PolylineAlgorithm.Abstraction.Tests/AbstractPolylineDecoderTest.cs

@@ -6,7 +6,7 @@
 using System;
 
 [TestClass]
-public class PolylineDecoderTest {
+public class AbstractPolylineDecoderTest {
     private static readonly PolylineDecoder _decoder = new PolylineDecoder();
 
     public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
@@ -28,7 +28,7 @@ public void Constructor_Parameterless_Ok() {
     }
 
     [TestMethod]
-    public void Constructor_ValidOptions_Ok() {
+    public void Constructor_Options_Instance_Ok() {
         // Arrange
         var options = new PolylineEncodingOptions();
 
@@ -40,6 +40,19 @@ public void Constructor_ValidOptions_Ok() {
         Assert.AreSame(options, decoder.Options);
     }
 
+    [TestMethod]
+    public void Constructor_Null_Options_Throws_ArgumentNullException() {
+        // Arrange
+        void New() => new PolylineDecoder(null!);
+
+        // Act
+        var exception = Assert.ThrowsExactly<ArgumentNullException>(New);
+
+        // Assert
+        Assert.AreEqual("options", exception.ParamName);
+        Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
+    }
+
     [TestMethod]
     public void Decode_NullPolyline_Throws_ArgumentException() {
         // Arrange

…Abstraction.Tests/PolylineEncoderTest.cs …ion.Tests/AbstractPolylineEncoderTest.cstests/PolylineAlgorithm.Abstraction.Tests/PolylineEncoderTest.cs renamed to tests/PolylineAlgorithm.Abstraction.Tests/AbstractPolylineEncoderTest.cs tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncoderTest.cs renamed to tests/PolylineAlgorithm.Abstraction.Tests/AbstractPolylineEncoderTest.cs

@@ -5,7 +5,7 @@
 using System;
 
 [TestClass]
-public class PolylineEncoderTest {
+public class AbstractPolylineEncoderTest {
     private static readonly PolylineEncoder _encoder = new PolylineEncoder();
 
     public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
@@ -38,6 +38,20 @@ public void Constructor_ValidOptions_Ok() {
         Assert.AreSame(options, encoder.Options);
     }
 
+
+    [TestMethod]
+    public void Constructor_Null_Options_Throws_ArgumentNullException() {
+        // Arrange
+        void New() => new PolylineEncoder(null!);
+
+        // Act
+        var exception = Assert.ThrowsExactly<ArgumentNullException>(New);
+
+        // Assert
+        Assert.AreEqual("options", exception.ParamName);
+        Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
+    }
+
     [TestMethod]
     public void Encode_NullCoordinates_Throws_ArgumentException() {
         // Arrange

tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncodingOptionsTest.cs

@@ -3,7 +3,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Logging.Testing;
-using static PolylineAlgorithm.Abstraction.Tests.PolylineEncoderTest;
+using static PolylineAlgorithm.Abstraction.Tests.AbstractPolylineEncoderTest;
 
 [TestClass]
 public class PolylineEncodingOptionsTest {

tests/PolylineAlgorithm.Abstraction.Tests/PolylineOptionsBuilderTest.cs

@@ -32,6 +32,21 @@ public void Build_Returns_Instance_With_Default_Values() {
         Assert.AreEqual(loggerFactory, options.LoggerFactory);
     }
 
+    [TestMethod]
+    public void WithBufferSize_Small_BufferSize_Parameter_Returns_Throws_ArgumentOutOfRangeException() {
+        // Arrange
+        void WithSmallBufferSize() => PolylineEncodingOptionsBuilder.Create()
+            .WithBufferSize(11);
+
+        // Act
+        var exception = Assert.ThrowsException<ArgumentOutOfRangeException>(WithSmallBufferSize);
+
+        // Assert
+        Assert.IsNotNull(exception);
+        Assert.AreEqual("maxBufferSize", exception.ParamName);
+        Assert.IsTrue(exception.Message.Contains("Buffer size must be greater than 11."));
+    }
+
     [TestMethod]
     public void Build_Returns_Instance_With_Expected_Buffer_Size() {
         // Arrange
@@ -64,4 +79,19 @@ public void Build_Returns_Instance_With_Expected_LoggerFactory() {
         Assert.IsNotNull(options);
         Assert.AreEqual(expected, options.LoggerFactory);
     }
+
+    [TestMethod]
+    public void WithLoggerFactory_Null_Parameter_Returns_Throws_ArgumentNullException() {
+        // Arrange
+        void WithNullLoggerFactory() => PolylineEncodingOptionsBuilder.Create()
+            .WithLoggerFactory(null!);
+
+        // Act
+        var exception = Assert.ThrowsException<ArgumentNullException>(WithNullLoggerFactory);
+
+        // Assert
+        Assert.IsNotNull(exception);
+        Assert.AreEqual("loggerFactory", exception.ParamName);
+        Assert.IsTrue(exception.Message.Contains("Logger factory cannot be null."));
+    }
 }

tests/PolylineAlgorithm.Tests/PolylineTest.cs

@@ -254,6 +254,7 @@ public void Equality_Operators_Correct_Results() {
         Polyline polyline = Polyline.FromString(nameof(polyline));
         Polyline equal = Polyline.FromString(nameof(polyline));
         Polyline notEqual = Polyline.FromString(nameof(notEqual));
+        Polyline empty = new Polyline();
         string typeNotEqual = "not a polyline";
 
         // Act && Assert
@@ -266,6 +267,8 @@ public void Equality_Operators_Correct_Results() {
         Assert.IsTrue(polyline.Equals(equal));
         Assert.IsTrue(polyline.Equals((object)equal));
 
+        Assert.IsFalse(polyline.Equals(empty));
+        Assert.IsFalse(polyline.Equals(notEqual));
         Assert.IsFalse(polyline.Equals((object)notEqual));
         Assert.IsFalse(polyline.Equals(typeNotEqual));
     }