updated tests

Author: petesramek

tests/PolylineAlgorithm.Abstraction.Tests/InvalidPolylineExceptionTest.cs

@@ -21,8 +21,10 @@ public void Throw_Method_Invalid_Coordinate_Parameter_PolylineMalformedException
         var position = Random.Shared.Next();
         static void ThrowAt(int position) => InvalidPolylineException.Throw(position);
 
-        // Act && Assert
+        // Act
         var exception = Assert.ThrowsExactly<InvalidPolylineException>(() => ThrowAt(position));
+
+        // Assert
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
         Assert.IsTrue(exception.Message.Contains(position.ToString()));
     }

tests/PolylineAlgorithm.Abstraction.Tests/PolylineAlgorithm.Abstraction.Tests.csproj

@@ -40,6 +40,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\PolylineAlgorithm.Abstraction\PolylineAlgorithm.Abstraction.csproj" />
+    <ProjectReference Include="..\..\utilities\PolylineAlgorithm.Utility\PolylineAlgorithm.Utility.csproj" />
   </ItemGroup>
 
 </Project>

tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncoderTest.cs

@@ -1,24 +1,73 @@
 namespace PolylineAlgorithm.Abstraction.Tests;
 
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Testing;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using PolylineAlgorithm.Utility;
 using System;
 
 [TestClass]
 public class PolylineEncoderTest {
-    internal static readonly FakeLoggerProvider loggerProvider = new();
+    private static readonly PolylineEncoder _encoder = new PolylineEncoder();
+
+    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
+
+    [TestMethod]
+    public void Encode_NullCoordinates_Throws_ArgumentException() {
+        // Arrange
+        void Encode() => _encoder.Encode(null!);
+
+        // Act
+        var exception = Assert.ThrowsExactly<ArgumentNullException>(Encode);
+
+        // Assert
+        Assert.AreEqual("coordinates", exception.ParamName);
+        Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
+    }
+
+    [TestMethod]
+    public void Encode_EmptyCoordinates_Throws_ArgumentException() {
+        // Arrange
+        void Encode() => _encoder.Encode(Array.Empty<(double Latitude, double Longitude)>());
+
+        // Act
+        var exception = Assert.ThrowsExactly<ArgumentException>(Encode);
+
+        // Assert
+        Assert.AreEqual("coordinates", exception.ParamName);
+        Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
+    }
 
     [TestMethod]
-    public void TestEncodeEmptyCollection() {
-        var encoder = new PolylineEncoder(new() { LoggerFactory = new FakeLoggerFactory(loggerProvider) });
-       void Encode() => encoder.Encode(Array.Empty<(double Latitude, double Longitude)>());
-        var exception = Assert.ThrowsExactly<ArgumentException>(Encode, "The input collection cannot be empty.");
-        ///loggerProvider.Collector.LatestRecord,(exception, LogLevel.Error, "Argument cannot be empty enumeration");
+    [DynamicData(nameof(CoordinateCount))]
+    public void Encode_RandomValue_ValidInput_Ok(int count) {
+        // Arrange
+        IEnumerable<(double Latitude, double Longitude)> coordinates = RandomValueProvider.GetCoordinates(count);
+        string expected = RandomValueProvider.GetPolyline(count);
+
+        // Act
+        var result = _encoder.Encode(coordinates);
+
+        // Assert
+        Assert.AreEqual(expected.Length, result.Length);
+        Assert.IsTrue(expected.Equals(result));
+    }
+
+    [TestMethod]
+    public void Encode_StaticValue_ValidInput_Ok() {
+        // Arrange
+        IEnumerable<(double Latitude, double Longitude)> coordinates = StaticValueProvider.GetCoordinates();
+        string expected = StaticValueProvider.GetPolyline();
+
+        // Act
+        var result = _encoder.Encode(coordinates);
+
+        // Assert
+        Assert.AreEqual(expected.Length, result.Length);
+        Assert.IsTrue(expected.Equals(result));
     }
 
     public class PolylineEncoder : PolylineEncoder<(double Latitude, double Longitude), string> {
-        public PolylineEncoder(PolylineEncodingOptions options) : base(options) { }
+        public PolylineEncoder()
+            : base(new()) { }
 
         protected override string CreatePolyline(ReadOnlyMemory<char> polyline) => polyline.ToString();
         protected override double GetLatitude((double Latitude, double Longitude) coordinate) => coordinate.Latitude;

tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncodingTest.cs

@@ -227,8 +227,10 @@ public void Normalize_Throws_ArgumentOutOfRangeException(double value, PolylineE
         // Arrange
         static int Normalize(double value, PolylineEncoding.ValueType type) => PolylineEncoding.Normalize(value, type);
 
-        // Act & Assert
+        // Act
         var exception = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Normalize(value, type));
+
+        // Assert
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
 
@@ -238,8 +240,10 @@ public void Denormalize_Throws_ArgumentOutOfRangeException(int value, PolylineEn
         // Arrange
         static double Denormalize(int value, PolylineEncoding.ValueType type) => PolylineEncoding.Denormalize(value, type);
 
-        // Act & Assert
+        // Act
         var exception = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Denormalize(value, type));
+
+        // Assert
         Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
 

tests/PolylineAlgorithm.Tests/PolylineEncoderTest.cs

@@ -57,7 +57,7 @@ public void Encode_EmptyInput_ThrowsException() {
     /// <remarks>Expected result is that the encoded polyline matches <see cref="Values.Polyline.Valid"/>.</remarks>
     [TestMethod]
     [DynamicData(nameof(CoordinateCount))]
-    public void Random_Value_Encode_ValidInput_Ok(int count) {
+    public void Encode_RandomValue_ValidInput_Ok(int count) {
         // Arrange
         IEnumerable<Coordinate> valid = RandomValueProvider.GetCoordinates(count).Select(c => new Coordinate(c.Latitude, c.Longitude));
         Polyline expected = Polyline.FromString(RandomValueProvider.GetPolyline(count));
@@ -76,7 +76,7 @@ public void Random_Value_Encode_ValidInput_Ok(int count) {
     /// </summary>
     /// <remarks>Expected result is that the encoded polyline matches <see cref="Values.Polyline.Valid"/>.</remarks>
     [TestMethod]
-    public void Static_Value_Encode_ValidInput_Ok() {
+    public void Encode_StaticValue_ValidInput_Ok() {
         // Arrange
         IEnumerable<Coordinate> valid = StaticValueProvider.GetCoordinates().Select(c => new Coordinate(c.Latitude, c.Longitude));
         Polyline expected = Polyline.FromString(StaticValueProvider.GetPolyline());

utilities/PolylineAlgorithm.Utility/PolylineAlgorithm.Utility.csproj

@@ -27,6 +27,9 @@
 		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
 			<_Parameter1>PolylineAlgorithm.Tests</_Parameter1>
 		</AssemblyAttribute>
+		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+			<_Parameter1>PolylineAlgorithm.Abstraction.Tests</_Parameter1>
+		</AssemblyAttribute>
 		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
 			<_Parameter1>PolylineAlgorithm.Benchmarks</_Parameter1>
 		</AssemblyAttribute>