feat(measurement): enforce finite Distance magnitudes (#599)

* feat(measurement): enforce finite Distance magnitudes

Throw IllegalArgumentException when constructing a Distance with a NaN
or infinite magnitude. Update tests to cover the new validation and fix
all property-based tests that previously used Arb.double() (which can
produce non-finite values).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(measurement): remove obsolete Distance.isFinite property

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: mtrewartha

core/measurement/src/main/kotlin/io/trewartha/positional/core/measurement/Distance.kt

@@ -8,10 +8,9 @@ package io.trewartha.positional.core.measurement
  */
 public data class Distance(val magnitude: Double, val unit: Unit) {
 
-    /**
-     * `true` if the distance is finite, `false` if it is negative or positive infinity
-     */
-    val isFinite: Boolean get() = magnitude.isFinite()
+    init {
+        require(magnitude.isFinite()) { "Distance magnitude must be finite, but was $magnitude" }
+    }
 
     /**
      * `true` if the distance is negative, `false` if it is positive or zero

core/measurement/src/main/kotlin/io/trewartha/positional/core/measurement/MgrsCoordinates.kt

@@ -23,8 +23,8 @@ public data class MgrsCoordinates(
 ) : Coordinates {
 
     private val worldWindMgrsCoordinates = try {
-        require(easting.isFinite && !easting.isNegative) { "Invalid easting: $easting" }
-        require(northing.isFinite && !northing.isNegative) { "Invalid northing: $northing" }
+        require(!easting.isNegative) { "Easting must not be negative but was $easting" }
+        require(!northing.isNegative) { "Northing must not be negative but was $northing" }
         val easting = easting.inRoundedAndPaddedMeters()
         val northing = northing.inRoundedAndPaddedMeters()
         MGRSCoord.fromString("$gridZoneDesignator $gridSquareID $easting $northing")

core/measurement/src/main/kotlin/io/trewartha/positional/core/measurement/UtmCoordinates.kt

@@ -25,8 +25,8 @@ public data class UtmCoordinates(
             Hemisphere.NORTH -> earth.worldwind.geom.coords.Hemisphere.N
             Hemisphere.SOUTH -> earth.worldwind.geom.coords.Hemisphere.S
         }
-        require(easting.isFinite && !easting.isNegative) { "Invalid easting: $easting" }
-        require(northing.isFinite && !northing.isNegative) { "Invalid northing: $northing" }
+        require(!easting.isNegative) { "Easting must not be negative but was $easting" }
+        require(!northing.isNegative) { "Northing must not be negative but was $northing" }
         val easting = easting.inMeters().magnitude
         val northing = northing.inMeters().magnitude
         UTMCoord.fromUTM(zone, hemisphere, easting, northing)

core/measurement/src/test/kotlin/io/trewartha/positional/core/measurement/DistanceTest.kt

@@ -1,44 +1,71 @@
 package io.trewartha.positional.core.measurement
 
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.DescribeSpec
 import io.kotest.matchers.booleans.shouldBeFalse
 import io.kotest.matchers.booleans.shouldBeTrue
 import io.kotest.matchers.doubles.plusOrMinus
 import io.kotest.matchers.shouldBe
 import io.kotest.property.Arb
-import io.kotest.property.arbitrary.double
 import io.kotest.property.arbitrary.enum
 import io.kotest.property.arbitrary.filter
-import io.kotest.property.arbitrary.negativeDouble
 import io.kotest.property.arbitrary.numericDouble
 import io.kotest.property.arbitrary.of
-import io.kotest.property.arbitrary.positiveDouble
 import io.kotest.property.checkAll
 import kotlin.math.abs
 
 class DistanceTest : DescribeSpec({
 
+    describe("creating a Distance") {
+        context("with a finite magnitude") {
+            it("succeeds") {
+                checkAll(Arb.numericDouble(), Arb.enum<Distance.Unit>()) { magnitude, unit ->
+                    Distance(magnitude, unit)
+                }
+            }
+        }
+
+        context("with a NaN magnitude") {
+            it("throws IllegalArgumentException") {
+                checkAll(Arb.enum<Distance.Unit>()) { unit ->
+                    shouldThrow<IllegalArgumentException> { Distance(Double.NaN, unit) }
+                }
+            }
+        }
+
+        context("with an infinite magnitude") {
+            it("throws IllegalArgumentException") {
+                checkAll(
+                    Arb.of(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
+                    Arb.enum<Distance.Unit>()
+                ) { magnitude, unit ->
+                    shouldThrow<IllegalArgumentException> { Distance(magnitude, unit) }
+                }
+            }
+        }
+    }
+
     describe("creating a distance in feet") {
         it("creates a distance with the correct magnitude and unit") {
-            checkAll(Arb.double()) { number ->
+            checkAll(Arb.numericDouble()) { number ->
                 number.feet.shouldBe(Distance(number, Distance.Unit.FEET))
             }
         }
     }
 
     describe("creating a distance in meters") {
         it("creates a distance with the correct magnitude and unit") {
-            checkAll(Arb.double()) { number ->
+            checkAll(Arb.numericDouble()) { number ->
                 number.meters.shouldBe(Distance(number, Distance.Unit.METERS))
             }
         }
     }
 
-    describe("checking whether the distance is negative") {
+    describe("whether the distance is negative") {
         context("when the magnitude is negative") {
             it("returns true") {
                 checkAll(
-                    Arb.negativeDouble().filter { !it.isNaN() },
+                    Arb.numericDouble().filter { it < 0 },
                     Arb.enum<Distance.Unit>()
                 ) { magnitude, unit ->
                     Distance(magnitude, unit).isNegative.shouldBeTrue()
@@ -57,28 +84,20 @@ class DistanceTest : DescribeSpec({
         context("when the magnitude is positive") {
             it("returns false") {
                 checkAll(
-                    Arb.positiveDouble().filter { !it.isNaN() },
+                    Arb.numericDouble().filter { it > 0 },
                     Arb.enum<Distance.Unit>()
                 ) { magnitude, unit ->
                     Distance(magnitude, unit).isNegative.shouldBeFalse()
                 }
             }
         }
-
-        context("when the magnitude is NaN") {
-            it("returns false") {
-                checkAll(Arb.enum<Distance.Unit>()) { unit ->
-                    Distance(Double.NaN, unit).isNegative.shouldBeFalse()
-                }
-            }
-        }
     }
 
-    describe("checking whether the distance is positive") {
+    describe("whether the distance is positive") {
         context("when the magnitude is negative") {
             it("returns false") {
                 checkAll(
-                    Arb.negativeDouble().filter { !it.isNaN() },
+                    Arb.numericDouble().filter { it < 0 },
                     Arb.enum<Distance.Unit>()
                 ) { magnitude, unit ->
                     Distance(magnitude, unit).isPositive.shouldBeFalse()
@@ -97,59 +116,19 @@ class DistanceTest : DescribeSpec({
         context("when the magnitude is positive") {
             it("returns true") {
                 checkAll(
-                    Arb.positiveDouble().filter { !it.isNaN() },
+                    Arb.numericDouble().filter { it > 0 },
                     Arb.enum<Distance.Unit>()
                 ) { magnitude, unit ->
                     Distance(magnitude, unit).isPositive.shouldBeTrue()
                 }
             }
         }
-
-        context("when the magnitude is NaN") {
-            it("returns false") {
-                checkAll(Arb.enum<Distance.Unit>()) { unit ->
-                    Distance(Double.NaN, unit).isPositive.shouldBeFalse()
-                }
-            }
-        }
-    }
-
-    describe("checking whether the distance is finite") {
-        context("when the magnitude is NaN") {
-            it("returns false") {
-                checkAll(Arb.enum<Distance.Unit>()) { unit ->
-                    Distance(Double.NaN, unit).isFinite.shouldBeFalse()
-                }
-            }
-        }
-
-        context("when the magnitude is infinite") {
-            it("returns false") {
-                checkAll(
-                    Arb.of(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
-                    Arb.enum<Distance.Unit>()
-                ) { magnitude, unit ->
-                    Distance(magnitude, unit).isFinite.shouldBeFalse()
-                }
-            }
-        }
-
-        context("when the magnitude is finite") {
-            it("returns true") {
-                checkAll(
-                    Arb.numericDouble(),
-                    Arb.enum<Distance.Unit>()
-                ) { magnitude, unit ->
-                    Distance(magnitude, unit).isFinite.shouldBeTrue()
-                }
-            }
-        }
     }
 
     describe("converting to feet") {
         context("when the distance is already in feet") {
             it("returns the original distance") {
-                checkAll(Arb.double()) { magnitude ->
+                checkAll(Arb.numericDouble()) { magnitude ->
                     magnitude.feet.inFeet().shouldBe(magnitude.feet)
                 }
             }
@@ -191,7 +170,7 @@ class DistanceTest : DescribeSpec({
 
         context("when the distance is already in meters") {
             it("returns the original distance") {
-                checkAll(Arb.double()) { magnitude ->
+                checkAll(Arb.numericDouble()) { magnitude ->
                     magnitude.meters.inMeters().shouldBe(magnitude.meters)
                 }
             }