@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.3.0-beta.942

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

@@ -0,0 +1,13 @@
+package com.mentra.bluetoothsdk
+
+import com.mentra.bluetoothsdk.utils.G2Text
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class G2TextTest {
+  @Test fun blankRowsAreEncodedOnlyAtTheDeviceBoundary() {
+    assertEquals("hello\n\u200B\nworld\n\u200B", G2Text.containerContent("hello\n\nworld\n"))
+    assertEquals(" ", G2Text.containerContent(""))
+    assertEquals("hello\nworld", G2Text.containerContent("hello\nworld"))
+  }
+}

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/VersionInfoResponseAccumulatorTest.kt

@@ -102,6 +102,77 @@ class VersionInfoResponseAccumulatorTest {
             .isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
     }
 
+    @Test
+    fun factoryAsg27CompletesAfterItsTwoChunks() {
+        // Exact January wire shape after Bridge normalization; firmware can be unknown.
+        for (firmware in listOf("", "17.26.1.13")) {
+            val accumulator = VersionInfoResponseAccumulator("request-1")
+            accumulator.accept(chunk("version_info_1", null, "buildNumber" to "27", "appVersion" to "27.0"))
+            val complete = accumulator.accept(chunk("version_info_2", null,
+                "buildNumber" to "", "otaVersionUrl" to "https://ota.example/live_version.json", "firmwareVersion" to firmware,
+            )) as VersionInfoAccumulatorOutcome.Complete
+            assertThat(complete.result.buildNumber).isEqualTo("27")
+            assertThat(complete.result.otaVersionUrl).isEqualTo("https://ota.example/live_version.json")
+            assertThat(complete.result.firmwareVersion).isEqualTo(firmware)
+        }
+    }
+
+    @Test
+    fun otherLegacyBuildsStillRequireTheirThirdChunk() {
+        for (build in listOf("", "26", "28", "31", "37", "42")) {
+            val accumulator = VersionInfoResponseAccumulator("request-1")
+            accumulator.accept(chunk("version_info_1", null, "buildNumber" to build))
+            assertThat(accumulator.accept(chunk("version_info_2", null,
+                "otaVersionUrl" to "https://ota.example/version.json",
+            ))).isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+            assertThat(accumulator.accept(chunk("version_info_3", null, "besFirmwareVersion" to "new")))
+                .isInstanceOf(VersionInfoAccumulatorOutcome.Complete::class.java)
+        }
+    }
+
+    @Test
+    fun factorySecondChunkCannotCompleteWithoutFirstChunkAndOtaUrl() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        val second = chunk("version_info_2", null, "otaVersionUrl" to "https://ota.example/version.json")
+        assertThat(accumulator.accept(second)).isEqualTo(VersionInfoAccumulatorOutcome.Ignored)
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "27"))
+        for (values in listOf(emptyMap(), mapOf("otaVersionUrl" to ""), mapOf("otaVersionUrl" to " \n"))) {
+            assertThat(accumulator.accept(chunk("version_info_2", null) + values))
+                .isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+        }
+        assertThat(accumulator.accept(second)).isInstanceOf(VersionInfoAccumulatorOutcome.Complete::class.java)
+    }
+
+    @Test
+    fun secondChunkCannotChangeBuildIntoFactoryProtocol() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "31"))
+        assertThat(accumulator.accept(chunk("version_info_2", null,
+            "buildNumber" to "27", "otaVersionUrl" to "https://ota.example/version.json",
+        ))).isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+    }
+
+    @Test
+    fun repeatedFirstChunkClearsFactoryCompletionRule() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "27"))
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "31"))
+        assertThat(accumulator.accept(chunk("version_info_2", null,
+            "otaVersionUrl" to "https://ota.example/version.json",
+        ))).isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+    }
+
+    @Test
+    fun factoryBuildCannotBypassModernCorrelation() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        accumulator.accept(chunk("version_info_1", "request-1", "buildNumber" to "27"))
+        assertThat(accumulator.accept(chunk("version_info_2", null,
+            "otaVersionUrl" to "https://ota.example/version.json",
+        ))).isEqualTo(VersionInfoAccumulatorOutcome.Ignored)
+        assertThat(accumulator.accept(chunk("version_info_3", "request-1", "besFirmwareVersion" to "new")))
+            .isInstanceOf(VersionInfoAccumulatorOutcome.Complete::class.java)
+    }
+
     @Test
     fun modernFinalChunkWaitsForMissingFirstChunk() {
         val accumulator = VersionInfoResponseAccumulator("request-1")

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/services/G2ConnectionRecoveryTest.kt

@@ -0,0 +1,51 @@
+package com.mentra.bluetoothsdk.services
+
+import com.mentra.bluetoothsdk.utils.DeviceTypes
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28])
+class G2ConnectionRecoveryTest {
+    private fun recovery() = G2ConnectionRecovery(RuntimeEnvironment.getApplication())
+    private fun settings() = mapOf<String, Any>(
+        "default_wearable" to DeviceTypes.G2, "device_name" to "S200-test",
+        "brightness" to 75, "auto_brightness" to false,
+        "core_token" to "must-not-persist", "micEnabled" to true,
+        "searching" to true, "pending_device_name" to "unpaired",
+    )
+
+    @Before fun reset() { recovery().clear() }
+
+    @Test fun `a fresh recovery owner restores identity and settings but not runtime or auth state`() {
+        recovery().save(settings())
+        val restored = recovery().read()!!
+        assertEquals("S200-test", restored["device_name"])
+        assertEquals(75, restored["brightness"])
+        assertEquals(false, restored["auto_brightness"])
+        assertFalse(restored.containsKey("core_token"))
+        assertFalse(restored.containsKey("micEnabled"))
+        assertFalse(restored.containsKey("searching"))
+        assertFalse(restored.containsKey("pending_device_name"))
+    }
+
+    @Test fun `explicit disconnect clears recovery across owner recreation`() {
+        recovery().save(settings())
+        recovery().clear()
+        assertNull(recovery().read())
+    }
+
+    @Test fun `forget or switching models cannot resurrect old G2 pairing`() {
+        recovery().save(settings())
+        recovery().save(settings() + ("device_name" to ""))
+        assertNull(recovery().read())
+        recovery().save(settings())
+        recovery().save(settings() + ("default_wearable" to DeviceTypes.G1))
+        assertNull(recovery().read())
+    }
+}

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/G1PairingTest.kt

@@ -0,0 +1,105 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothProfile
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceStore
+import com.mentra.lc3Lib.Lc3Cpp
+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.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
+import org.robolectric.annotation.LooperMode
+import java.util.concurrent.TimeUnit
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class G1PairingTest {
+    @Before
+    fun setup() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        shadowOf(BluetoothAdapter.getDefaultAdapter()).setState(BluetoothAdapter.STATE_ON)
+    }
+
+    @Test
+    fun `fresh pairing connects the selected G1 without a saved identity`() {
+        assertSelectedGlassesConnect("")
+    }
+
+    @Test
+    fun `pairing from simulated glasses connects the selected G1`() {
+        assertSelectedGlassesConnect("Simulated Glasses")
+    }
+
+    @Test
+    fun `switching G1 pairs ignores the previously saved pair`() {
+        assertSelectedGlassesConnect("12")
+    }
+
+    @Test
+    fun `reconnecting the saved G1 still connects both halves`() {
+        assertSelectedGlassesConnect("47")
+    }
+
+    private fun assertSelectedGlassesConnect(savedName: String) {
+        DeviceStore.set("bluetooth", "device_name", savedName)
+        DeviceStore.set("bluetooth", "pending_device_name", "47")
+        val adapter = BluetoothAdapter.getDefaultAdapter()
+        val scanner = shadowOf(adapter.bluetoothLeScanner)
+        val glasses = G1()
+        try {
+            glasses.connectById("47")
+            val callback = scanner.scanCallbacks.single()
+            val unrelated = device("00:00:00:00:12:01", "Even G1_12_L_000001")
+            val left = device("00:00:00:00:47:01", "Even G1_47_L_000001")
+            val right = device("00:00:00:00:47:02", "Even G1_47_R_000002")
+
+            for (device in listOf(unrelated, left, right)) {
+                callback.onScanResult(
+                    ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
+                    ScanResult(device, null, -50, 0),
+                )
+            }
+            shadowOf(Looper.getMainLooper()).idle()
+            assertTrue("The previously saved pair must not receive a GATT connection", shadowOf(unrelated).bluetoothGatts.isEmpty())
+            assertEquals("Connect the selected left half", 1, shadowOf(left).bluetoothGatts.size)
+            shadowOf(left).simulateGattConnectionChange(BluetoothGatt.GATT_SUCCESS, BluetoothProfile.STATE_CONNECTED)
+            shadowOf(Looper.getMainLooper()).idleFor(2, TimeUnit.SECONDS)
+            assertEquals("Connect the selected right half", 1, shadowOf(right).bluetoothGatts.size)
+            assertTrue("Stop scanning once both selected halves are found", scanner.scanCallbacks.isEmpty())
+            assertEquals("Scanning must not promote an unready pairing", savedName, DeviceStore.get("bluetooth", "device_name"))
+        } finally {
+            glasses.disconnect()
+        }
+    }
+
+    private fun device(address: String, name: String): BluetoothDevice =
+        BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address).also {
+            shadowOf(it).setName(name)
+            shadowOf(it).setAlias(name)
+            shadowOf(it).setBondState(BluetoothDevice.BOND_BONDED)
+        }
+
+    // Pairing tests exercise the real G1 driver; only its unrelated native audio codec is stubbed.
+    @Implements(Lc3Cpp::class)
+    class ShadowLc3Cpp {
+        companion object {
+            @JvmStatic @Implementation fun __staticInitializer__() {}
+            @JvmStatic @Implementation fun initDecoder(): Long = 1L
+            @JvmStatic @Implementation fun freeDecoder(decoderPtr: Long) {}
+        }
+    }
+}

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)
+    }
 }