refactored encoding options, updated tests and comments

Author: petesramek

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -140,14 +140,14 @@ int GetMaxBufferLength(int count) {
 
             int requestedBufferLength = count * Defaults.Polyline.Block.Length.Max;
 
-            Debug.Assert(Options.MaxBufferLength > 0, "Max buffer length must be greater than zero.");
+            Debug.Assert(Options.MaxPolylineLength > 0, "Max buffer length must be greater than zero.");
             Debug.Assert(requestedBufferLength > 0, "Requested buffer length must be greater than zero.");
 
-            if (requestedBufferLength > Options.MaxBufferLength) {
+            if (requestedBufferLength > Options.MaxPolylineLength) {
                 logger
-                    .LogRequestedBufferSizeExceedsMaxBufferLengthWarning(requestedBufferLength, Options.MaxBufferLength);
+                    .LogRequestedBufferSizeExceedsMaxBufferLengthWarning(requestedBufferLength, Options.MaxPolylineLength);
 
-                return Options.MaxBufferLength;
+                return Options.MaxPolylineLength;
             }
 
             return requestedBufferLength;

src/PolylineAlgorithm/PolylineEncodingOptions.cs

@@ -18,12 +18,12 @@ namespace PolylineAlgorithm;
 [DebuggerDisplay("MaxBufferSize: {MaxBufferSize}, MaxBufferLength: {MaxBufferLength}, LoggerFactoryType: {LoggerFactory.GetType().Name}")]
 public sealed class PolylineEncodingOptions {
     /// <summary>
-    /// Gets the maximum buffer size for encoding operations.
+    /// Gets or sets the maximum size of the buffer used for encoding.
     /// </summary>
     /// <remarks>
-    /// The default maximum buffer size is 64,000 bytes (64 KB). This can be adjusted based on the expected size of the polyline data, but should be enough for common cases.
+    /// The default value is 1,024 characters.
     /// </remarks>
-    public int MaxBufferSize { get; internal set; } = 64_000;
+    public int MaxPolylineLength { get; internal set; } = 1_024;
 
     /// <summary>
     /// Gets or sets the precision for encoding coordinates.
@@ -32,13 +32,4 @@ public sealed class PolylineEncodingOptions {
     /// The default logger factory is <see cref="NullLoggerFactory"/>, which does not log any messages.
     /// </remarks>
     public ILoggerFactory LoggerFactory { get; internal set; } = NullLoggerFactory.Instance;
-
-
-    /// <summary>
-    /// Gets the maximum length of the encoded polyline string.
-    /// </summary>
-    /// <remarks>
-    /// The maximum length is calculated based on the buffer size divided by the size of a character.
-    /// </remarks>
-    internal int MaxBufferLength => MaxBufferSize / sizeof(char);
 }

src/PolylineAlgorithm/PolylineEncodingOptionsBuilder.cs

@@ -13,7 +13,7 @@ namespace PolylineAlgorithm;
 /// Provides a builder for configuring options for polyline encoding operations.
 /// </summary>
 public class PolylineEncodingOptionsBuilder {
-    private int _bufferSize = 64_000;
+    private int _maxPolylineLength = 1_024;
     private ILoggerFactory _loggerFactory = NullLoggerFactory.Instance;
 
     private PolylineEncodingOptionsBuilder() { }
@@ -36,23 +36,25 @@ public static PolylineEncodingOptionsBuilder Create() {
     /// </returns>
     public PolylineEncodingOptions Build() {
         return new PolylineEncodingOptions {
-            MaxBufferSize = _bufferSize,
+            MaxPolylineLength = _maxPolylineLength,
             LoggerFactory = _loggerFactory
         };
     }
 
     /// <summary>
-    /// Sets the buffer size for encoding operations.
+    /// Sets the maximum length of the polyline string that can be encoded.
     /// </summary>
-    /// <param name="bufferSize">
-    /// The maximum buffer size. Must be greater than 11.
+    /// <param name="maxLength">
+    /// The maximum length of the polyline string in characters.
     /// </param>
     /// <returns>
-    /// The current builder instance.
+    /// The current builder instance, allowing for method chaining.
     /// </returns>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="bufferSize"/> is less than or equal to 11.</exception>
-    public PolylineEncodingOptionsBuilder WithMaxBufferSize(int bufferSize) {
-        _bufferSize = bufferSize > 11 ? bufferSize : throw new ArgumentOutOfRangeException(nameof(bufferSize), string.Format(ExceptionMessageResource.BufferSizeMustBeGreaterThanMessageFormat, 11));
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown when <paramref name="maxLength"/> is less than 1024 characters.
+    /// </exception>
+    public PolylineEncodingOptionsBuilder WithMaxPolylineLength(int maxLength) {
+        _maxPolylineLength = maxLength >= 1024 ? maxLength : throw new ArgumentOutOfRangeException(nameof(maxLength), string.Format(ExceptionMessageResource.BufferSizeMustBeGreaterThanMessageFormat, 11));
 
         return this;
     }
@@ -64,12 +66,12 @@ public PolylineEncodingOptionsBuilder WithMaxBufferSize(int bufferSize) {
     /// The instance of a logger factory.
     /// </param>
     /// <returns>
-    /// The current builder instance.
+    /// The current builder instance, allowing for method chaining.
     /// </returns>
     /// <exception cref="ArgumentNullException">
     /// Thrown when <paramref name="loggerFactory"/> is <see langword="null"/>.
     /// </exception>
-    public PolylineEncodingOptionsBuilder WithLoggerFactory(ILoggerFactory loggerFactory) {
+    public PolylineEncodingOptionsBuilder UseLoggerFactory(ILoggerFactory loggerFactory) {
         _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
 
         return this;

tests/PolylineAlgorithm.Tests/AbstractPolylineDecoderTest.cs

@@ -15,7 +15,7 @@ namespace PolylineAlgorithm.Tests;
 public class AbstractPolylineDecoderTest {
     private static readonly PolylineDecoder _decoder = new();
 
-    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
+    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100]];
 
     public static IEnumerable<(double, double)> NotANumberAndInfinityCoordinates => StaticValueProvider.Invalid.GetNotANumberAndInfinityCoordinates();
 

tests/PolylineAlgorithm.Tests/AbstractPolylineEncoderTest.cs

@@ -15,7 +15,7 @@ namespace PolylineAlgorithm.Tests;
 public class AbstractPolylineEncoderTest {
     private static readonly PolylineEncoder _encoder = new();
 
-    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
+    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100]];
 
     public static IEnumerable<(double, double)> NotANumberAndInfinityCoordinates => StaticValueProvider.Invalid.GetNotANumberAndInfinityCoordinates();
 
@@ -88,7 +88,7 @@ public void Encode_EmptyCoordinates_Throws_ArgumentException() {
     [TestMethod]
     public void Encode_BufferTooSmall_Throws_InternalBufferOverflowException() {
         // Arrange
-        PolylineEncoder _encoder = new(new PolylineEncodingOptions { MaxBufferSize = 12 });
+        PolylineEncoder _encoder = new(new PolylineEncodingOptions { MaxPolylineLength = 12 });
         IEnumerable<(double Latitude, double Longitude)> coordinates = RandomValueProvider.GetCoordinates(2);
 
         // Act

tests/PolylineAlgorithm.Tests/PolylineDecoderExtensionsTest.cs

@@ -14,7 +14,7 @@ namespace PolylineAlgorithm.Tests;
 public class PolylineDecoderExtensionsTest {
     private readonly PolylineDecoder _decoder = new();
 
-    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
+    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100]];
 
     [TestMethod]
     public void Decode_Null_Decoder_Null_String_Throws_ArgumentNullException() {

tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs

@@ -13,7 +13,7 @@ namespace PolylineAlgorithm.Tests;
 /// </summary>
 [TestClass]
 public class PolylineDecoderTest {
-    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
+    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100]];
 
     /// <summary>
     /// The instance of the <see cref="PolylineDecoder"/> used for testing.

tests/PolylineAlgorithm.Tests/PolylineEncoderExtensionsTest.cs

@@ -14,7 +14,7 @@ namespace PolylineAlgorithm.Tests;
 public class PolylineEncoderExtensionsTest {
     private readonly PolylineEncoder _encoder = new();
 
-    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
+    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100]];
 
     [TestMethod]
     public void Encode_Null_Encoder_Empty_List_Throws_ArgumentNullException() {

tests/PolylineAlgorithm.Tests/PolylineEncoderTest.cs

@@ -12,7 +12,7 @@ namespace PolylineAlgorithm.Tests;
 /// </summary>
 [TestClass]
 public class PolylineEncoderTest {
-    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100], [1_000]];
+    public static IEnumerable<object[]> CoordinateCount => [[1], [10], [100]];
 
     /// <summary>
     /// The instance of the <see cref="PolylineEncoder"/> used for testing.

tests/PolylineAlgorithm.Tests/PolylineEncodingOptionsTest.cs

@@ -17,26 +17,24 @@ public void Constructor_Parameterless_Ok() {
         var options = new PolylineEncodingOptions();
 
         // Assert
-        Assert.AreEqual(64_000, options.MaxBufferSize);
-        Assert.AreEqual(64_000 / sizeof(char), options.MaxBufferLength);
+        Assert.AreEqual(1_024, options.MaxPolylineLength);
         Assert.IsInstanceOfType<NullLoggerFactory>(options.LoggerFactory);
     }
 
     [TestMethod]
-    public void Constructor_ValidOptions_Ok() {
+    public void Property_Initializer_Ok() {
         // Arrange
-        var bufferSize = 32_000;
+        var maxPolylineLength = 32_000;
         var loggerFactory = new FakeLoggerFactory(new FakeLoggerProvider());
 
         // Act
         var options = new PolylineEncodingOptions() {
-            MaxBufferSize = bufferSize,
+            MaxPolylineLength = maxPolylineLength,
             LoggerFactory = loggerFactory
         };
 
         // Assert
-        Assert.AreEqual(bufferSize, options.MaxBufferSize);
-        Assert.AreEqual(bufferSize / sizeof(char), options.MaxBufferLength);
+        Assert.AreEqual(maxPolylineLength, options.MaxPolylineLength);
         Assert.IsInstanceOfType<FakeLoggerFactory>(options.LoggerFactory);
     }
 }