@mentra/acs-meeting 3.2.0-dev.221 → 3.2.0-dev.223

package/android/src/test/java/com/mentra/acsmeeting/network/InternetHoldTest.kt

@@ -0,0 +1,148 @@
+package com.mentra.acsmeeting.network
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Covers the parts of [InternetHold] that decide something, which is the verdict on a default
+ * network and the name that verdict is reported under. The framework plumbing around them
+ * (`requestNetwork`, `activeNetwork`) is not reachable from a plain JVM test and is not what went
+ * wrong on device: the failure was proceeding on an unvalidated route, and that judgement lives
+ * here.
+ */
+class InternetHoldTest {
+
+    @Test
+    fun `a present validated network is the only usable one`() {
+        assertTrue(InternetHold.DefaultNetwork("cellular", validated = true, present = true).usable)
+    }
+
+    @Test
+    fun `a network that is up but not validated is not usable`() {
+        // The device failure exactly: cellular present, carrying no TLS, and ACS joining over it.
+        val cellular = InternetHold.DefaultNetwork("cellular", validated = false, present = true)
+        assertFalse(cellular.usable)
+        assertEquals("cellular (unvalidated)", cellular.toString())
+    }
+
+    @Test
+    fun `no default network at all is reported as none rather than as an unvalidated one`() {
+        // Distinct causes need distinct copy: "no network" is airplane mode, "unvalidated" is a
+        // radio that is up and not working yet.
+        val absent = InternetHold.DefaultNetwork("none", validated = false, present = false)
+        assertFalse(absent.usable)
+        assertEquals("none", absent.toString())
+    }
+
+    @Test
+    fun `a validated network cannot be usable while absent`() {
+        // Guards against reading a stale capability snapshot as a live route.
+        assertFalse(InternetHold.DefaultNetwork("cellular", validated = true, present = false).usable)
+    }
+
+    @Test
+    fun `a validated leftover glasses hotspot is not usable internet`() {
+        // The 17:52:24 failure: Android marked MentraLive_* VALIDATED, teardown dropped the
+        // cellular pin, and the next teams:create left through SoftAP. Cloudflare answered 503.
+        val leftover =
+            InternetHold.DefaultNetwork("wifi", validated = true, present = true, glassesHotspot = true)
+        assertFalse(leftover.usable)
+        assertEquals("wifi (validated, leftover-hotspot)", leftover.toString())
+    }
+
+    @Test
+    fun `a validated cellular network renders with its transport and state`() {
+        assertEquals(
+            "cellular (validated)",
+            InternetHold.DefaultNetwork("cellular", validated = true, present = true).toString(),
+        )
+    }
+
+    @Test
+    fun `Mentra Live SoftAP SSIDs are leftover glasses hotspots`() {
+        assertTrue(InternetHold.isGlassesHotspotSsid("MentraLive_15f63c"))
+        assertTrue(InternetHold.isGlassesHotspotSsid("\"MentraLive_15f63c\""))
+        assertTrue(InternetHold.isGlassesHotspotSsid("mentralive_aabbcc"))
+        assertFalse(InternetHold.isGlassesHotspotSsid("<unknown ssid>"))
+        assertFalse(InternetHold.isGlassesHotspotSsid("Office-WiFi"))
+    }
+
+    @Test
+    fun `Android SoftAP IPv4 is the leftover glasses LAN`() {
+        assertTrue(InternetHold.isAndroidSoftApIpv4(byteArrayOf(192.toByte(), 168.toByte(), 43, 154.toByte())))
+        assertFalse(InternetHold.isAndroidSoftApIpv4(byteArrayOf(192.toByte(), 168.toByte(), 1, 10)))
+        assertFalse(InternetHold.isAndroidSoftApIpv4(byteArrayOf(10, 0, 0, 1)))
+    }
+
+    @Test
+    fun `a vpn is named ahead of the transport it runs over`() {
+        // A tunnel owning the app's UID is what decides whether ACS reaches the internet, and it
+        // stacks on cellular rather than replacing it. Naming the carrier would hide the cause of
+        // the EPERM failures we chased.
+        assertEquals(
+            "vpn",
+            InternetHold.transportNameOf(cellular = true, wifi = false, vpn = true, ethernet = false),
+        )
+        assertEquals(
+            "vpn",
+            InternetHold.transportNameOf(cellular = false, wifi = true, vpn = true, ethernet = false),
+        )
+    }
+
+    @Test
+    fun `each transport has a name and an unknown mix does not crash the trace`() {
+        assertEquals(
+            "cellular",
+            InternetHold.transportNameOf(cellular = true, wifi = false, vpn = false, ethernet = false),
+        )
+        assertEquals(
+            "wifi",
+            InternetHold.transportNameOf(cellular = false, wifi = true, vpn = false, ethernet = false),
+        )
+        assertEquals(
+            "ethernet",
+            InternetHold.transportNameOf(cellular = false, wifi = false, vpn = false, ethernet = true),
+        )
+        assertEquals(
+            "other",
+            InternetHold.transportNameOf(cellular = false, wifi = false, vpn = false, ethernet = false),
+        )
+    }
+
+    @Test
+    fun `cellular is named over wifi when both are present`() {
+        // Only reached when the app's default has both transports; cellular is the one this class
+        // holds up, so it is the one worth naming.
+        assertEquals(
+            "cellular",
+            InternetHold.transportNameOf(cellular = true, wifi = true, vpn = false, ethernet = false),
+        )
+    }
+
+    @Test
+    fun `a hold that could not be taken reports neither held nor validated`() {
+        val none = InternetHold.CellularHold(held = false, validated = false, waitedMs = 0)
+        assertFalse(none.held)
+        assertFalse(none.validated)
+    }
+
+    @Test
+    fun `a held request that never validated is still recorded as held`() {
+        // The request is deliberately kept after a validation timeout, so that a caller which
+        // continues anyway does not also lose the radio. Losing this distinction would make the
+        // release path look unnecessary.
+        val held = InternetHold.CellularHold(held = true, validated = false, waitedMs = 15_000)
+        assertTrue(held.held)
+        assertFalse(held.validated)
+        assertEquals(15_000, held.waitedMs)
+    }
+
+    @Test
+    fun `the cellular wait is longer than the default-route wait`() {
+        // Bringing a radio up from cold is slow; a default route swapping to a network already up
+        // is not. Equal budgets would either abort good calls or stall every one of them.
+        assertTrue(InternetHold.CELLULAR_WAIT_MS > InternetHold.DEFAULT_WAIT_MS)
+    }
+}

package/android/src/test/java/com/mentra/acsmeeting/network/Ipv4PrefixTest.kt

@@ -0,0 +1,59 @@
+package com.mentra.acsmeeting.network
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class Ipv4PrefixTest {
+
+    @Test
+    fun `contains the phone and the gateway on a 24`() {
+        val prefix = Ipv4Prefix("192.168.43.20", 24)
+        assertTrue(prefix.contains("192.168.43.1"))
+        assertTrue(prefix.contains("192.168.43.20"))
+        assertTrue(prefix.contains("192.168.43.255"))
+    }
+
+    /** The whole point: a cellular 10/8 address is RFC1918 and still the wrong interface. */
+    @Test
+    fun `rejects a private address on another interface`() {
+        val prefix = Ipv4Prefix("192.168.43.20", 24)
+        assertFalse(prefix.contains("10.171.36.4"))
+        assertFalse(prefix.contains("192.168.1.20"))
+        assertFalse(prefix.contains("172.16.0.1"))
+    }
+
+    /** An OEM hotspot on another subnet must still pass, which is why /24 is never assumed. */
+    @Test
+    fun `honours the reported prefix length`() {
+        assertTrue(Ipv4Prefix("192.168.49.1", 16).contains("192.168.43.7"))
+        assertFalse(Ipv4Prefix("192.168.49.1", 24).contains("192.168.43.7"))
+        assertTrue(Ipv4Prefix("10.5.4.3", 8).contains("10.99.99.99"))
+    }
+
+    @Test
+    fun `non-addresses are not addresses`() {
+        val prefix = Ipv4Prefix("192.168.43.20", 24)
+        assertFalse(prefix.contains(null))
+        assertFalse(prefix.contains("typ"))
+        assertFalse(prefix.contains("192.168.43"))
+        assertFalse(prefix.contains("192.168.43.256"))
+        assertFalse(prefix.contains("192.168.43.20.1"))
+        assertFalse(prefix.contains("a4f1c2d3.local"))
+    }
+
+    @Test
+    fun `packs and prints`() {
+        assertEquals(0x0A000001, Ipv4Prefix.packIpv4("10.0.0.1"))
+        assertNull(Ipv4Prefix.packIpv4("not.an.ip.addr"))
+        assertEquals("192.168.43.20/24", Ipv4Prefix("192.168.43.20", 24).toString())
+    }
+
+    /** An unparseable own-address must match nothing rather than everything. */
+    @Test
+    fun `a malformed prefix contains nothing`() {
+        assertFalse(Ipv4Prefix("garbage", 24).contains("192.168.43.1"))
+    }
+}

package/android/src/test/java/com/mentra/acsmeeting/network/NetworkFactsTest.kt

@@ -0,0 +1,59 @@
+package com.mentra.acsmeeting.network
+
+import com.mentra.acsmeeting.network.NetworkFacts.Iface
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+/**
+ * The attribution helpers decide what the next SoftAP diagnosis says, so they are pinned rather
+ * than eyeballed in a log line.
+ */
+class NetworkFactsTest {
+
+    private fun iface(
+        name: String,
+        ipv4: List<String>,
+        up: Boolean = true,
+        loopback: Boolean = false,
+    ) = Iface(name, 1, up, loopback, false, false, 1500, ipv4)
+
+    private val table =
+        listOf(
+            iface("lo", listOf("127.0.0.1/8"), loopback = true),
+            iface("wlan0", listOf("192.168.43.79/24")),
+            iface("rmnet_data0", listOf("10.48.51.202/30")),
+            iface("dummy0", emptyList()),
+            iface("epdg0", listOf("10.9.9.9/32"), up = false),
+        )
+
+    @Test
+    fun `the owner of an address is the interface the table says carries it`() {
+        assertThat(NetworkFacts.ownerOf("192.168.43.79", table)).isEqualTo("wlan0")
+        assertThat(NetworkFacts.ownerOf("10.48.51.202", table)).isEqualTo("rmnet_data0")
+    }
+
+    /** An address ICE gathered that is absent here means our two views of the network disagree. */
+    @Test
+    fun `an address the table has never seen has no owner`() {
+        assertThat(NetworkFacts.ownerOf("192.168.50.7", table)).isNull()
+    }
+
+    @Test
+    fun `a prefix is not mistaken for the address`() {
+        assertThat(NetworkFacts.ownerOf("192.168.43.79/24", table)).isNull()
+    }
+
+    @Test
+    fun `gatherable drops loopback, down, and addressless interfaces`() {
+        assertThat(NetworkFacts.gatherable(table).map { it.name })
+            .containsExactly("wlan0", "rmnet_data0")
+    }
+
+    @Test
+    fun `render keeps the name, flags and every address`() {
+        val line = NetworkFacts.render(listOf(iface("wlan0", listOf("192.168.43.79/24", "10.1.2.3/24"))))
+
+        assertThat(line).contains("wlan0#1")
+        assertThat(line).contains("192.168.43.79/24,10.1.2.3/24")
+    }
+}

package/android/src/test/java/com/mentra/acsmeeting/network/ScopedLocalNetworkPermissionTest.kt

@@ -0,0 +1,35 @@
+package com.mentra.acsmeeting.network
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class ScopedLocalNetworkPermissionTest {
+    @Test
+    fun `Android 17 preserves implicit access for the SDK 36 host`() {
+        assertThat(ScopedSoftApNetwork.hasLocalNetworkPermission(37, 36) {
+            error("Legacy targets must not query the unneeded runtime grant")
+        }).isTrue()
+    }
+
+    @Test
+    fun `older Android does not query a permission it cannot enforce`() {
+        assertThat(ScopedSoftApNetwork.hasLocalNetworkPermission(36, 37) {
+            error("Older Android must not query the new permission")
+        }).isTrue()
+    }
+
+    @Test
+    fun `Android 17 denies a target 37 host without the grant`() {
+        assertThat(ScopedSoftApNetwork.hasLocalNetworkPermission(37, 37) { false }).isFalse()
+    }
+
+    @Test
+    fun `Android 17 allows a target 37 host with the grant`() {
+        assertThat(ScopedSoftApNetwork.hasLocalNetworkPermission(37, 37) { true }).isTrue()
+    }
+
+    @Test
+    fun `future Android and target versions still enforce the grant`() {
+        assertThat(ScopedSoftApNetwork.hasLocalNetworkPermission(38, 38) { false }).isFalse()
+    }
+}

package/android/src/test/java/com/mentra/acsmeeting/network/ScopedNetworkChangeDetectorTest.kt

@@ -0,0 +1,165 @@
+package com.mentra.acsmeeting.network
+
+import com.mentra.acsmeeting.network.ScopedNetworkChangeDetector.Companion.formatIpv4
+import com.mentra.acsmeeting.network.ScopedNetworkChangeDetector.Companion.mergeScopedNetwork
+import com.mentra.acsmeeting.network.ScopedNetworkChangeDetector.Companion.renderInventory
+import com.mentra.acsmeeting.network.ScopedNetworkChangeDetector.Companion.toNetworkInformation
+import com.mentra.acsmeeting.network.ScopedNetworkChangeDetector.ScopedInterface
+import com.mentra.acsmeeting.source.SoftApIcePolicy
+import org.webrtc.PeerConnectionFactory
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import org.webrtc.NetworkChangeDetector
+
+/**
+ * The merge is the part that decides whether ICE can see the hotspot at all, so it is tested
+ * directly rather than only through the on-device gate.
+ */
+class ScopedNetworkChangeDetectorTest {
+
+    private fun ipv4(a: Int, b: Int, c: Int, d: Int) =
+        byteArrayOf(a.toByte(), b.toByte(), c.toByte(), d.toByte())
+
+    private fun softAp(name: String = "wlan1", handle: Long = 42L) =
+        ScopedInterface(name, handle, listOf(ipv4(192, 168, 43, 20)))
+
+    private fun detected(name: String) =
+        NetworkChangeDetector.NetworkInformation(
+            name,
+            NetworkChangeDetector.ConnectionType.CONNECTION_4G,
+            NetworkChangeDetector.ConnectionType.CONNECTION_NONE,
+            7L,
+            arrayOf(NetworkChangeDetector.IPAddress(ipv4(10, 8, 0, 2))),
+        )
+
+    @Test
+    fun `the scoped SoftAP is the only Wi-Fi in the inventory`() {
+        val merged = mergeScopedNetwork(listOf(detected("rmnet0")), softAp())
+
+        assertThat(merged.map { it.name }).containsExactly("wlan1")
+        assertThat(merged.single().ipAddresses[0].address).isEqualTo(ipv4(192, 168, 43, 20))
+    }
+
+    /**
+     * The collision that produced `count=0` candidates on device when two entries shared handle 0.
+     * One entry with the real handle cannot collide with itself.
+     */
+    @Test
+    fun `the inventory is a single entry, so no two entries can share a handle`() {
+        val merged = mergeScopedNetwork(listOf(detected("rmnet_data0"), detected("wlan0")), softAp())
+
+        assertThat(merged).hasSize(1)
+        assertThat(merged.map { it.handle }.distinct()).hasSize(1)
+    }
+
+    /** The mask has to leave the hotspot gatherable, and nothing else is offered to it. */
+    @Test
+    fun `the published hotspot survives the ignore mask`() {
+        val merged = mergeScopedNetwork(emptyList(), softAp())
+        val mask = SoftApIcePolicy.networkIgnoreMask()
+
+        val gatherable = merged.filter { SoftApIcePolicy.allowsAdapter(mask, adapterTypeOf(it.type)) }
+
+        assertThat(gatherable.map { it.name }).containsExactly("wlan1")
+    }
+
+    /** Mirrors libwebrtc's `AdapterTypeFromNetworkType` for the two types this merge produces. */
+    private fun adapterTypeOf(type: NetworkChangeDetector.ConnectionType): Int =
+        when (type) {
+            NetworkChangeDetector.ConnectionType.CONNECTION_WIFI ->
+                PeerConnectionFactory.Options.ADAPTER_TYPE_WIFI
+            NetworkChangeDetector.ConnectionType.CONNECTION_4G ->
+                PeerConnectionFactory.Options.ADAPTER_TYPE_CELLULAR
+            else -> PeerConnectionFactory.Options.ADAPTER_TYPE_UNKNOWN
+        }
+
+    /** Without this, ICE never gathers a candidate on the hotspot subnet. */
+    @Test
+    fun `the scoped interface appears even when the delegate reports nothing`() {
+        val merged = mergeScopedNetwork(emptyList(), softAp())
+
+        assertThat(merged.map { it.name }).containsExactly("wlan1")
+    }
+
+    @Test
+    fun `a null delegate list is tolerated`() {
+        assertThat(mergeScopedNetwork(null, softAp())).hasSize(1)
+    }
+
+    @Test
+    fun `no scoped network leaves the inventory untouched`() {
+        val detectedList = listOf(detected("rmnet0"))
+
+        assertThat(mergeScopedNetwork(detectedList, null).map { it.name }).containsExactly("rmnet0")
+    }
+
+    @Test
+    fun `a same-named stock wlan0 is replaced by the scoped SoftAP address`() {
+        // This phone: stock detector reports wlan0 at 10.15.68.161 (internet Wi-Fi). SoftAP is a
+        // different Network that reuses the name wlan0 at 192.168.43.79. Matching on name and
+        // keeping the stock entry is how ICE answered with the 10.x host candidate.
+        val stockWifi = detected("wlan0")
+        val scoped = softAp(name = "wlan0", handle = 99L)
+
+        val merged = mergeScopedNetwork(listOf(stockWifi), scoped)
+
+        assertThat(merged).hasSize(1)
+        assertThat(merged.single().ipAddresses[0].address).isEqualTo(ipv4(192, 168, 43, 20))
+    }
+
+    /**
+     * Handle 0 advertised the right address and then never completed an ICE check (18:56 / 19:01).
+     * The real handle is what marks the socket onto the SoftAP; the SDP pin puts the scoped IP
+     * back in the answer the glasses see.
+     */
+    @Test
+    fun `the hotspot is published with its real network handle`() {
+        val information = toNetworkInformation(softAp(handle = 99L))
+
+        assertThat(information).isNotNull
+        assertThat(information!!.handle).isEqualTo(99L)
+        assertThat(information.type).isEqualTo(NetworkChangeDetector.ConnectionType.CONNECTION_WIFI)
+    }
+
+    @Test
+    fun `the published network carries the hotspot address`() {
+        val information = toNetworkInformation(softAp())!!
+
+        assertThat(information.ipAddresses).hasSize(1)
+        assertThat(information.ipAddresses[0].address).isEqualTo(ipv4(192, 168, 43, 20))
+    }
+
+    @Test
+    fun `an interface with no address is not published`() {
+        val addressless = ScopedInterface("wlan1", 42L, emptyList())
+
+        assertThat(toNetworkInformation(addressless)).isNull()
+        assertThat(mergeScopedNetwork(emptyList(), addressless)).isEmpty()
+    }
+
+    @Test
+    fun `formatIpv4 renders a dotted-quad`() {
+        assertThat(formatIpv4(ipv4(10, 15, 68, 161))).isEqualTo("10.15.68.161")
+    }
+
+    @Test
+    fun `multiple addresses are all published`() {
+        val multi =
+            ScopedInterface("wlan1", 42L, listOf(ipv4(192, 168, 43, 20), ipv4(192, 168, 43, 21)))
+
+        assertThat(toNetworkInformation(multi)!!.ipAddresses).hasSize(2)
+    }
+
+    /** The rejection diagnostics read this, so a handle collision has to be visible in it. */
+    @Test
+    fun `renderInventory names every entry with its type, handle and addresses`() {
+        val rendered = renderInventory(mergeScopedNetwork(emptyList(), softAp()))
+
+        assertThat(rendered).isEqualTo("wlan1[CONNECTION_WIFI]#42(192.168.43.20)")
+    }
+
+    @Test
+    fun `renderInventory tolerates a null list`() {
+        assertThat(renderInventory(null)).isEmpty()
+    }
+}

package/android/src/test/java/com/mentra/acsmeeting/network/ScopedNetworkErrorTest.kt

@@ -0,0 +1,96 @@
+package com.mentra.acsmeeting.network
+
+import com.mentra.acsmeeting.network.ScopedNetworkState.Failure
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class ScopedNetworkErrorTest {
+
+    @Test
+    fun `no failure maps to no error`() {
+        assertThat(ScopedNetworkError.from(Failure.NONE, "ssid", 30_000)).isNull()
+    }
+
+    @Test
+    fun `each failure maps to its typed error and stable code`() {
+        assertThat(ScopedNetworkError.from(Failure.TIMEOUT, "ap", 30_000))
+            .isInstanceOf(ScopedNetworkError.Timeout::class.java)
+            .extracting("code")
+            .isEqualTo(ScopedNetworkError.CODE_TIMEOUT)
+
+        assertThat(ScopedNetworkError.from(Failure.UNAVAILABLE, "ap", 30_000))
+            .isInstanceOf(ScopedNetworkError.Unavailable::class.java)
+
+        assertThat(ScopedNetworkError.from(Failure.LOST, "ap", 30_000))
+            .isInstanceOf(ScopedNetworkError.Lost::class.java)
+
+        assertThat(ScopedNetworkError.from(Failure.REQUEST_FAILED, "ap", 30_000))
+            .isInstanceOf(ScopedNetworkError.RequestFailed::class.java)
+    }
+
+    /**
+     * A denied permission must be its own error, not a timeout: otherwise it looks like a flaky
+     * hotspot and costs 30 seconds before failing.
+     */
+    @Test
+    fun `permission denial is distinct from a timeout`() {
+        val denied = ScopedNetworkError.from(Failure.PERMISSION_DENIED, "ap", 30_000)
+
+        assertThat(denied).isInstanceOf(ScopedNetworkError.PermissionDenied::class.java)
+        assertThat(denied?.code).isEqualTo(ScopedNetworkError.CODE_PERMISSION_DENIED)
+        assertThat(denied?.code).isNotEqualTo(ScopedNetworkError.CODE_TIMEOUT)
+    }
+
+    @Test
+    fun `error codes are stable and unique`() {
+        val codes =
+            listOf(
+                ScopedNetworkError.CODE_PERMISSION_DENIED,
+                ScopedNetworkError.CODE_TIMEOUT,
+                ScopedNetworkError.CODE_UNAVAILABLE,
+                ScopedNetworkError.CODE_LOST,
+                ScopedNetworkError.CODE_REQUEST_FAILED,
+                ScopedNetworkError.CODE_NO_LOCAL_ADDRESS,
+                ScopedNetworkError.CODE_NOT_READY,
+                ScopedNetworkError.CODE_WIFI_DISABLED,
+                ScopedNetworkError.CODE_VPN_ACTIVE,
+            )
+
+        assertThat(codes).doesNotHaveDuplicates()
+        assertThat(codes).allMatch { it.startsWith("SOFTAP_") }
+    }
+
+    @Test
+    fun `messages name the ssid so a log line is actionable`() {
+        assertThat(ScopedNetworkError.Timeout("MentraLive-1234", 30_000).message)
+            .contains("MentraLive-1234")
+            .contains("30000")
+        assertThat(ScopedNetworkError.Lost("MentraLive-1234").message).contains("MentraLive-1234")
+    }
+
+    @Test
+    fun `a capturing vpn is named as the cause and tells the user what to change`() {
+        val error = ScopedNetworkError.VpnCapturesApp()
+        assertThat(error.code).isEqualTo(ScopedNetworkError.CODE_VPN_ACTIVE)
+        assertThat(error.message).contains("VPN").contains("split tunneling")
+    }
+
+    /**
+     * "Joined but not usable" has to be its own code. Reported as a join success it becomes an ICE
+     * answer with no candidates, which is the symptom several unrelated faults share.
+     */
+    @Test
+    fun `a network that joined but never became usable names the missing source`() {
+        val error = ScopedNetworkError.NotReady("MentraLive-1234", "the kernel interface table")
+
+        assertThat(error.code).isEqualTo(ScopedNetworkError.CODE_NOT_READY)
+        assertThat(error.code).isNotEqualTo(ScopedNetworkError.CODE_NO_LOCAL_ADDRESS)
+        assertThat(error.message).contains("MentraLive-1234").contains("the kernel interface table")
+    }
+
+    @Test
+    fun `the local network permission name is the platform constant`() {
+        assertThat(ScopedNetworkError.LOCAL_NETWORK_PERMISSION)
+            .isEqualTo("android.permission.ACCESS_LOCAL_NETWORK")
+    }
+}