Add tests for LatLong

3 files changed, 337 insertions, 0 deletions

diff --git a/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LatLongTest.kt b/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LatLongTest.kt
new file mode 100644
index 0000000000..6644e25e82
--- /dev/null
+++ b/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LatLongTest.kt
@@ -0,0 +1,20 @@
+package net.mullvad.mullvadvpn.model
+
+import kotlin.math.sqrt
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class LatLongTest {
+
+    @Test
+    fun `distance between two LatLong should be same as hypotenuse`() {
+        val latLong1 = LatLong(Latitude(30f), Longitude(40f))
+        val latLong2 = LatLong(Latitude(-40f), Longitude(170f))
+
+        val latDiff = latLong1.latitude.distanceTo(latLong2.latitude)
+        val longDiff = latLong1.longitude.distanceTo(latLong2.longitude)
+        val hypotenuse = sqrt(latDiff * latDiff + longDiff * longDiff)
+
+        assertEquals(hypotenuse, latLong1.distanceTo(latLong2))
+    }
+}
diff --git a/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LatitudeTest.kt b/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LatitudeTest.kt
new file mode 100644
index 0000000000..8788c2123a
--- /dev/null
+++ b/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LatitudeTest.kt
@@ -0,0 +1,163 @@
+package net.mullvad.mullvadvpn.model
+
+import kotlin.math.absoluteValue
+import kotlin.test.assertEquals
+import org.junit.jupiter.api.Assertions.assertDoesNotThrow
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+class LatitudeTest {
+    @Test
+    fun `creating a valid latitude should work`() {
+        assertDoesNotThrow { Latitude(30f) }
+    }
+
+    @Test
+    fun `creating a valid negative latitude should work`() {
+        assertDoesNotThrow { Latitude(-30f) }
+    }
+
+    @Test
+    fun `create with too high latitude should give IllegalArgumentException`() {
+        assertThrows<IllegalArgumentException> { Latitude(90.1f) }
+    }
+
+    @Test
+    fun `create with too low latitude should give IllegalArgumentException`() {
+        assertThrows<IllegalArgumentException> { Latitude(-90.1f) }
+    }
+
+    @Test
+    fun `fromFloat should accept and wrap large value`() {
+        val longFloat = 400f
+        val longitude = Latitude.fromFloat(longFloat)
+
+        assertEquals(40f, longitude.value)
+    }
+
+    @Test
+    fun `fromFloat should accept and support half-wrap`() {
+        val longFloat = 100f
+        val longitude = Latitude.fromFloat(longFloat)
+
+        assertEquals(80f, longitude.value)
+    }
+
+    @Test
+    fun `fromFloat should accept and support negative half-wrap`() {
+        val longFloat = -100f
+        val longitude = Latitude.fromFloat(longFloat)
+
+        assertEquals(-80f, longitude.value)
+    }
+
+    @Test
+    fun `adding two positive latitude should result in the sum`() {
+        val latFloat1 = 20f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = 30f
+        val latitude2 = Latitude(latFloat2)
+
+        assertEquals(latFloat1 + latFloat2, (latitude1 + latitude2).value)
+    }
+
+    @Test
+    fun `adding two large positive latitude should result in the sum wrapped`() {
+        val latFloat1 = 70f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = 50f
+        val latitude2 = Latitude(latFloat2)
+
+        val expectedResult = 60f
+
+        assertEquals(expectedResult, (latitude1 + latitude2).value)
+    }
+
+    @Test
+    fun `adding two negative latitude should result in the sum`() {
+        val latFloat1 = -20f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = -40f
+        val latitude2 = Latitude(latFloat2)
+
+        assertEquals(latFloat1 + latFloat2, (latitude1 + latitude2).value)
+    }
+
+    @Test
+    fun `adding two large negative latitude should result in the sum`() {
+        val latFloat1 = -70f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = -50f
+        val latitude2 = Latitude(latFloat2)
+
+        val expectedResult = -60f
+
+        assertEquals(expectedResult, (latitude1 + latitude2).value)
+    }
+
+    @Test
+    fun `subtracting two positive latitude should result in the sum`() {
+        val latFloat1 = 80f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = 30f
+        val latitude2 = Latitude(latFloat2)
+
+        assertEquals(latFloat1 - latFloat2, (latitude1 - latitude2).value)
+    }
+
+    @Test
+    fun `subtracting a large latitude should result in the sum wrapped`() {
+        val latFloat1 = -30f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = 80f
+        val latitude2 = Latitude(latFloat2)
+
+        val expectedResult = -70f
+
+        assertEquals(expectedResult, (latitude1 - latitude2).value)
+    }
+
+    @Test
+    fun `subtracting a negative latitude should result in same as addition`() {
+        val latFloat1 = -30f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = -40f
+        val latitude2 = Latitude(latFloat2)
+
+        assertEquals(latFloat1 + latFloat2.absoluteValue, (latitude1 - latitude2).value)
+    }
+
+    @Test
+    fun `subtracting a large negative latitude should result in same as addition wrapped`() {
+        val latFloat1 = 80f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = -90f
+        val latitude2 = Latitude(latFloat2)
+
+        val absoluteLatitude2 = Latitude.fromFloat(latFloat2.absoluteValue)
+
+        assertEquals(latitude1 + absoluteLatitude2, latitude1 - latitude2)
+    }
+
+    @Test
+    fun `distanceTo with two positive latitudes`() {
+        val latFloat1 = 80f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = 30f
+        val latitude2 = Latitude(latFloat2)
+
+        assertEquals(latFloat1 - latFloat2, latitude1.distanceTo(latitude2))
+    }
+
+    @Test
+    fun `distanceTo with two negative latitudes`() {
+        val latFloat1 = -80f
+        val latitude1 = Latitude(latFloat1)
+        val latFloat2 = -30f
+        val latitude2 = Latitude(latFloat2)
+
+        val expectedValue = 50f
+
+        assertEquals(expectedValue, latitude1.distanceTo(latitude2))
+    }
+}
diff --git a/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LongitudeTest.kt b/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LongitudeTest.kt
new file mode 100644
index 0000000000..de94661ad0
--- /dev/null
+++ b/android/lib/model/src/test/kotlin/net/mullvad/mullvadvpn/model/LongitudeTest.kt
@@ -0,0 +1,154 @@
+package net.mullvad.mullvadvpn.model
+
+import kotlin.math.absoluteValue
+import kotlin.test.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
+
+class LongitudeTest {
+    @Test
+    fun `create longitude with longitude should work`() {
+        assertDoesNotThrow { Longitude(80f) }
+    }
+
+    @Test
+    fun `create longitude with negative longitude should work`() {
+        assertDoesNotThrow { Longitude(-80f) }
+    }
+
+    @Test
+    fun `create too high longitude should give IllegalArgumentException`() {
+        assertThrows<IllegalArgumentException> { Longitude(180.1f) }
+    }
+
+    @Test
+    fun `create too low longitude should give IllegalArgumentException`() {
+        assertThrows<IllegalArgumentException> { Longitude(-180.1f) }
+    }
+
+    @Test
+    fun `fromFloat should accept and wrap large value`() {
+        val longFloat = 720f
+        val longitude = Longitude.fromFloat(longFloat)
+
+        assertEquals(0f, longitude.value)
+    }
+
+    @Test
+    fun `fromFloat should accept and wrap large negative value`() {
+        val longFloat = -720f
+        val longitude = Longitude.fromFloat(longFloat)
+
+        assertEquals(0f, longitude.value, 0f)
+    }
+
+    @Test
+    fun `adding two positive longitude should result in the sum`() {
+        val longFloat1 = 80f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = 30f
+        val longitude2 = Longitude(longFloat2)
+
+        assertEquals(longFloat1 + longFloat2, (longitude1 + longitude2).value)
+    }
+
+    @Test
+    fun `adding two large positive longitude should result in the sum wrapped`() {
+        val longFloat1 = 170f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = 150f
+        val longitude2 = Longitude(longFloat2)
+
+        val expectedResult = -40f
+
+        assertEquals(expectedResult, (longitude1 + longitude2).value)
+    }
+
+    @Test
+    fun `adding two negative longitude should result in the sum wrapped`() {
+        val longFloat1 = -80f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = -40f
+        val longitude2 = Longitude(longFloat2)
+
+        assertEquals(longFloat1 + longFloat2, (longitude1 + longitude2).value)
+    }
+
+    @Test
+    fun `subtracting two positive longitude should result in the sum`() {
+        val longFloat1 = 80f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = 30f
+        val longitude2 = Longitude(longFloat2)
+
+        assertEquals(longFloat1 - longFloat2, (longitude1 - longitude2).value)
+    }
+
+    @Test
+    fun `subtracting a large longitude should result in the sum wrapped`() {
+        val longFloat1 = -30f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = 170f
+        val longitude2 = Longitude(longFloat2)
+
+        val expectedResult = 160f
+
+        assertEquals(expectedResult, (longitude1 - longitude2).value)
+    }
+
+    @Test
+    fun `subtracting a negative latitude should result in same as addition`() {
+        val longFloat1 = -80f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = -40f
+        val longitude2 = Longitude(longFloat2)
+
+        assertEquals(longFloat1 + longFloat2.absoluteValue, (longitude1 - longitude2).value)
+    }
+
+    @Test
+    fun `subtracting a large negative latitude should result in same as addition wrapped`() {
+        val longFloat1 = 80f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = -140f
+        val longitude2 = Longitude(longFloat2)
+
+        val absoluteLongitude2 = Longitude.fromFloat(longFloat2.absoluteValue)
+        assertEquals(longitude1 + absoluteLongitude2, longitude1 - longitude2)
+    }
+
+    @Test
+    fun `distanceTo with two positive longitudes`() {
+        val longFloat1 = 80f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = 30f
+        val longitude2 = Longitude(longFloat2)
+
+        assertEquals(longFloat1 - longFloat2, longitude1.distanceTo(longitude2))
+    }
+
+    @Test
+    fun `distanceTo with two negative longitudes`() {
+        val longFloat1 = -80f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = -30f
+        val longitude2 = Longitude(longFloat2)
+
+        val expectedValue = 50f
+
+        assertEquals(expectedValue, longitude1.distanceTo(longitude2))
+    }
+
+    @Test
+    fun `distanceTo with wrapping value as shortest path`() {
+        val longFloat1 = -170f
+        val longitude1 = Longitude(longFloat1)
+        val longFloat2 = 170f
+        val longitude2 = Longitude(longFloat2)
+
+        val expectedValue = 20f
+
+        assertEquals(expectedValue, longitude1.distanceTo(longitude2))
+    }
+}