@mentra/bluetooth-sdk 3.2.1 → 3.3.0-beta.954

package/android/src/test/java/com/mentra/bluetoothsdk/BluetoothSdkUsageTrackerTest.kt

@@ -0,0 +1,263 @@
+package com.mentra.bluetoothsdk
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class BluetoothSdkUsageTrackerTest {
+    private val tracker = BluetoothSdkUsageTracker()
+
+    @Test
+    fun `an API photo reports its request shape, latency and outcome`() {
+        val ok = tracker.photoSettled("medium", "photo", "none", save = true, transferMethod = "auto", latencyMs = 812, fileSizeBytes = 204_800, errorCode = null)
+        assertThat(ok.name).isEqualTo("bluetooth_sdk_photo_taken")
+        assertThat(ok.properties)
+            .containsEntry("trigger", "api")
+            .containsEntry("success", true)
+            .containsEntry("latency_ms", 812L)
+            .containsEntry("photo_size", "medium")
+            .containsEntry("save_to_gallery", true)
+            .containsEntry("transfer_method", "auto")
+            .containsEntry("file_size_bytes", 204_800L)
+            .doesNotContainKey("error_code")
+
+        val failed = tracker.photoSettled("max", "photo", "none", save = false, transferMethod = "ble", latencyMs = 30_000, fileSizeBytes = null, errorCode = "request_timeout")
+        assertThat(failed.properties)
+            .containsEntry("success", false)
+            .containsEntry("error_code", "request_timeout")
+            .doesNotContainKey("file_size_bytes")
+    }
+
+    @Test
+    fun `a failed button photo is reported as a button trigger`() {
+        val event = tracker.buttonPhotoFailed("CAMERA_BUSY")
+        assertThat(event.properties).containsEntry("trigger", "button").containsEntry("success", false).containsEntry("error_code", "CAMERA_BUSY")
+    }
+
+    @Test
+    fun `an API recording reports its length, parameters and app stop once`() {
+        tracker.videoRequested("rec-1", width = 1920, height = 1080, fps = 30, save = true, maxDurationMinutes = 0)
+        assertThat(tracker.videoStatus("rec-1", "recording_started", success = true, nowMs = 1_000)).isNull()
+        // A duplicate start does not move the start time.
+        assertThat(tracker.videoStatus("rec-1", "recording_started", success = true, nowMs = 2_000)).isNull()
+        tracker.videoStopRequested("rec-1")
+
+        val stopped = tracker.videoStatus("rec-1", "recording_stopped", success = true, nowMs = 61_000)!!
+        assertThat(stopped.name).isEqualTo("bluetooth_sdk_video_recorded")
+        assertThat(stopped.properties)
+            .containsEntry("trigger", "api")
+            .containsEntry("success", true)
+            .containsEntry("duration_ms", 60_000L)
+            .containsEntry("width", 1920)
+            .containsEntry("fps", 30)
+            .containsEntry("save_to_gallery", true)
+            .containsEntry("stopped_by_app", true)
+            .doesNotContainKey("max_duration_minutes")
+
+        assertThat(tracker.videoStatus("rec-1", "recording_stopped", success = true, nowMs = 62_000)).isNull()
+    }
+
+    @Test
+    fun `a button recording is reported with a button trigger and no app stop`() {
+        val id = "local_video_1728000000_ab12"
+        tracker.videoStatus(id, "recording_started", success = true, nowMs = 0)
+        val stopped = tracker.videoStatus(id, "recording_stopped", success = true, nowMs = 5_000)!!
+        assertThat(stopped.properties)
+            .containsEntry("trigger", "button")
+            .containsEntry("duration_ms", 5_000L)
+            .containsEntry("stopped_by_app", false)
+    }
+
+    @Test
+    fun `a recording failure is reported, but not_recording is not a recording`() {
+        tracker.videoRequested("rec-2", 0, 0, 0, save = false, maxDurationMinutes = 5)
+        val failed = tracker.videoStatus("rec-2", "battery_low", success = false, nowMs = 0)!!
+        assertThat(failed.properties)
+            .containsEntry("success", false)
+            .containsEntry("error_code", "battery_low")
+            .containsEntry("max_duration_minutes", 5)
+            .doesNotContainKey("duration_ms")
+            .doesNotContainKey("width")
+
+        assertThat(tracker.videoStatus("rec-3", "not_recording", success = false, nowMs = 0)).isNull()
+        assertThat(tracker.videoStatus("", "recording_stopped", success = true, nowMs = 0)).isNull()
+    }
+
+    @Test
+    fun `a stream is reported at start and once at its terminal status`() {
+        assertThat(tracker.streamRequested("s1", "rtmps://live.example.com/app/secret-key", nowMs = 6_600)).isNull()
+        // The first live status can arrive before startStream returns.
+        assertThat(stream("streaming", nowMs = 10_000)).isNull()
+        val started =
+            tracker.streamStartSettled(
+                streamUrl = "rtmps://live.example.com/app/secret-key",
+                width = 1280,
+                height = 720,
+                fps = 30,
+                bitrate = 2_000_000,
+                captureAudio = true,
+                glassesNetwork = "wifi",
+                latencyMs = 3_400,
+                errorCode = null,
+            )
+        assertThat(started.name).isEqualTo("bluetooth_sdk_stream_started")
+        assertThat(started.properties)
+            .containsEntry("success", true)
+            .containsEntry("protocol", "rtmp")
+            .containsEntry("glasses_network", "wifi")
+        assertThat(started.properties.values.map { it.toString() }).noneMatch { it.contains("secret-key") }
+
+        assertThat(stream("reconnecting", reconnectAttempt = 1, nowMs = 20_000)).isNull()
+        assertThat(stream("reconnected", reconnectAttempt = 2, nowMs = 21_000)).isNull()
+        assertThat(stream("streaming", bitrate = 1_800_000, droppedFrames = 12, nowMs = 30_000)).isNull()
+        // Statuses for another stream id do not touch this one.
+        assertThat(tracker.streamStatus("other", "stopped", true, null, null, null, null, null, null, 31_000)).isNull()
+        tracker.streamStopRequested()
+
+        val ended = stream("stopped", terminal = true, nowMs = 70_000)!!
+        assertThat(ended.name).isEqualTo("bluetooth_sdk_stream_ended")
+        assertThat(ended.properties)
+            .containsEntry("protocol", "rtmp")
+            .containsEntry("duration_ms", 60_000L)
+            .containsEntry("end_state", "stopped")
+            .containsEntry("stopped_by_app", true)
+            .containsEntry("reconnect_attempts", 2)
+            .containsEntry("bitrate", 1_800_000L)
+            .containsEntry("dropped_frames", 12L)
+
+        assertThat(stream("stopped", terminal = true, nowMs = 71_000)).isNull()
+    }
+
+    @Test
+    fun `a stream that ends right after going live is still reported`() {
+        tracker.streamRequested("s1", "rtmp://host/app", nowMs = 0)
+        assertThat(stream("streaming", nowMs = 1_000)).isNull()
+        val ended = stream("error", terminal = true, nowMs = 1_500)!!
+        assertThat(ended.properties).containsEntry("duration_ms", 500L).containsEntry("end_state", "error")
+    }
+
+    @Test
+    fun `a new start reports the live stream it replaces`() {
+        tracker.streamRequested("s1", "rtmp://host/app", nowMs = 0)
+        stream("streaming", nowMs = 1_000)
+        val replaced = tracker.streamRequested("s2", "srt://host:9000", nowMs = 11_000)!!
+        assertThat(replaced.name).isEqualTo("bluetooth_sdk_stream_ended")
+        assertThat(replaced.properties)
+            .containsEntry("protocol", "rtmp")
+            .containsEntry("end_state", "replaced")
+            .containsEntry("duration_ms", 10_000L)
+        // The replaced stream's own late terminal status is not reported again.
+        assertThat(stream("stopped", terminal = true, nowMs = 12_000)).isNull()
+        assertThat(tracker.streamStatus("s2", "streaming", null, null, null, null, null, null, null, 12_000)).isNull()
+        val second = tracker.streamStatus("s2", "stopped", true, null, null, null, null, null, null, 20_000)!!
+        assertThat(second.properties).containsEntry("protocol", "srt").containsEntry("duration_ms", 8_000L)
+    }
+
+    @Test
+    fun `older glasses without a terminal flag end a stream on stopped, and error details lose their URLs`() {
+        tracker.streamRequested("s2", "https://whip.example.com/whip/abc", nowMs = 0)
+        assertThat(tracker.streamStatus(null, "streaming", null, null, null, null, null, null, null, 500)).isNull()
+        assertThat(tracker.streamStatus(null, "error", null, null, null, null, null, null, null, 1_000)).isNull()
+        val ended =
+            tracker.streamStatus(null, "reconnect_failed", null, null, null, null, null, null, "connect to https://whip.example.com/whip/abc failed", 9_000)!!
+        assertThat(ended.properties)
+            .containsEntry("protocol", "whip")
+            .containsEntry("end_state", "reconnect_failed")
+            .containsEntry("error_code", "connect to <url> failed")
+            .containsEntry("stopped_by_app", false)
+    }
+
+    @Test
+    fun `a stream that never went live ends without a second event`() {
+        tracker.streamRequested("s3", "srt://host:9000", nowMs = 0)
+        val failed = tracker.streamStartSettled("srt://host:9000", null, null, null, null, true, "none", 30_000, "stream_start_failed")
+        assertThat(failed.properties).containsEntry("success", false).containsEntry("error_code", "stream_start_failed").containsEntry("protocol", "srt")
+        assertThat(tracker.streamStatus("s3", "stopped", true, null, null, null, null, null, null, 1_000)).isNull()
+        // Nothing live was replaced either.
+        assertThat(tracker.streamRequested("s4", "srt://host:9000", nowMs = 2_000)).isNull()
+    }
+
+    @Test
+    fun `stream protocol follows the glasses scheme mapping`() {
+        assertThat(BluetoothSdkUsageTracker.streamProtocol("rtmp://a")).isEqualTo("rtmp")
+        assertThat(BluetoothSdkUsageTracker.streamProtocol("RTMPS://a")).isEqualTo("rtmp")
+        assertThat(BluetoothSdkUsageTracker.streamProtocol("srt://a")).isEqualTo("srt")
+        assertThat(BluetoothSdkUsageTracker.streamProtocol("http://a")).isEqualTo("whip")
+        assertThat(BluetoothSdkUsageTracker.streamProtocol("rtmpt://a")).isEqualTo("unknown")
+        assertThat(BluetoothSdkUsageTracker.streamProtocol("not a url")).isEqualTo("unknown")
+    }
+
+    @Test
+    fun `a mic session ends when the source turns off or changes`() {
+        assertThat(tracker.observeMic("", transcribing = false, nowMs = 0)).isNull()
+        assertThat(tracker.observeMic("glasses", transcribing = false, nowMs = 1_000)).isNull()
+        assertThat(tracker.observeMic("glasses", transcribing = true, nowMs = 2_000)).isNull()
+
+        val switched = tracker.observeMic("phone", transcribing = false, nowMs = 11_000)!!
+        assertThat(switched.name).isEqualTo("bluetooth_sdk_mic_session")
+        assertThat(switched.properties)
+            .containsEntry("mic_source", "glasses")
+            .containsEntry("duration_ms", 10_000L)
+            .containsEntry("local_transcription", true)
+
+        val off = tracker.observeMic("", transcribing = false, nowMs = 14_000)!!
+        assertThat(off.properties).containsEntry("mic_source", "phone").containsEntry("duration_ms", 3_000L).containsEntry("local_transcription", false)
+        assertThat(tracker.observeMic("", transcribing = false, nowMs = 15_000)).isNull()
+    }
+
+    @Test
+    fun `wifi and hotspot setup report outcome and latency`() {
+        assertThat(tracker.wifiSetupSettled(4_000, null).properties).containsEntry("success", true).containsEntry("latency_ms", 4_000L)
+        assertThat(tracker.wifiSetupSettled(15_000, "connect_timeout").properties).containsEntry("error_code", "connect_timeout")
+        assertThat(tracker.hotspotStartSettled(2_500, null).name).isEqualTo("bluetooth_sdk_hotspot_started")
+    }
+
+    @Test
+    fun `an OTA session is reported once with its starting versions`() {
+        assertThat(ota("ota-1", "in_progress", nowMs = 0, fromBuild = "38")).isNull()
+        assertThat(ota("ota-1", "step_complete", nowMs = 60_000, fromBuild = "39")).isNull()
+        val done = ota("ota-1", "complete", nowMs = 300_000, fromBuild = "40")!!
+        assertThat(done.name).isEqualTo("bluetooth_sdk_ota_finished")
+        assertThat(done.properties)
+            .containsEntry("success", true)
+            .containsEntry("duration_ms", 300_000L)
+            .containsEntry("from_build_number", "38")
+            .containsEntry("total_steps", 2)
+            .doesNotContainKey("failed_step_type")
+        assertThat(ota("ota-1", "complete", nowMs = 301_000, fromBuild = "40")).isNull()
+
+        val failed = ota("ota-2", "failed", nowMs = 0, fromBuild = "40", stepType = "bes", error = "download failed: https://ota.example.com/x.bin")!!
+        assertThat(failed.properties)
+            .containsEntry("success", false)
+            .containsEntry("failed_step_type", "bes")
+            .containsEntry("error_message", "download failed: <url>")
+            .doesNotContainKey("duration_ms")
+    }
+
+    @Test
+    fun `request timeouts are capped per tracker`() {
+        val capped = BluetoothSdkUsageTracker(maxRequestTimeouts = 2)
+        assertThat(capped.requestTimedOut("photo request")!!.properties)
+            .containsEntry("operation", "photo request")
+            .containsEntry("error_code", "request_timeout")
+        assertThat(capped.requestTimedOut("start stream")).isNotNull()
+        assertThat(capped.requestTimedOut("start stream")).isNull()
+    }
+
+    private fun stream(
+        state: String,
+        terminal: Boolean? = null,
+        reconnectAttempt: Int? = null,
+        bitrate: Long? = null,
+        droppedFrames: Long? = null,
+        nowMs: Long,
+    ) = tracker.streamStatus("s1", state, terminal, reconnectAttempt, bitrate, null, droppedFrames, null, null, nowMs)
+
+    private fun ota(
+        sessionId: String,
+        status: String,
+        nowMs: Long,
+        fromBuild: String,
+        stepType: String = "apk",
+        error: String? = null,
+    ) = tracker.otaStatus(sessionId, status, stepType, totalSteps = 2, errorMessage = error, fromBuildNumber = fromBuild, fromBesFirmwareVersion = "", fromMtkFirmwareVersion = "", nowMs = nowMs)
+}

package/android/src/test/java/com/mentra/bluetoothsdk/NetworkDiagnosticsTest.kt

@@ -0,0 +1,55 @@
+package com.mentra.bluetoothsdk
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class NetworkDiagnosticsTest {
+    private val validatedInternet = mapOf("internet" to true, "validated" to true)
+    private val localOnly = mapOf("internet" to false, "validated" to false)
+
+    @Test
+    fun `distinguishes a process bound to glasses from a validated active network`() {
+        val snapshot = networkDiagnostics(123L, "private-glasses", "private-cellular", "private-glasses") {
+            if (it == "private-cellular") validatedInternet else localOnly
+        }
+
+        assertEquals(123L, snapshot["sampledAtMs"])
+        assertEquals(false, snapshot["processBoundMatchesActive"])
+        assertEquals(true, snapshot["processBoundMatchesGlassesLocal"])
+        assertEquals(false, snapshot["activeNetworkMatchesGlassesLocal"])
+        assertEquals(validatedInternet, observation(snapshot, "activeNetwork")["capabilities"])
+        assertFalse(snapshot.toString().contains("private-"))
+    }
+
+    @Test
+    fun `keeps an unvalidated active network distinct from a disappeared network`() {
+        val unvalidated = networkDiagnostics(124L, null, "default", null) { localOnly }
+        assertEquals(localOnly, observation(unvalidated, "activeNetwork")["capabilities"])
+        val disappeared = networkDiagnostics(125L, null, "default", null) { null }
+        assertEquals(true, observation(disappeared, "activeNetwork")["present"])
+        assertNull(observation(disappeared, "activeNetwork")["capabilities"])
+    }
+
+    @Test
+    fun `no network does not imply equal routes or attempt a capability read`() {
+        var read = false
+        val snapshot = networkDiagnostics<String>(126L, null, null, null) {
+            read = true
+            validatedInternet
+        }
+
+        assertFalse(read)
+        listOf("processBound", "activeNetwork", "glassesLocal").forEach {
+            assertEquals(false, observation(snapshot, it)["present"])
+            assertNull(observation(snapshot, it)["capabilities"])
+        }
+        assertEquals(false, snapshot["processBoundMatchesActive"])
+        assertEquals(false, snapshot["processBoundMatchesGlassesLocal"])
+        assertEquals(false, snapshot["activeNetworkMatchesGlassesLocal"])
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun observation(snapshot: Map<String, Any?>, name: String) = snapshot[name] as Map<String, Any?>
+}

package/android/src/test/java/com/mentra/bluetoothsdk/ScanCompletionTest.kt

@@ -37,7 +37,11 @@ class ScanCompletionTest {
             error("Legacy callbacks must not query diagnostics")
         }
         assertThat(completed).isTrue()
-        assertThat(ScanCallback::class.java.declaredMethods.map { it.name })
+        // Instance methods only: Kotlin 2.2+ compiles bodies to Java default
+        // methods plus static `access$...$jd` bridges, which nothing implements.
+        assertThat(ScanCallback::class.java.declaredMethods
+            .filterNot { java.lang.reflect.Modifier.isStatic(it.modifiers) }
+            .map { it.name })
             .containsExactlyInAnyOrder("onResults", "onComplete", "onError")
     }
 

package/android/src/test/java/com/mentra/bluetoothsdk/debug/BleTraceLoggerTest.kt

@@ -0,0 +1,69 @@
+package com.mentra.bluetoothsdk.debug
+
+import java.util.UUID
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.shadows.ShadowLog
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28])
+class BleTraceLoggerTest {
+    @Test
+    fun wifiScanPreservesBooleanSecurityWhileRedactingCredentials() {
+        val secret = UUID.randomUUID().toString()
+        val networks = JSONArray()
+        for (secured in listOf(true, false)) {
+            networks.put(
+                JSONObject()
+                    .put("ssid", if (secured) "secured-fixture" else "open-fixture")
+                    .put("requiresPassword", secured)
+                    .put("signalStrength", -45)
+                    .put("password", secret)
+                    .put("token", secret)
+            )
+        }
+        ShadowLog.clear()
+        BleTraceLogger.logJson(
+            "glasses_to_phone",
+            "sdk_ble_event",
+            JSONObject().put("type", "wifi_scan_result").put("networks_neo", networks),
+        )
+        val message = ShadowLog.getLogsForTag("MentraBleTrace").single().msg
+        assertFalse(message.contains(secret))
+        val actual = JSONObject(message.substringAfter("payload=")).getJSONArray("networks_neo")
+        for ((index, secured) in listOf(true, false).withIndex()) {
+            val item = actual.getJSONObject(index)
+            assertEquals(secured, item.get("requiresPassword"))
+            assertEquals(-45, item.getInt("signalStrength"))
+            assertEquals("<redacted>", item.getString("password"))
+            assertEquals("<redacted>", item.getString("token"))
+        }
+    }
+
+    @Test
+    fun exceptionDoesNotExposeNonBooleanOrOtherPasswordFields() {
+        val secret = UUID.randomUUID().toString()
+        ShadowLog.clear()
+        BleTraceLogger.logJson(
+            "glasses_to_phone",
+            "sdk_ble_event",
+            JSONObject()
+                .put("type", "wifi_scan_result")
+                .put("requiresPassword", secret)
+                .put("password", true)
+                .put("RequiresPassword", false),
+        )
+        val message = ShadowLog.getLogsForTag("MentraBleTrace").single().msg
+        assertFalse(message.contains(secret))
+        val actual = JSONObject(message.substringAfter("payload="))
+        for (key in listOf("requiresPassword", "password", "RequiresPassword")) {
+            assertEquals("<redacted>", actual.getString(key))
+        }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/ClassicAudioServiceDiscoveryTest.kt

@@ -0,0 +1,124 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.os.Handler
+import android.os.Looper
+import android.os.ParcelUuid
+import java.time.Duration
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+@LooperMode(LooperMode.Mode.PAUSED)
+class ClassicAudioServiceDiscoveryTest {
+    private val target = BluetoothAdapter.getDefaultAdapter().getRemoteDevice("AA:BB:CC:DD:EE:FF")
+    private val sink = ParcelUuid.fromString("0000110b-0000-1000-8000-00805f9b34fb")
+    private val zero = ParcelUuid.fromString("00000000-0000-0000-0000-000000000000")
+    private val messages = mutableListOf<String>()
+    private val discovery = ClassicAudioServiceDiscovery(Handler(Looper.getMainLooper()), 30000, messages::add)
+    private var connects = 0
+
+    private fun request(device: BluetoothDevice = target) {
+        discovery.connectWhenDiscovered(device) { connects++ }
+    }
+
+    @Test fun `bonded Samsung zero UUID inventory waits for real Audio Sink discovery`() {
+        shadowOf(target).setBondState(BluetoothDevice.BOND_BONDED)
+        shadowOf(target).setUuids(arrayOf(zero))
+        shadowOf(target).setFetchUuidsWithSdpResult(true)
+        request()
+        assertThat(connects).isZero()
+        assertThat(shadowOf(target).fetchUuidsWithSdpCount).isEqualTo(1)
+        shadowOf(target).setUuids(arrayOf(sink))
+        discovery.onUuids(target)
+        discovery.onUuids(target)
+        assertThat(connects).isEqualTo(1)
+        shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(30))
+        assertThat(messages.none { it.contains("timed out") }).isTrue()
+        assertThat(target.bondState).isEqualTo(BluetoothDevice.BOND_BONDED)
+    }
+
+    @Test fun `valid cached Audio Sink needs no refresh`() {
+        shadowOf(target).setUuids(arrayOf(sink))
+        request()
+        assertThat(connects).isEqualTo(1)
+        assertThat(shadowOf(target).fetchUuidsWithSdpCount).isZero()
+    }
+
+    @Test fun `early empty UUID broadcast preserves the wait for the actual SDP result`() {
+        shadowOf(target).setUuids(arrayOf(zero))
+        shadowOf(target).setFetchUuidsWithSdpResult(true)
+        request()
+        discovery.onUuids(target)
+        assertThat(connects).isZero()
+        shadowOf(target).setUuids(arrayOf(sink))
+        discovery.onUuids(target)
+        assertThat(connects).isEqualTo(1)
+        assertThat(shadowOf(target).fetchUuidsWithSdpCount).isEqualTo(1)
+    }
+
+    @Test fun `unrelated device and duplicate requests cannot complete or multiply discovery`() {
+        shadowOf(target).setFetchUuidsWithSdpResult(true)
+        request()
+        request()
+        val other = BluetoothAdapter.getDefaultAdapter().getRemoteDevice("11:22:33:44:55:66")
+        shadowOf(other).setUuids(arrayOf(sink))
+        discovery.onUuids(other)
+        assertThat(connects).isZero()
+        assertThat(shadowOf(target).fetchUuidsWithSdpCount).isEqualTo(1)
+        shadowOf(target).setUuids(arrayOf(sink))
+        discovery.onUuids(target)
+        assertThat(connects).isEqualTo(1)
+    }
+
+    @Test fun `rejected SDP request does not connect on a later unsolicited event`() {
+        shadowOf(target).setFetchUuidsWithSdpResult(false)
+        request()
+        shadowOf(target).setUuids(arrayOf(sink))
+        discovery.onUuids(target)
+        assertThat(connects).isZero()
+        assertThat(messages.last()).contains("rejected")
+    }
+
+    @Test fun `missing UUID broadcast times out without connecting on a late event`() {
+        shadowOf(target).setFetchUuidsWithSdpResult(true)
+        request()
+        shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(20))
+        discovery.onUuids(target)
+        shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(10))
+        shadowOf(target).setUuids(arrayOf(sink))
+        discovery.onUuids(target)
+        assertThat(connects).isZero()
+        assertThat(messages.last()).contains("timed out")
+    }
+
+    @Test fun `teardown cancellation invalidates callback and removes its timeout`() {
+        shadowOf(target).setFetchUuidsWithSdpResult(true)
+        request()
+        discovery.cancel()
+        shadowOf(target).setUuids(arrayOf(sink))
+        discovery.onUuids(target)
+        shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(30))
+        assertThat(connects).isZero()
+        assertThat(messages.none { it.contains("timed out") }).isTrue()
+    }
+
+    @Test fun `previous session timeout cannot cancel rediscovery for the same glasses`() {
+        shadowOf(target).setFetchUuidsWithSdpResult(true)
+        request()
+        shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(20))
+        discovery.cancel()
+        request()
+        shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(10))
+        shadowOf(target).setUuids(arrayOf(sink))
+        discovery.onUuids(target)
+        assertThat(connects).isEqualTo(1)
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/G1TextSanitizerTest.kt

@@ -8,19 +8,19 @@ class G1TextSanitizerTest {
     @Test
     fun `strips Vietnamese diacritics unsupported by G1`() {
         assertThat(sanitizeG1DisplayText("Tiếng Việt: Đặng, Nguyễn, phở bò"))
-            .isEqualTo("Tieng Viet: Dang, Nguyen, pho bo")
+            .isEqualTo("Tieng Viet: Dang, Nguyen, pho bò")
     }
 
     @Test
     fun `handles decomposed marks and preserves layout`() {
         assertThat(sanitizeG1DisplayText("Cafe\u0301\nĐa Nang"))
-            .isEqualTo("Cafe\nDa Nang")
+            .isEqualTo("Café\nDa Nang")
     }
 
     @Test
-    fun `expands Latin letters that do not decompose into combining marks`() {
+    fun `preserves mapped letters and expands only unmapped letters`() {
         assertThat(sanitizeG1DisplayText("Øresund Łódź Æsir Œuvre Straße Ðingvellir Þingvellir"))
-            .isEqualTo("Oresund Lodz AEsir OEuvre Strasse Dingvellir THingvellir")
+            .isEqualTo("Øresund Łódź Æsir OEuvre Straße Ðingvellir Þingvellir")
     }
 
     @Test
@@ -28,4 +28,29 @@ class G1TextSanitizerTest {
         assertThat(sanitizeG1DisplayText("Hello, world! 123"))
             .isEqualTo("Hello, world! 123")
     }
+
+    @Test
+    fun `preserves Swedish accents case punctuation and spacing`() {
+        assertThat(sanitizeG1DisplayText("“Hallå, hallå”\nÅÄÖ åäö"))
+            .isEqualTo("“Hallå, hallå”\nÅÄÖ åäö")
+        assertThat(sanitizeG1DisplayText("Halla\u030A, halla\u030A"))
+            .isEqualTo("Hallå, hallå")
+    }
+
+    @Test
+    fun `preserves other scripts and is idempotent`() {
+        val otherScripts = "が カ\u3099 한\u302E Α\u0301 مُرَحَّبًا शि ❤️"
+        assertThat(sanitizeG1DisplayText(otherScripts)).isEqualTo(otherScripts)
+        val normalized = sanitizeG1DisplayText("Hallå Łódź Đặng Œuvre")
+        assertThat(normalized).isEqualTo("Hallå Łódź Dang OEuvre")
+        assertThat(sanitizeG1DisplayText(normalized)).isEqualTo(normalized)
+    }
+
+    @Test
+    fun `preserves every embedded extended Latin glyph in composed and decomposed forms`() {
+        val glyphs = "ÀÂÇÈÉÊËÎÏÔÙÛÜàçèéêëîïôùûüÿŸÄäÖößẞâÁáÍíÑñúÓóÚⁱIJijŠšŽžÃÅÆÌÐÒÕØÝÞãåæìðòõøýþĄąĆćČčĎďĘęĚěĞğŁłŃńŇňŘřŚśŞşŤťŮůŹźŻżĂăıȘșȚțǖǘǚǜǎǐǒǔŐőŰű"
+        assertThat(sanitizeG1DisplayText(glyphs)).isEqualTo(glyphs)
+        val decomposed = java.text.Normalizer.normalize(glyphs, java.text.Normalizer.Form.NFD)
+        assertThat(sanitizeG1DisplayText(decomposed)).isEqualTo(glyphs)
+    }
 }