Add unit and instrumentation tests for Utils and MarkerDao

app/src/androidTest/java/org/nitri/opentopo/da/MarkerDaoInstrumentedTest.kt

@@ -0,0 +1,52 @@
+package org.nitri.opentopo.da
+
+import androidx.room.Room
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.nitri.opentopo.model.MarkerModel
+import org.nitri.opentopo.overlay.OverlayDatabase
+
+@RunWith(AndroidJUnit4::class)
+class MarkerDaoInstrumentedTest {
+    private lateinit var db: OverlayDatabase
+    private lateinit var dao: MarkerDao
+
+    @Before fun setup() {
+        db = Room.inMemoryDatabaseBuilder(ApplicationProvider.getApplicationContext(), OverlayDatabase::class.java)
+            .allowMainThreadQueries().build()
+        dao = db.markerDao()
+    }
+
+    @After fun teardown() { db.close() }
+
+    @Test fun insertUpdateDeleteMarker_flowWorks() = runBlocking {
+        dao.insertMarker(MarkerModel(seq = 1, latitude = 1.0, longitude = 2.0, name = "A", description = "x"))
+        val inserted = dao.getAllMarkersNow()
+        assertEquals(1, inserted.size)
+        val updated = inserted.first().copy(name = "B")
+        dao.updateMarker(updated)
+        assertEquals("B", dao.getAllMarkersNow().first().name)
+        dao.deleteMarkerById(updated.id)
+        assertTrue(dao.getAllMarkersNow().isEmpty())
+    }
+
+    @Test fun deleteMarkersByIds_removesMultiple() = runBlocking {
+        dao.insertMarkers(listOf(
+            MarkerModel(seq = 1, latitude = 1.0, longitude = 1.0, name = "a", description = ""),
+            MarkerModel(seq = 2, latitude = 2.0, longitude = 2.0, name = "b", description = ""),
+            MarkerModel(seq = 3, latitude = 3.0, longitude = 3.0, name = "c", description = "")
+        ))
+        val all = dao.getAllMarkersNow()
+        dao.deleteMarkersByIds(listOf(all[0].id, all[1].id))
+        val remaining = dao.getAllMarkersNow()
+        assertEquals(1, remaining.size)
+        assertEquals("c", remaining.first().name)
+    }
+}

app/src/androidTest/java/org/nitri/opentopo/util/UtilsInstrumentedTest.kt

@@ -0,0 +1,64 @@
+package org.nitri.opentopo.util
+
+import androidx.appcompat.content.res.AppCompatResources
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.ticofab.androidgpxparser.parser.domain.Gpx
+import io.ticofab.androidgpxparser.parser.domain.WayPoint
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.nitri.opentopo.R
+
+@RunWith(AndroidJUnit4::class)
+class UtilsInstrumentedTest {
+
+    @Test
+    fun getBitmapFromDrawable_returnsBitmapWithIntrinsicDimensions() {
+        val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+        val drawable = AppCompatResources.getDrawable(context, R.drawable.ic_action_layers)
+        requireNotNull(drawable)
+
+        val bitmap = Utils.getBitmapFromDrawable(context, R.drawable.ic_action_layers, 255)
+
+        assertNotNull(bitmap)
+        assertEquals(drawable.intrinsicWidth, bitmap.width)
+        assertEquals(drawable.intrinsicHeight, bitmap.height)
+    }
+
+    @Test
+    fun elevationFromNmea_validSentenceReturnsElevation() {
+        val nmea = "\$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,100.0,M,46.9,M,,*47"
+        val elevation = Utils.elevationFromNmea(nmea)
+        assertEquals(100.0, elevation, 0.0)
+    }
+
+    @Test
+    fun elevationFromNmea_invalidSentenceReturnsNoElevationValue() {
+        val elevation = Utils.elevationFromNmea("INVALID")
+        assertEquals(Utils.NO_ELEVATION_VALUE.toDouble(), elevation, 0.0)
+    }
+
+    @Test
+    fun getWayPointTypes_returnsSortedDistinctTypes() {
+        val points = listOf(
+            WayPoint.Builder().setType("summit").build() as WayPoint,
+            WayPoint.Builder().setType("cafe").build() as WayPoint,
+            WayPoint.Builder().setType("").build() as WayPoint,
+            WayPoint.Builder().setType("summit").build() as WayPoint
+        )
+        val gpx = Gpx.Builder().setTracks(emptyList()).setRoutes(emptyList()).setWayPoints(points).build()
+        val types = Utils.getWayPointTypes(gpx, "default")
+        assertEquals(listOf("cafe", "default", "summit"), types)
+    }
+
+    @Test
+    fun getWayPointsByType_filtersCorrectly() {
+        val summit = WayPoint.Builder().setType("summit").build() as WayPoint
+        val blank = WayPoint.Builder().setType("").build() as WayPoint
+        val gpx = Gpx.Builder().setTracks(emptyList()).setRoutes(emptyList()).setWayPoints(listOf(summit, blank)).build()
+        assertEquals(1, Utils.getWayPointsByType(gpx, "summit").size)
+        assertEquals(1, Utils.getWayPointsByType(gpx, "").size)
+    }
+}

app/src/test/java/org/nitri/opentopo/DistanceCalculatorTest.kt → app/src/test/java/org/nitri/opentopo/util/DistanceCalculatorTest.kt

@@ -1,8 +1,7 @@
-package org.nitri.opentopo
+package org.nitri.opentopo.util
 
-import org.junit.Assert.assertEquals
+import org.junit.Assert
 import org.junit.Test
-import org.nitri.opentopo.util.DistanceCalculator
 
 class DistanceCalculatorTest {
 
@@ -13,7 +12,7 @@ class DistanceCalculatorTest {
 
         val distance = DistanceCalculator.distance(latitude, longitude, latitude, longitude)
 
-        assertEquals(0.0, distance, 0.0)
+        Assert.assertEquals(0.0, distance, 0.0)
     }
 
     @Test
@@ -28,6 +27,6 @@ class DistanceCalculatorTest {
         val expectedDistanceMeters = 343_556.0
         val toleranceMeters = 1_000.0
 
-        assertEquals(expectedDistanceMeters, distance, toleranceMeters)
+        Assert.assertEquals(expectedDistanceMeters, distance, toleranceMeters)
     }
-}
+}

app/src/test/java/org/nitri/opentopo/util/UtilsTest.kt

@@ -0,0 +1,56 @@
+package org.nitri.opentopo.util
+
+import io.ticofab.androidgpxparser.parser.domain.Gpx
+import io.ticofab.androidgpxparser.parser.domain.Route
+import io.ticofab.androidgpxparser.parser.domain.RoutePoint
+import io.ticofab.androidgpxparser.parser.domain.Track
+import io.ticofab.androidgpxparser.parser.domain.TrackPoint
+import io.ticofab.androidgpxparser.parser.domain.TrackSegment
+import io.ticofab.androidgpxparser.parser.domain.WayPoint
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class UtilsTest {
+    private fun buildGpx(
+        tracks: List<Track> = emptyList(),
+        routes: List<Route> = emptyList(),
+        wayPoints: List<WayPoint> = emptyList()
+    ): Gpx = Gpx.Builder().setTracks(tracks).setRoutes(routes).setWayPoints(wayPoints).build()
+
+    @Test
+    fun area_usesTrackPointsWhenPresent() {
+        val trackPoints = listOf(
+            TrackPoint.Builder().setLatitude(10.0).setLongitude(20.0).build() as TrackPoint,
+            TrackPoint.Builder().setLatitude(12.0).setLongitude(18.0).build() as TrackPoint,
+            TrackPoint.Builder().setLatitude(8.0).setLongitude(25.0).build() as TrackPoint
+        )
+        val track = Track.Builder().setTrackSegments(listOf(TrackSegment.Builder().setTrackPoints(trackPoints).build())).build()
+        val bounds = Utils.area(buildGpx(tracks = listOf(track)))
+        assertEquals(12.0, bounds.latNorth, 0.0)
+        assertEquals(8.0, bounds.latSouth, 0.0)
+        assertEquals(25.0, bounds.lonEast, 0.0)
+        assertEquals(18.0, bounds.lonWest, 0.0)
+    }
+
+    @Test
+    fun convertRouteToTrack_createsSyntheticTrackWhenNoTrackExists() {
+        val routePoints = listOf(
+            RoutePoint.Builder().setLatitude(1.0).setLongitude(2.0).setDesc("a").build() as RoutePoint,
+            RoutePoint.Builder().setLatitude(3.0).setLongitude(4.0).setDesc("b").build() as RoutePoint
+        )
+        val route = Route.Builder().setRoutePoints(routePoints).build()
+        val converted = Utils.convertRouteToTrack(buildGpx(routes = listOf(route)))
+        assertEquals(1, converted.tracks?.size)
+        assertEquals(2, converted.tracks?.first()?.trackSegments?.first()?.trackPoints?.size)
+        assertTrue(converted.routes?.isNotEmpty() == true)
+    }
+
+    @Test
+    fun convertRouteToTrack_returnsOriginalWhenTrackPresent() {
+        val existingTrack = Track.Builder().setTrackSegments(emptyList()).build()
+        val gpx = buildGpx(tracks = listOf(existingTrack))
+        assertSame(gpx, Utils.convertRouteToTrack(gpx))
+    }
+}