interim commit

Author: Pete Sramek

tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs

@@ -57,10 +57,23 @@ public void Decode_Empty_Input_ThrowsException() {
     /// <remarks>Expected result to equal <see cref="Values.Coordinates.Valid"/>.</remarks>
     [TestMethod]
     [DynamicData(nameof(CoordinateCount))]
-    public void Decode_Valid_Input_Ok(int count) {
+    public void Random_Value_Decode_Valid_Input_Ok(int count) {
         // Arrange
-        IEnumerable<Coordinate> expected = RandomValueProvider.GetCoordinates(1);
-        string value = RandomValueProvider.GetPolyline(1).ToString();
+        IEnumerable<Coordinate> expected = RandomValueProvider.GetCoordinates(count);
+        Polyline value = RandomValueProvider.GetPolyline(count);
+
+        // Act
+        var result = Decoder.Decode(value);
+
+        // Assert
+        CollectionAssert.AreEqual(expected.ToArray(), result.ToArray());
+    }
+
+    [TestMethod]
+    public void Static_Value_Decode_Valid_Input_Ok() {
+        // Arrange
+        IEnumerable<Coordinate> expected = StaticValueProvider.GetCoordinates();
+        Polyline value = StaticValueProvider.GetPolyline();
 
         // Act
         var result = Decoder.Decode(value);

tests/PolylineAlgorithm.Tests/PolylineEncoderTest.cs

@@ -59,7 +59,7 @@ void EncodeEmptyCoordinates() {
     /// <remarks>Expected result is that the encoded polyline matches <see cref="Values.Polyline.Valid"/>.</remarks>
     [TestMethod]
     [DynamicData(nameof(CoordinateCount))]
-    public void Encode_ValidInput_Ok(int count) {
+    public void Random_Value_Encode_ValidInput_Ok(int count) {
         // Arrange
         IEnumerable<Coordinate> valid = RandomValueProvider.GetCoordinates(count);
         Polyline expected = RandomValueProvider.GetPolyline(count);
@@ -72,4 +72,23 @@ public void Encode_ValidInput_Ok(int count) {
         Assert.AreEqual(expected.Length, result.Length);
         Assert.IsTrue(expected.Equals(result));
     }
+
+    /// <summary>
+    /// Tests the <see cref="PolylineEncoder.Encode(IEnumerable{Coordinate})"/> method with a valid input.
+    /// </summary>
+    /// <remarks>Expected result is that the encoded polyline matches <see cref="Values.Polyline.Valid"/>.</remarks>
+    [TestMethod]
+    public void Static_Value_Encode_ValidInput_Ok() {
+        // Arrange
+        IEnumerable<Coordinate> valid = StaticValueProvider.GetCoordinates();
+        Polyline expected = StaticValueProvider.GetPolyline();
+
+        // Act
+        var result = Encoder.Encode(valid);
+
+        // Assert
+        Assert.AreEqual(expected.IsEmpty, result.IsEmpty);
+        Assert.AreEqual(expected.Length, result.Length);
+        Assert.IsTrue(expected.Equals(result));
+    }
 }

utilities/PolylineAlgorithm.Utility/RandomValueProvider.cs

@@ -7,7 +7,7 @@
 
 internal static class RandomValueProvider {
     private static readonly Random _random = new(DateTime.Now.Millisecond);
-    private static readonly ConcurrentDictionary<int, CoordinatePair> _cache = new();
+    private static readonly ConcurrentDictionary<int, PolylineCoordinateCollectionPair> _cache = new();
     private static readonly PolylineEncoder _encoder = new();
 
     public static IEnumerable<Coordinate> GetCoordinates(int count) {
@@ -26,7 +26,7 @@ public static Polyline GetPolyline(int count) {
         return entry.Polyline;
     }
 
-    private static CoordinatePair GetCaheEntry(int count) {
+    private static PolylineCoordinateCollectionPair GetCaheEntry(int count) {
         if (_cache.TryGetValue(count, out var entry)) {
             return entry;
         }
@@ -36,7 +36,7 @@ private static CoordinatePair GetCaheEntry(int count) {
                             .Select(i => new Coordinate(RandomLatitude(), RandomLongitude()))
                             .ToList();
 
-        entry = _cache.GetOrAdd(count, _ => new CoordinatePair(enumeration, _encoder.Encode(enumeration)));
+        entry = _cache.GetOrAdd(count, _ => new PolylineCoordinateCollectionPair(enumeration, _encoder.Encode(enumeration)));
 
         return entry;
     }
@@ -49,13 +49,8 @@ private static double RandomLatitude() {
         return Math.Round(_random.Next(-90, 90) + _random.NextDouble(), 5);
     }
 
-    private readonly struct CoordinatePair {
-        public CoordinatePair(IEnumerable<Coordinate> coordinates, Polyline polyline) {
-            Coordinates = coordinates;
-            Polyline = polyline;
-        }
-
-        public IEnumerable<Coordinate> Coordinates { get; }
-        public Polyline Polyline { get; }
+    private readonly struct PolylineCoordinateCollectionPair(IEnumerable<Coordinate> coordinates, Polyline polyline) {
+        public IEnumerable<Coordinate> Coordinates { get; } = coordinates;
+        public Polyline Polyline { get; } = polyline;
     }
 }

utilities/PolylineAlgorithm.Utility/StaticValueProvider.cs

@@ -0,0 +1,25 @@
+namespace PolylineAlgorithm.Utility;
+
+using System.Collections.Generic;
+
+internal static class StaticValueProvider {
+    private static readonly Polyline _polyline = Polyline.FromString("???_gsia@_cidP??~fsia@?~fsia@~bidP?~bidP??_gsia@");
+    private static readonly IEnumerable<Coordinate> _coordinates = [
+        new (0, 0),
+        new (0, 180),
+        new (90, 180),
+        new (90, 0),
+        new (90, -180),
+        new (0, -180),
+        new (-90, -180),
+        new (-90, 0)
+    ];
+
+    public static IEnumerable<Coordinate> GetCoordinates() {
+        return _coordinates;
+    }
+
+    public static Polyline GetPolyline() {
+        return _polyline;
+    }
+}