logging

petesramek · petesramek · commit 6b45c1aecd9a · 2025-06-30T23:13:31.000+02:00
diff --git a/src/PolylineAlgorithm.Abstraction/IPolylineEncodingOptionsBuilder.cs b/src/PolylineAlgorithm.Abstraction/IPolylineEncodingOptionsBuilder.cs
@@ -1,6 +1,11 @@
 ﻿namespace PolylineAlgorithm.Abstraction;
 
+using Microsoft.Extensions.Logging;
+
 public interface IPolylineEncodingOptionsBuilder {
     IPolylineEncodingOptionsBuilder WithBufferSize(int maxBufferSize);
+
+    IPolylineEncodingOptionsBuilder WithLoggerFactory(ILoggerFactory loggerFactory);
+
     PolylineEncodingOptions Build();
 }
diff --git a/src/PolylineAlgorithm.Abstraction/Internal/Logging.cs b/src/PolylineAlgorithm.Abstraction/Internal/Logging.cs
@@ -0,0 +1,23 @@
+﻿namespace PolylineAlgorithm.Abstraction.Internal;
+
+using Microsoft.Extensions.Logging;
+
+internal static partial class Logging {
+    [LoggerMessage(0, LogLevel.Error, "Argument {argumentName} cannot be null.")]
+    internal static partial void LogNullArgumentError(this ILogger logger, string argumentName);
+
+    [LoggerMessage(0, LogLevel.Error, "Argument {argumentName} cannot be empty.")]
+    internal static partial void LogEmptyArgumentError(this ILogger logger, string argumentName);
+
+    [LoggerMessage(0, LogLevel.Error, "Internal buffer has {bufferLength} length. At position {position} is required additonal {requiredSpace} length.")]
+    internal static partial void LogInternalBufferOverflowError(this ILogger logger, int position, int bufferLength, int requiredSpace);
+    
+    [LoggerMessage(0, LogLevel.Error, "Cannot write to internal buffer at position {position}.")]
+    internal static partial void LogCannotWriteValueToBufferError(this ILogger logger, int position);
+
+    [LoggerMessage(0, LogLevel.Error, "Argument {argumentName} is too short. Minimal length is {minimumLength}. Actual length is {actualLength}.")]
+    internal static partial void LogPolylineCannotBeShorterThanError(this ILogger logger, string argumentName, int actualLength, int minimumLength);
+
+    [LoggerMessage(0, LogLevel.Warning, "Requested buffer size of {requestedBufferLength} exceeds maximum allowed buffer length of {maxBufferLength}.")]
+    internal static partial void LogRequestedBufferSizeExceedsMaxBufferLength(this ILogger logger, int requestedBufferLength, int maxBufferLength);
+}
diff --git a/src/PolylineAlgorithm.Abstraction/PolylineAlgorithm.Abstraction.csproj b/src/PolylineAlgorithm.Abstraction/PolylineAlgorithm.Abstraction.csproj
@@ -9,6 +9,10 @@
 		<NeutralLanguage>en</NeutralLanguage>
 	</PropertyGroup>
 
+	<PropertyGroup>
+		<EnableConfigurationBindingGenerator>true</EnableConfigurationBindingGenerator>
+	</PropertyGroup>
+
 	<PropertyGroup>
 		<AnalysisMode>All</AnalysisMode>
 		<AnalysisLevel>latest</AnalysisLevel>
@@ -49,6 +53,7 @@
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
 		</PackageReference>
+		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.*" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/src/PolylineAlgorithm.Abstraction/PolylineDecoder.cs b/src/PolylineAlgorithm.Abstraction/PolylineDecoder.cs
@@ -50,6 +50,10 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
         ReadOnlyMemory<char> sequence = GetReadOnlyMemory(polyline);
 
         if (sequence.Length < Defaults.Polyline.MinEncodedCoordinateLength) {
+            Options
+                .UseLoggerFor<PolylineDecoder<TPolyline, TCoordinate>>()
+                .LogPolylineCannotBeShorterThanError(nameof(sequence), sequence.Length, Defaults.Polyline.MinEncodedCoordinateLength);
+
             throw new ArgumentException(string.Format(ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage, sequence.Length), nameof(polyline));
         }
 
diff --git a/src/PolylineAlgorithm.Abstraction/PolylineEncoder.cs b/src/PolylineAlgorithm.Abstraction/PolylineEncoder.cs
@@ -5,6 +5,7 @@
 
 namespace PolylineAlgorithm.Abstraction;
 
+using Microsoft.Extensions.Logging;
 using PolylineAlgorithm.Abstraction.Internal;
 using PolylineAlgorithm.Abstraction.Properties;
 using System;
@@ -48,12 +49,17 @@ public PolylineEncoder(PolylineEncodingOptions options) {
     /// </exception>
     public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
         if (coordinates is null) {
+            Options
+                .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogNullArgumentError(nameof(coordinates));
             throw new ArgumentNullException(nameof(coordinates));
         }
 
         int count = GetCount(coordinates);
 
         if (count == 0) {
+            Options
+                .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogEmptyArgumentError(nameof(coordinates));
+
             throw new ArgumentException(ExceptionMessageResource.ArgumentCannotBeEmptyEnumerationMessage, nameof(coordinates));
         }
 
@@ -72,12 +78,16 @@ public TPolyline Encode(IEnumerable<TCoordinate> coordinates) {
                 .Next(PolylineEncoding.Normalize(GetLatitude(enumerator.Current), PolylineEncoding.ValueType.Latitude), PolylineEncoding.Normalize(GetLongitude(enumerator.Current), PolylineEncoding.ValueType.Longitude));
 
             if (GetRemainingBufferSize(position, buffer.Length) < GetRequiredLength(variance)) {
+                Options
+                    .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogInternalBufferOverflowError(position, buffer.Length, GetRequiredLength(variance));
                 throw new InternalBufferOverflowException();
             }
 
             if (!PolylineEncoding.TryWriteValue(variance.Latitude, ref buffer, ref position)
                 || !PolylineEncoding.TryWriteValue(variance.Longitude, ref buffer, ref position)
             ) {
+                Options
+                    .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogCannotWriteValueToBufferError(position);
                 throw new InvalidOperationException();
             }
 
@@ -101,13 +111,16 @@ static int GetRequiredLength(CoordinateVariance variance) =>
 
         int GetBufferLength(int count) {
             int maxBufferLength = Options.BufferSize / sizeof(char);
-            int? requestedBufferLength = count * Defaults.Polyline.MaxEncodedCoordinateLength;
+            int requestedBufferLength = count * Defaults.Polyline.MaxEncodedCoordinateLength;
+
+            if (requestedBufferLength > maxBufferLength) {
+                Options
+                   .UseLoggerFor<PolylineEncoder<TCoordinate, TPolyline>>().LogRequestedBufferSizeExceedsMaxBufferLength(requestedBufferLength, maxBufferLength);
 
-            if (requestedBufferLength is null || requestedBufferLength > maxBufferLength) {
                 return maxBufferLength;
             }
 
-            return requestedBufferLength.Value;
+            return requestedBufferLength;
         }
     }
 
diff --git a/src/PolylineAlgorithm.Abstraction/PolylineEncodingOptions.cs b/src/PolylineAlgorithm.Abstraction/PolylineEncodingOptions.cs
@@ -5,6 +5,9 @@
 
 namespace PolylineAlgorithm.Abstraction;
 
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
 /// <summary>
 /// Options for configuring polyline encoding.
 /// </summary>
@@ -16,4 +19,8 @@ public sealed class PolylineEncodingOptions {
     public int BufferSize { get; internal set; } = 64_000;
 
     public int MaxLength => BufferSize / sizeof(char);
+
+    public ILoggerFactory LoggerFactory { get; internal set; } = NullLoggerFactory.Instance;
+
+    public ILogger UseLoggerFor<T>() => LoggerFactory.CreateLogger<T>();
 }
diff --git a/src/PolylineAlgorithm.Abstraction/PolylineEncodingOptionsBuilder.cs b/src/PolylineAlgorithm.Abstraction/PolylineEncodingOptionsBuilder.cs
@@ -5,20 +5,23 @@
 
 namespace PolylineAlgorithm.Abstraction;
 
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
 public class PolylineEncodingOptionsBuilder : IPolylineEncodingOptionsBuilder {
     private int _bufferSize = 64_000;
+    private ILoggerFactory _loggerFactory = NullLoggerFactory.Instance;
 
     /// <summary>
     /// Creates a new <see cref="IPolylineEncodingOptionsBuilder"/> instance for the specified coordinate type.
     /// </summary>
-    /// <typeparam name="TCoordinate">The type representing a coordinate.</typeparam>
     /// <returns>An <see cref="IPolylineEncodingOptionsBuilder"/> instance for configuring polyline encoding options.</returns>
     public static IPolylineEncodingOptionsBuilder Create() {
         return new PolylineEncodingOptionsBuilder();
     }
 
     /// <summary>
-    /// Builds a new <see cref="PolylineEncodingOptions{TCoordinate}"/> instance using the configured options.
+    /// Builds a new <see cref="PolylineEncodingOptions"/> instance using the configured options.
     /// </summary>
     /// <returns>A configured <see cref="PolylineEncodingOptions"/> instance.</returns>
     PolylineEncodingOptions IPolylineEncodingOptionsBuilder.Build() {
@@ -38,4 +41,17 @@ IPolylineEncodingOptionsBuilder IPolylineEncodingOptionsBuilder.WithBufferSize(i
 
         return this;
     }
+
+    /// <summary>
+    /// Sets the logger factory for logging during encoding operations.
+    /// </summary>
+    /// <param name="loggerFactory">The instance of a logger factory.</param>
+    /// <returns>The current builder instance.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="loggerFactory"/> is <see langword="null"/></exception>
+    IPolylineEncodingOptionsBuilder IPolylineEncodingOptionsBuilder.WithLoggerFactory(ILoggerFactory loggerFactory) {
+        _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory), "Logger factory cannot be null.");
+
+        return this;
+
+    }
 }
diff --git a/tests/PolylineAlgorithm.Abstraction.Tests/FakeLoggerFactory.cs b/tests/PolylineAlgorithm.Abstraction.Tests/FakeLoggerFactory.cs
@@ -0,0 +1,41 @@
+﻿namespace PolylineAlgorithm.Abstraction.Tests;
+
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Testing;
+
+internal class FakeLoggerFactory : ILoggerFactory {
+    private bool _isDisposed;
+
+    public FakeLoggerFactory(FakeLoggerProvider loggerProvider) {
+        Provider = new FakeLoggerProvider();
+    }
+
+    public ILoggerProvider Provider { get; private set; }
+
+
+    public void AddProvider(ILoggerProvider provider) {
+        Provider = provider;
+    }
+
+    public ILogger CreateLogger(string categoryName) {
+        return Provider.CreateLogger(categoryName);
+    }
+
+    protected virtual void Dispose(bool disposing) {
+        if (!_isDisposed) {
+            if (disposing) {
+               
+            }
+
+            // TODO: free unmanaged resources (unmanaged objects) and override finalizer
+            // TODO: set large fields to null
+            _isDisposed = true;
+        }
+    }
+
+    public void Dispose() {
+        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+}
diff --git a/tests/PolylineAlgorithm.Abstraction.Tests/PolylineAlgorithm.Abstraction.Tests.csproj b/tests/PolylineAlgorithm.Abstraction.Tests/PolylineAlgorithm.Abstraction.Tests.csproj
@@ -30,6 +30,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
+		<PackageReference Include="Microsoft.Extensions.Diagnostics.Testing" Version="9.6.0" />
 		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
 		<PackageReference Include="MSTest" Version="3.*" />
 		<PackageReference Include="Microsoft.Testing.Platform.MSBuild" Version="1.*" />
diff --git a/tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncoderTest.cs b/tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncoderTest.cs
@@ -0,0 +1,27 @@
+﻿namespace PolylineAlgorithm.Abstraction.Tests;
+
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Testing;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+[TestClass]
+public class PolylineEncoderTest {
+    internal static readonly FakeLoggerProvider loggerProvider = new();
+
+    [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");
+    }
+
+    public class PolylineEncoder : PolylineEncoder<(double Latitude, double Longitude), string> {
+        public PolylineEncoder(PolylineEncodingOptions options) : base(options) { }
+
+        protected override string CreatePolyline(ReadOnlyMemory<char> polyline) => polyline.ToString();
+        protected override double GetLatitude((double Latitude, double Longitude) coordinate) => coordinate.Latitude;
+        protected override double GetLongitude((double Latitude, double Longitude) coordinate) => coordinate.Longitude;
+    }
+}
diff --git a/tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncodingTest.cs b/tests/PolylineAlgorithm.Abstraction.Tests/PolylineEncodingTest.cs
@@ -5,7 +5,7 @@
 using System.Collections.Generic;
 
 [TestClass]
-public class PolylineEncodingTests {
+public class PolylineEncodingTest {
     #region Dynamic Data Properties
 
     public static IEnumerable<(int variance, string polyline)> VariancePolylinePairs => [
diff --git a/tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs b/tests/PolylineAlgorithm.Tests/PolylineDecoderTest.cs
@@ -24,12 +24,12 @@ public class PolylineDecoderTest {
     /// Tests the <see cref="PolylineDecoder.Decode(ref readonly Polyline)"/> method with an empty input, expecting an <see cref="ArgumentException"/>.
     /// </summary>
     [TestMethod]
-    public void Decode_Empty_Input_ThrowsException() {
+    public void Decode_Default_Polyline_Throws_ArgumentException() {
         // Arrange
-        string empty = String.Empty;
+        Polyline empty = new();
 
         // Act
-        void Execute(string value) => Decoder.Decode(Polyline.FromString(value)).ToList();
+        void Execute(Polyline value) => Decoder.Decode(value).ToList();
 
         // Assert
         Assert.ThrowsExactly<ArgumentException>(() => Execute(empty));

Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,10 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {`
`50`	`50`	`ReadOnlyMemory<char> sequence = GetReadOnlyMemory(polyline);`
`51`	`51`
`52`	`52`	`if (sequence.Length < Defaults.Polyline.MinEncodedCoordinateLength) {`
	`53`	`+ Options`
	`54`	`+ .UseLoggerFor<PolylineDecoder<TPolyline, TCoordinate>>()`
	`55`	`+ .LogPolylineCannotBeShorterThanError(nameof(sequence), sequence.Length, Defaults.Polyline.MinEncodedCoordinateLength);`
	`56`	`+`
`53`	`57`	`throw new ArgumentException(string.Format(ExceptionMessageResource.PolylineCannotBeShorterThanExceptionMessage, sequence.Length), nameof(polyline));`
`54`	`58`	`}`
`55`	`59`