test: Add instrumented tests for GPU, Camera, and Font collectors

Add instrumented tests that run on real Android devices/emulators to verify:
- GpuCollector: EGL context creation, renderer/vendor info, resource cleanup
- CameraCollector: Camera2 API access, facing values, repeated calls
- FontCollector: Typeface detection, standard fonts, consistency

These tests require actual Android APIs and cannot be mocked in unit tests.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: oschwald

device-sdk/src/androidTest/java/com/maxmind/device/collector/CameraCollectorInstrumentedTest.kt

@@ -0,0 +1,62 @@
+package com.maxmind.device.collector
+
+import android.hardware.camera2.CameraCharacteristics
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Instrumented tests for [CameraCollector].
+ *
+ * These tests run on an Android device/emulator to verify camera info collection
+ * using real Camera2 API.
+ */
+@RunWith(AndroidJUnit4::class)
+public class CameraCollectorInstrumentedTest {
+    @Test
+    public fun collect_returnsCameraListOrEmpty() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val collector = CameraCollector(context)
+
+        val result = collector.collect()
+
+        assertNotNull("Camera list should not be null", result)
+        // Most devices have at least one camera, but emulators may not
+    }
+
+    @Test
+    public fun collect_cameraInfoHasValidFacing() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val collector = CameraCollector(context)
+
+        val result = collector.collect()
+
+        result.forEach { cameraInfo ->
+            assertNotNull("Camera ID should not be null", cameraInfo.cameraID)
+            assertTrue(
+                "Facing should be FRONT (0), BACK (1), or EXTERNAL (2)",
+                cameraInfo.facing in
+                    listOf(
+                        CameraCharacteristics.LENS_FACING_FRONT,
+                        CameraCharacteristics.LENS_FACING_BACK,
+                        CameraCharacteristics.LENS_FACING_EXTERNAL,
+                    ),
+            )
+        }
+    }
+
+    @Test
+    public fun collect_doesNotCrashOnRepeatedCalls() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val collector = CameraCollector(context)
+
+        // Multiple calls should not crash
+        repeat(3) {
+            val result = collector.collect()
+            assertNotNull(result)
+        }
+    }
+}

device-sdk/src/androidTest/java/com/maxmind/device/collector/FontCollectorInstrumentedTest.kt

@@ -0,0 +1,65 @@
+package com.maxmind.device.collector
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Instrumented tests for [FontCollector].
+ *
+ * These tests run on an Android device/emulator to verify font detection
+ * using real Android Typeface API.
+ */
+@RunWith(AndroidJUnit4::class)
+public class FontCollectorInstrumentedTest {
+    @Test
+    public fun collect_returnsFontInfo() {
+        val collector = FontCollector()
+
+        val result = collector.collect()
+
+        assertNotNull("Font info should not be null", result)
+        assertNotNull("Available fonts list should not be null", result.availableFonts)
+    }
+
+    @Test
+    public fun collect_detectsRobotoFont() {
+        val collector = FontCollector()
+
+        val result = collector.collect()
+
+        // Roboto is always available as the default Android font
+        // FontCollector only tests fonts from its TEST_FONTS list
+        assertTrue(
+            "Roboto font should be available (Android default)",
+            result.availableFonts.contains("Roboto"),
+        )
+    }
+
+    @Test
+    public fun collect_returnsNonEmptyFontList() {
+        val collector = FontCollector()
+
+        val result = collector.collect()
+
+        assertTrue(
+            "Available fonts should not be empty",
+            result.availableFonts.isNotEmpty(),
+        )
+    }
+
+    @Test
+    public fun collect_isConsistentAcrossMultipleCalls() {
+        val collector = FontCollector()
+
+        val result1 = collector.collect()
+        val result2 = collector.collect()
+
+        assertTrue(
+            "Font list should be consistent across calls",
+            result1.availableFonts == result2.availableFonts,
+        )
+    }
+}

device-sdk/src/androidTest/java/com/maxmind/device/collector/GpuCollectorInstrumentedTest.kt

@@ -0,0 +1,63 @@
+package com.maxmind.device.collector
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Instrumented tests for [GpuCollector].
+ *
+ * These tests run on an Android device/emulator to verify GPU info collection
+ * using real EGL contexts.
+ */
+@RunWith(AndroidJUnit4::class)
+public class GpuCollectorInstrumentedTest {
+    @Test
+    public fun collect_returnsGpuInfoOrNullGracefully() {
+        val collector = GpuCollector()
+
+        val result = collector.collect()
+
+        // On most devices, GPU info should be available
+        // On emulators without GPU support, null is acceptable
+        if (result != null) {
+            // If we got a result, it should have meaningful data
+            assertTrue(
+                "Renderer or vendor should be non-null",
+                result.renderer != null || result.vendor != null,
+            )
+        }
+        // Test passes whether result is null or non-null
+        // The key is that it doesn't crash
+    }
+
+    @Test
+    public fun collect_doesNotCrashOnRepeatedCalls() {
+        val collector = GpuCollector()
+
+        // Multiple calls should not leak EGL resources or crash
+        repeat(5) {
+            val result = collector.collect()
+            // Just verify no crash - result can be null or non-null
+        }
+    }
+
+    @Test
+    public fun collect_handlesMultipleCollectorInstances() {
+        // Verify that multiple collector instances don't interfere
+        val collector1 = GpuCollector()
+        val collector2 = GpuCollector()
+
+        val result1 = collector1.collect()
+        val result2 = collector2.collect()
+
+        // Results should be consistent (both null or both non-null with same values)
+        if (result1 != null && result2 != null) {
+            assertTrue(
+                "Renderer should be consistent across instances",
+                result1.renderer == result2.renderer,
+            )
+        }
+    }
+}