test: add android-maps-robolectric unit test suites for maps-compose and navigation-app

gradle/libs.versions.toml

@@ -34,6 +34,7 @@ materialIconsExtendedAndroid = "1.7.8"
 
 # Google Maps Platform
 mapsecrets = "2.0.1"
+mapsRobolectric = "1.2.0-rc01"
 mapsutils = "7.0.0"
 navigation = "8.0.0"
 places = "6.0.2"
@@ -88,6 +89,7 @@ androidx-compose-material3 = { module = "androidx.compose.material3:material3",
 material = { group = "com.google.android.material", name = "material", version.ref = "material" }
 
 # Google Maps Platform
+maps-robolectric-shadows = { module = "com.google.android.maps.robolectric:shadows", version.ref = "mapsRobolectric" }
 maps-utils-core = { module = "com.google.maps.android:android-maps-utils-core", version.ref = "mapsutils" }
 maps-utils = { module = "com.google.maps.android:android-maps-utils", version.ref = "mapsutils" }
 maps-secrets-plugin = { module = "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin", version.ref = "mapsecrets" }

maps-compose/build.gradle.kts

@@ -56,6 +56,12 @@ android {
             enableAndroidTestCoverage = true
         }
     }
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+    }
 }
 
 kotlin {
@@ -92,9 +98,14 @@ dependencies {
     api(libs.maps.utils.core)
 
     testImplementation(libs.test.junit)
+    testImplementation(libs.robolectric)
+    testImplementation(libs.truth)
     testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.maps.robolectric.shadows)
     testImplementation(libs.mockk)
-    testImplementation(libs.truth)
+    testImplementation(libs.androidx.test.compose.ui)
+    testImplementation(libs.androidx.activity.compose)
+    testImplementation(libs.androidx.test.core)
 
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.androidx.test.espresso)

maps-compose/src/debug/AndroidManifest.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2026 Google LLC
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application>
+        <activity
+            android:name="androidx.activity.ComponentActivity"
+            android:exported="true" />
+    </application>
+</manifest>

maps-compose/src/test/java/com/google/maps/android/compose/CameraPositionStateTest.kt

@@ -16,71 +16,135 @@
 
 package com.google.maps.android.compose
 
+import android.app.Activity
+import android.os.Bundle
 import com.google.android.gms.maps.CameraUpdateFactory
+import com.google.android.gms.maps.GoogleMap
+import com.google.android.gms.maps.MapView
 import com.google.android.gms.maps.model.CameraPosition
 import com.google.android.gms.maps.model.LatLng
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
+import com.google.android.maps.robolectric.annotation.EnableMapsShadows
+import com.google.android.maps.robolectric.shadows.ShadowGoogleMap
+import com.google.android.maps.robolectric.truth.LatLngSubject
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.test.runTest
 import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.shadow.api.Shadow
+import org.robolectric.shadows.ShadowLooper
+import java.util.concurrent.atomic.AtomicReference
 
-public class CameraPositionStateTest {
+// [START maps_compose_camera_position_state_test]
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@EnableMapsShadows
+internal class CameraPositionStateTest {
 
-    private val explicitPosition = CameraPosition.fromLatLngZoom(LatLng(48.1, 11.5), 15f)
+    private lateinit var googleMap: GoogleMap
+    private lateinit var shadowMap: ShadowGoogleMap
+
+    private val sydney: LatLng = LatLng(-33.852, 151.211)
+    private val tokyo: LatLng = LatLng(35.6762, 139.6503)
 
     @Before
-    public fun setUp() {
-        initFakeCameraUpdateFactory()
+    internal fun setUp() {
+        val activity = Robolectric.buildActivity(Activity::class.java).create().get()
+        val mapView = MapView(activity)
+        mapView.onCreate(Bundle())
+
+        val mapRef = AtomicReference<GoogleMap>()
+        mapView.getMapAsync { mapRef.set(it) }
+        ShadowLooper.idleMainLooper()
+
+        googleMap = mapRef.get()
+        shadowMap = Shadow.extract(googleMap) as ShadowGoogleMap
     }
 
     @Test
-    public fun testSettingPositionWhileUnboundOverridesPendingMove() {
-        val state = CameraPositionState()
-        state.move(CameraUpdateFactory.zoomTo(3f))
-        state.position = explicitPosition
+    internal fun testInitialPosition_withoutMapBound() {
+        val state = CameraPositionState(position = CameraPosition.fromLatLngZoom(sydney, 10f))
+        assertThat(state.position.target).isEqualTo(sydney)
+        assertThat(state.position.zoom).isEqualTo(10f)
+        assertThat(state.isMoving).isFalse()
+        assertThat(state.projection).isNull()
+    }
 
-        val calls = mutableListOf<FakeCall>()
-        state.setMap(fakeGoogleMap(calls))
+    @Test
+    internal fun testSetMap_syncsPositionFromStateToMap() {
+        val initialPosition = CameraPosition.fromLatLngZoom(sydney, 12f)
+        val state = CameraPositionState(position = initialPosition)
 
-        assertEquals(listOf(moveCameraTo(explicitPosition)), calls.filter { it.method == "moveCamera" })
+        state.setMap(googleMap)
+
+        assertThat(googleMap.cameraPosition.target).isEqualTo(sydney)
+        assertThat(googleMap.cameraPosition.zoom).isEqualTo(12f)
+        assertThat(state.projection).isNotNull()
     }
 
-    @Test(timeout = 5_000)
-    public fun testSettingPositionWhileUnboundCancelsPendingAnimate(): Unit = runBlocking {
-        val state = CameraPositionState()
-        val animation = launch(start = CoroutineStart.UNDISPATCHED) {
-            state.animate(CameraUpdateFactory.zoomTo(3f))
+    private fun bindState(state: CameraPositionState) {
+        state.setMap(googleMap)
+        googleMap.setOnCameraMoveStartedListener { reason ->
+            state.cameraMoveStartedReason = CameraMoveStartedReason.fromInt(reason)
+            state.isMoving = true
+        }
+        googleMap.setOnCameraMoveListener {
+            state.rawPosition = googleMap.cameraPosition
         }
-        state.position = explicitPosition
-        animation.join()
-        assertTrue(animation.isCancelled)
+        googleMap.setOnCameraIdleListener {
+            state.isMoving = false
+            state.rawPosition = googleMap.cameraPosition
+        }
+    }
 
-        val calls = mutableListOf<FakeCall>()
-        state.setMap(fakeGoogleMap(calls))
+    @Test
+    internal fun testMove_instantaneouslyUpdatesCameraPosition() {
+        val state = CameraPositionState()
+        bindState(state)
+
+        state.move(CameraUpdateFactory.newLatLngZoom(tokyo, 14f))
 
-        assertEquals(listOf(moveCameraTo(explicitPosition)), calls.filter { it.method == "moveCamera" })
+        assertThat(googleMap.cameraPosition.target).isEqualTo(tokyo)
+        LatLngSubject.assertThat(state.position.target)
+            .isWithin(1.0)
+            .of(tokyo)
+        assertThat(state.position.zoom).isEqualTo(14f)
+        assertThat(state.isMoving).isFalse()
     }
 
     @Test
-    public fun testPendingMoveIsAppliedWhenMapIsBound() {
+    internal fun testAnimate_updatesCameraPosition(): Unit = runTest {
         val state = CameraPositionState()
-        state.move(CameraUpdateFactory.zoomTo(3f))
-
-        val calls = mutableListOf<FakeCall>()
-        state.setMap(fakeGoogleMap(calls))
-
-        assertEquals(
-            listOf(
-                moveCameraTo(state.position),
-                FakeCall("moveCamera", listOf(FakeCall("zoomTo", listOf(3f)))),
-            ),
-            calls.filter { it.method == "moveCamera" },
-        )
+        bindState(state)
+
+        state.animate(CameraUpdateFactory.newLatLngZoom(tokyo, 15f), durationMs = 1000)
+
+        assertThat(googleMap.cameraPosition.target).isEqualTo(tokyo)
+        LatLngSubject.assertThat(state.position.target)
+            .isWithin(1.0)
+            .of(tokyo)
+        assertThat(state.position.zoom).isEqualTo(15f)
+        assertThat(state.isMoving).isFalse()
     }
 
-    private fun moveCameraTo(position: CameraPosition) =
-        FakeCall("moveCamera", listOf(FakeCall("newCameraPosition", listOf(position))))
+    @Test
+    internal fun testProjection_convertsCoordinates() {
+        val state = CameraPositionState()
+        state.setMap(googleMap)
+
+        state.move(CameraUpdateFactory.newLatLngZoom(sydney, 10f))
+
+        val projection = state.projection
+        assertThat(projection).isNotNull()
+        val screenPoint = projection?.toScreenLocation(sydney)
+        assertThat(screenPoint).isNotNull()
+        val roundTripLatLng = projection?.fromScreenLocation(screenPoint!!)
+        LatLngSubject.assertThat(roundTripLatLng)
+            .isWithin(1.0)
+            .of(sydney)
+    }
 }
+// [END maps_compose_camera_position_state_test]