zxczda

Author: Petr Sramek

src/PolylineAlgorithm/Validation/CoordinateValidator.cs

@@ -13,12 +13,6 @@ namespace PolylineAlgorithm.Validation;
 /// <param name="latitudeRange">A latitude range.</param>
 /// <param name="longitudeRange">A longitude range.</param>
 public sealed class CoordinateValidator(CoordinateRange latitudeRange, CoordinateRange longitudeRange) : ICoordinateValidator {
-    ///// <summary>
-    ///// Represents default coordinate validator. This field is read-only.
-    ///// </summary>
-    ///// <remarks>Validates latitude between -90 and 90; longitude between -180 and 180.</remarks>
-    //[SuppressMessage("Usage", "CA2211:Non-constant fields should not be visible", Justification = "We want to expose default instance of .")]
-
     /// <summary>
     /// A latitude validation range.
     /// </summary>

tests/PolylineAlgorithm.Tests/PolylineAlgorithm.Tests.csproj

@@ -34,8 +34,4 @@
 		<ProjectReference Include="..\..\src\PolylineAlgorithm\PolylineAlgorithm.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <Folder Include="Validation\" />
-	</ItemGroup>
-
 </Project>

tests/PolylineAlgorithm.Tests/Validation/CoordinateRangeTest.cs

@@ -12,7 +12,7 @@ namespace PolylineAlgorithm.Tests;
 /// </summary>
 [TestClass]
 public class CoordinateRangeTest {
-    public static IEnumerable<object[]> Consructor_Valid_Parameters => [
+    public static IEnumerable<object[]> Constructor_Valid_Parameters => [
         [ -90, 90 ],
         [ -180, 180 ],
     ];
@@ -37,7 +37,7 @@ public void Constructor_Parameterless_Ok() {
     }
 
     [TestMethod]
-    [DynamicData(nameof(Consructor_Valid_Parameters))]
+    [DynamicData(nameof(Constructor_Valid_Parameters))]
     public void Constructor_Valid_Parameters_Ok(double min, double max) {
         // Arrange
         double belowMax = max - 1;
@@ -46,14 +46,13 @@ public void Constructor_Valid_Parameters_Ok(double min, double max) {
         double equalMin = min;
         double aboveMax = max + 1;
         double aboveMin = min + 1;
-        
 
         // Act
         CoordinateRange range = new(min, max);
 
         // Assert
-        Assert.IsTrue(range.IsInRange(aboveMin));
         Assert.IsTrue(range.IsInRange(equalMin));
+        Assert.IsTrue(range.IsInRange(aboveMin));
         Assert.IsTrue(range.IsInRange(equalMax));
         Assert.IsTrue(range.IsInRange(belowMax));
 
@@ -67,20 +66,18 @@ public void Constructor_Invalid_Min_Parameter_ArgumentOutOfRangeException() {
         double min = 0;
         double max = 0;
 
-
         // Act
         void New(double min, double max) {
             CoordinateRange range = new(min, max);
 
         }
 
-
         // Assert
         Assert.ThrowsException<ArgumentOutOfRangeException>(() => New(min, max));
     }
 
     [TestMethod]
-    [DynamicData(nameof(Consructor_Valid_Parameters))]
+    [DynamicData(nameof(Constructor_Valid_Parameters))]
     public void Equals_CoordinateRange_True(double min, double max) {
         // Arrange
         CoordinateRange @this = new(min, max);
@@ -94,7 +91,7 @@ public void Equals_CoordinateRange_True(double min, double max) {
     }
 
     [TestMethod]
-    [DynamicData(nameof(Consructor_Valid_Parameters))]
+    [DynamicData(nameof(Constructor_Valid_Parameters))]
     public void Equals_CoordinateRange_False(double min, double max) {
         // Arrange
         Coordinate @this = new(min, max);

tests/PolylineAlgorithm.Tests/Validation/CoordinateValidatorTest.cs

@@ -0,0 +1,77 @@
+//  
+// Copyright (c) Pete Sramek. All rights reserved.  
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.  
+//
+
+namespace PolylineAlgorithm.Tests;
+
+using PolylineAlgorithm.Validation;
+
+/// <summary>
+/// Tests <see cref="Polyline"/> type.
+/// </summary>
+[TestClass]
+public class CoordinateValidatorTest {
+    private static readonly CoordinateRange _latitude = new(-90, 90);
+    private static readonly CoordinateRange _longitude = new(-180, 180);
+
+    public static IEnumerable<object[]> IsValid_Method_Parameters => [
+        [ 0, 0, true ],
+        [ _latitude.Min, _longitude.Max, true ],
+        [ _latitude.Min - 1, _longitude.Max, false ],
+        [ _latitude.Min, _longitude.Max + 1, false ],
+        [ _latitude.Min - 1, _longitude.Max + 1, false ]
+    ];
+
+    [TestMethod]
+    [DynamicData(nameof(IsValid_Method_Parameters))]
+    public void IsValid_Valid_Parameters_Ok(double latitude, double longitude, bool expected) {
+        // Arrange
+        Coordinate coordinate = new(latitude, longitude);
+        CoordinateValidator validator = new(_latitude, _longitude);
+
+        // Act
+        bool result = validator.IsValid(coordinate);
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void Constructor_Invalid_Min_Parameter_ArgumentOutOfRangeException() {
+        // Arrange
+        double min = 0;
+        double max = 0;
+
+        // Act
+        void New(double min, double max) {
+            CoordinateRange range = new(min, max);
+
+        }
+
+        // Assert
+        Assert.ThrowsException<ArgumentOutOfRangeException>(() => New(min, max));
+    }
+
+    [TestMethod]
+    public void SetDefault_Validator_Ok() {
+        // Arrange
+        CoordinateRange range = new(double.MinValue, double.MaxValue);
+        CoordinateValidator validator = new(range, range);
+
+        // Act
+        ICoordinateValidator original = ICoordinateValidator.Default;
+
+        ICoordinateValidator
+            .SetDefault(validator);
+
+        ICoordinateValidator @new = ICoordinateValidator.Default;
+
+        ICoordinateValidator
+            .SetDefault(original);
+
+        // Assert
+        Assert.AreEqual(validator, @new);
+        Assert.AreNotEqual(original, @new);
+    }
+}