fixes

Author: Petr Sramek

src/PolylineAlgorithm/Internal/PolylineReader.cs

@@ -22,7 +22,7 @@ public PolylineReader(ref readonly Polyline polyline) {
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Coordinate Read() {
-        EnsureRead();
+        InvalidReaderStateException.ThrowIfCannotRead(CanRead, Position, _polyline.Length);
 
         GetCurrent(out int currentLatitude, out int currentLongitude);
 
@@ -63,26 +63,20 @@ int ReadNext(ref readonly int value) {
         int shifter = 0;
 
         do {
-            EnsureRead();
+            InvalidReaderStateException.ThrowIfCannotRead(CanRead, Position, _polyline.Length);
             chunk = _polyline[Position] - Defaults.Algorithm.QuestionMark;
             sum |= (chunk & Defaults.Algorithm.UnitSeparator) << shifter;
             shifter += Defaults.Algorithm.ShiftLength;
             Advance();
         } while (chunk >= Defaults.Algorithm.Space && CanRead);
 
         if (!CanRead && chunk >= Defaults.Algorithm.Space) {
-            throw new PolylineMalformedException(Position);
+            PolylineMalformedException.Throw(Position);
         }
 
         return value + ((sum & 1) == 1 ? ~(sum >> 1) : sum >> 1);
     }
 
-    readonly void EnsureRead() {
-        if (!CanRead) {
-            throw new InvalidOperationException(ExceptionMessageResource.PolylineReaderCannotRead, innerException: new InvalidReaderStateException(Position, _polyline.Length));
-        }
-    }
-
     [StructLayout(LayoutKind.Sequential, Pack = 4, Size = 12)]
     private ref struct ReaderState {
         public ReaderState() {

src/PolylineAlgorithm/Internal/PolylineWriter.cs

@@ -19,7 +19,7 @@ public PolylineWriter(ref readonly Memory<char> buffer) {
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Write(ref readonly Coordinate coordinate) {
-        EnsureState();
+        InvalidWriterStateException.ThrowIfCannotWrite(CanWrite, Position, _buffer.Length);
 
         Imprecise(coordinate.Latitude, out int latitude);
         Imprecise(coordinate.Longitude, out int longitude);
@@ -35,12 +35,6 @@ static void Imprecise(double value, out int result) {
         }
     }
 
-    readonly void EnsureState() {
-        if (!CanWrite) {
-            throw new InvalidOperationException(ExceptionMessageResource.PolylineWriterCannotWrite, new InvalidWriterStateException(Position, _buffer.Length));
-        }
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void WriteNext(ref readonly int value) {
         int rem = value << 1;
@@ -59,7 +53,7 @@ void WriteNext(ref readonly int value) {
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void WriteChar(char value) {
-        EnsureState();
+        InvalidWriterStateException.ThrowIfCannotWrite(CanWrite, Position, _buffer.Length);
 
         _buffer.Span[Position] = value;
         _state.Position += 1;

src/PolylineAlgorithm/InvalidCoordinateException.cs

@@ -13,8 +13,8 @@ namespace PolylineAlgorithm;
 /// </summary>
 [SuppressMessage("Design", "CA1032:Implement standard exception constructors", Justification = "Main purpose is to report coordinate that is invalid, thus we have to have only one construtor.")]
 public sealed class InvalidCoordinateException : Exception {
-    private InvalidCoordinateException(Coordinate coordinate, string message, Exception? innerException = null)
-        : base(message, innerException) {
+    private InvalidCoordinateException(Coordinate coordinate, string message)
+        : base(message) {
         Coordinate = coordinate;
     }
 
@@ -23,7 +23,11 @@ private InvalidCoordinateException(Coordinate coordinate, string message, Except
     /// </summary>
     public Coordinate Coordinate { get; }
 
-    public static void Throw(Coordinate coordinate, Exception? innerException = null) {
-        throw new InvalidCoordinateException(coordinate, string.Format(ExceptionMessageResource.CoordinateIsOutOfRangeMessageFormat, coordinate.Latitude, coordinate.Longitude), innerException);
+    public static void ThrowIfNotValid(Coordinate coordinate) {
+        if(coordinate.IsValid) {
+            return;
+        }
+
+        throw new InvalidCoordinateException(coordinate, string.Format(ExceptionMessageResource.CoordinateIsOutOfRangeMessageFormat, coordinate.Latitude, coordinate.Longitude));
     }
 }

src/PolylineAlgorithm/InvalidReaderStateException.cs

@@ -16,7 +16,11 @@ namespace PolylineAlgorithm;
 public sealed class InvalidReaderStateException(string message)
     : Exception(message) {
 
-    public static void Throw(int readerPosition, int polylineLength) {
+    public static void ThrowIfCannotRead(bool canRead, int readerPosition, int polylineLength) {
+        if(canRead) {
+            return;
+        }
+
         if (polylineLength == 0) {
             throw new InvalidReaderStateException(ExceptionMessageResource.PolylineStringIsEmptyMessage);
         } else {

src/PolylineAlgorithm/InvalidWriterStateException.cs

@@ -16,8 +16,12 @@ namespace PolylineAlgorithm;
 public sealed class InvalidWriterStateException(string message)
     : Exception(message) {
 
-    public static void Throw(int readerPosition, int polylineLength) {
-        if (polylineLength == 0) {
+    public static void ThrowIfCannotWrite(bool canWrite, int readerPosition, int bufferSize) {
+        if (canWrite) {
+            return;
+        }
+
+        if (bufferSize == 0) {
             throw new InvalidWriterStateException(ExceptionMessageResource.PolylineBufferIsEmptyMessage);
         } else {
             throw new InvalidWriterStateException(string.Format(ExceptionMessageResource.UnableToWritePolylineBufferAtPositionMessageFormat, readerPosition, bufferSize));

src/PolylineAlgorithm/PolylineDecoder.cs

@@ -32,9 +32,7 @@ public IEnumerable<Coordinate> Decode(ref readonly Polyline polyline) {
         while (reader.CanRead) {
             var coordinate = reader.Read();
 
-            if(!coordinate.IsValid) {
-                throw new InvalidCoordinateException(coordinate);
-            }
+            InvalidCoordinateException.ThrowIfNotValid(coordinate);
 
             result.Add(coordinate);
         }

src/PolylineAlgorithm/PolylineEncoder.cs

@@ -38,10 +38,7 @@ public Polyline Encode(IEnumerable<Coordinate> coordinates) {
         PolylineWriter writer = new(in buffer);
 
         foreach (var coordinate in coordinates) {
-            if (!coordinate.IsValid) {
-                throw new InvalidCoordinateException(coordinate);
-            }
-
+            InvalidCoordinateException.ThrowIfNotValid(coordinate);
             writer.Write(in coordinate);
         }
 

src/PolylineAlgorithm/PolylineMalformedException.cs

@@ -19,8 +19,8 @@ public sealed class PolylineMalformedException : Exception {
     /// </summary>
     /// <param name="position"></param>
     /// <param name="innerException"></param>
-    private PolylineMalformedException(int position, string message, Exception? innerException = null)
-        : base(message, innerException) {
+    private PolylineMalformedException(int position, string message)
+        : base(message) {
         Position = position;
     }
 
@@ -29,7 +29,7 @@ private PolylineMalformedException(int position, string message, Exception? inne
     /// </summary>
     public int Position { get; }
 
-    public static void Throw(int position, Exception? innerException = null) {
-        throw new PolylineMalformedException(position, string.Format(ExceptionMessageResource.PolylineStringIsMalformedMessage, position), innerException);
+    public static void Throw(int position) {
+        throw new PolylineMalformedException(position, string.Format(ExceptionMessageResource.PolylineStringIsMalformedMessage, position));
     }
 }

tests/PolylineAlgorithm.Tests/Data/Values.cs

@@ -5,6 +5,7 @@
 
 namespace PolylineAlgorithm.Tests.Data;
 
+using PolylineAlgorithm.Validation;
 using System.Collections.Generic;
 
 /// <summary>
@@ -73,6 +74,8 @@ public static class MalformedPolylineException {
     }
 
     public static class InvalidCoordinateException {
-        public static readonly Coordinate Coordinate = new(_random.NextDouble(), _random.NextDouble());
+        public static readonly Coordinate Valid = new(_random.NextDouble(), _random.NextDouble());
+
+        public static readonly Coordinate Invalid = new(double.MinValue, double.MaxValue);
     }
 }

tests/PolylineAlgorithm.Tests/InvalidCoordinateExceptionTest.cs

@@ -20,17 +20,30 @@ public class InvalidCoordinateExceptionTest {
     /// <see cref="Exception.InnerException" /> equals passed argument,
     /// and <see cref="Exception.Message"/> in not <see langword="null"/>, empty -or- whitespace.</remarks>
     [TestMethod]
-    public void Constructor_Ok() {
+    public void ThrowIfNotValid_Valid_Parameter_Ok() {
         // Arrange
-        var coordinate = Values.InvalidCoordinateException.Coordinate;
-        var innerException = new Exception();
+        var coordinate = Values.InvalidCoordinateException.Valid;
 
         // Act
-        InvalidCoordinateException result = new(coordinate, innerException);
+        InvalidCoordinateException.ThrowIfNotValid(coordinate);
 
         // Assert
-        Assert.AreEqual(coordinate, result.Coordinate);
-        Assert.IsNotNull(innerException);
-        Assert.IsFalse(string.IsNullOrWhiteSpace(result.Message));
+        // We are assering exception was not thrown, if it was test won't pass
+    }
+
+    [TestMethod]
+    public void ThrowIfNotValid_Invalid_Parameter_InvalidCoordinateException_Thrown() {
+        // Arrange
+        var coordinate = Values.InvalidCoordinateException.Invalid;
+
+        // Act
+        void ThrowIfNotValid(Coordinate coordinate) {
+            InvalidCoordinateException.ThrowIfNotValid(coordinate);
+        }
+
+        // Assert
+        var exception = Assert.ThrowsException<InvalidCoordinateException>(() => ThrowIfNotValid(coordinate));
+        Assert.AreEqual(coordinate, exception.Coordinate);
+        Assert.IsFalse(string.IsNullOrWhiteSpace(exception.Message));
     }
 }