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

package/android/src/test/java/com/mentra/acsmeeting/source/GlassesMediaSourceTest.kt

@@ -48,7 +48,7 @@ class GlassesMediaSourceContractTest {
   private fun contract(source: FakeGlassesMediaSource) {
     val pcm = mutableListOf<ByteArray>()
     source.pcmListener = PcmListener { bytes, _, _ -> pcm.add(bytes) }
-    val controller = GlassesMediaController { _, listener ->
+    val controller = GlassesMediaController { _, listener, _ ->
       source.pcmListener = listener
       source
     }
@@ -92,15 +92,33 @@ class GlassesMediaSourceContractTest {
     val config = SourceConfig(url)
     // A resumed glasses uplink re-sends the same URL. ACS never lost its
     // subscription, so rebuilding would only restart the wait for a first frame.
-    assertThat(canReuseSource(url, SourceState.LIVE, config)).isTrue()
+    assertThat(SourceReusePolicy.canReuse(url, SourceState.LIVE, config)).isTrue()
     // Includes the answer → first frame window, which LIVE no longer covers.
-    assertThat(canReuseSource(url, SourceState.CONNECTING, config)).isTrue()
+    assertThat(SourceReusePolicy.canReuse(url, SourceState.CONNECTING, config)).isTrue()
     // ICE dropped, or the answer never produced a frame: rebuild.
-    assertThat(canReuseSource(url, SourceState.FAILED, config)).isFalse()
+    assertThat(SourceReusePolicy.canReuse(url, SourceState.FAILED, config)).isFalse()
     // A new stream means a new WHEP URL, and a stopped source has none.
-    assertThat(canReuseSource(url, SourceState.LIVE, SourceConfig("https://example.com/whep-2"))).isFalse()
-    assertThat(canReuseSource(null, SourceState.IDLE, config)).isFalse()
-    assertThat(canReuseSource(url, SourceState.LIVE, SourceConfig(url, SourceKind.DIRECT))).isFalse()
+    assertThat(SourceReusePolicy.canReuse(url, SourceState.LIVE, SourceConfig("https://example.com/whep-2"))).isFalse()
+    assertThat(SourceReusePolicy.canReuse(null, SourceState.IDLE, config)).isFalse()
+    assertThat(SourceReusePolicy.canReuse(url, SourceState.LIVE, SourceConfig(url, SourceKind.DIRECT))).isFalse()
+  }
+
+  @Test
+  fun softApIsNeverReusedBecauseTheListenerBelongsToOneAttempt() {
+    // A SoftAP attempt owns a listener, a port and a peer. There is no URL to keep across a
+    // rebuild — the URL is an output of binding, not an input — so reuse must always be refused,
+    // even when the config and state would otherwise look reusable.
+    val config = SourceConfig("", SourceKind.SOFTAP, bindAddress = "192.168.43.20")
+
+    assertThat(SourceReusePolicy.canReuse("", SourceState.LIVE, config)).isFalse()
+    assertThat(SourceReusePolicy.canReuse("", SourceState.CONNECTING, config)).isFalse()
+  }
+
+  @Test
+  fun onlySoftApReportsAnIngestUrl() {
+    // Every other kind is told its URL, so exposing one would be a contract error waiting to be
+    // read by the orchestrator that hands the URL to the glasses.
+    assertThat(FakeGlassesMediaSource().ingestUrl).isNull()
   }
 
   @Test
@@ -110,7 +128,7 @@ class GlassesMediaSourceContractTest {
       stats = com.mentra.acsmeeting.telemetry.PipelineStats(),
       isReady = { false },
     )
-    val controller = GlassesMediaController { _, _ -> source }
+    val controller = GlassesMediaController { _, _, _ -> source }
 
     assertThat(controller.state).isEqualTo(SourceState.IDLE)
     controller.attach(

package/android/src/test/java/com/mentra/acsmeeting/source/MeetingVideoSourceSpecTest.kt

@@ -0,0 +1,109 @@
+package com.mentra.acsmeeting.source
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.Test
+
+/**
+ * The bridge boundary between the host's `videoSource` union and the native source classes.
+ *
+ * Worth pinning because this is the last place a malformed source can be rejected with a message
+ * that names the field. Past here it becomes a call that joins and shows nothing.
+ */
+class MeetingVideoSourceSpecTest {
+
+  @Test
+  fun `a whep source parses to a whep config`() {
+    val spec = MeetingVideoSourceSpec.parse(
+      mapOf("type" to "whep", "url" to " https://example.com/whep "),
+      null,
+    )
+
+    assertThat(spec).isEqualTo(MeetingVideoSourceSpec.Whep("https://example.com/whep"))
+    assertThat(spec.toConfig()).isEqualTo(
+      SourceConfig("https://example.com/whep", SourceKind.WHEP),
+    )
+  }
+
+  @Test
+  fun `a softap source parses to a softap config carrying the bind address`() {
+    val spec = MeetingVideoSourceSpec.parse(
+      mapOf("type" to "softap", "bindAddress" to "192.168.43.20"),
+      null,
+    )
+
+    assertThat(spec).isEqualTo(MeetingVideoSourceSpec.SoftAp("192.168.43.20"))
+    assertThat(spec.toConfig())
+      .isEqualTo(SourceConfig("", SourceKind.SOFTAP, "192.168.43.20"))
+  }
+
+  /**
+   * The orchestrator may not know the address yet when it builds the request; the source falls
+   * back to asking the joined network. A blank string must not become a bind target.
+   */
+  @Test
+  fun `a softap source without a usable bind address carries null`() {
+    assertThat(MeetingVideoSourceSpec.parse(mapOf("type" to "softap"), null))
+      .isEqualTo(MeetingVideoSourceSpec.SoftAp(null))
+    assertThat(MeetingVideoSourceSpec.parse(mapOf("type" to "softap", "bindAddress" to " "), null))
+      .isEqualTo(MeetingVideoSourceSpec.SoftAp(null))
+  }
+
+  @Test
+  fun `the type is matched case insensitively`() {
+    assertThat(MeetingVideoSourceSpec.parse(mapOf("type" to "SoftAP"), null).kind)
+      .isEqualTo(SourceKind.SOFTAP)
+  }
+
+  // -----------------------------------------------------------------
+  // Back-compatibility with a host that predates the union
+  // -----------------------------------------------------------------
+
+  @Test
+  fun `a bare whepUrl with no videoSource still parses`() {
+    assertThat(MeetingVideoSourceSpec.parse(null, "https://example.com/whep"))
+      .isEqualTo(MeetingVideoSourceSpec.Whep("https://example.com/whep"))
+  }
+
+  @Test
+  fun `a whep source with no url falls back to the legacy field`() {
+    assertThat(MeetingVideoSourceSpec.parse(mapOf("type" to "whep"), "https://legacy/whep"))
+      .isEqualTo(MeetingVideoSourceSpec.Whep("https://legacy/whep"))
+  }
+
+  // -----------------------------------------------------------------
+  // Rejections
+  // -----------------------------------------------------------------
+
+  @Test
+  fun `an unknown type is rejected rather than defaulting to whep`() {
+    assertThatThrownBy { MeetingVideoSourceSpec.parse(mapOf("type" to "quic"), null) }
+      .isInstanceOf(IllegalArgumentException::class.java)
+      .hasMessageContaining("quic")
+  }
+
+  @Test
+  fun `a whep source with no url anywhere is rejected`() {
+    assertThatThrownBy { MeetingVideoSourceSpec.parse(mapOf("type" to "whep"), " ") }
+      .isInstanceOf(IllegalArgumentException::class.java)
+      .hasMessageContaining("url")
+  }
+
+  @Test
+  fun `no source and no legacy url is rejected`() {
+    assertThatThrownBy { MeetingVideoSourceSpec.parse(null, null) }
+      .isInstanceOf(IllegalArgumentException::class.java)
+  }
+
+  @Test
+  fun `a missing type is rejected`() {
+    assertThatThrownBy { MeetingVideoSourceSpec.parse(mapOf("url" to "https://x/whep"), null) }
+      .isInstanceOf(IllegalArgumentException::class.java)
+  }
+
+  @Test
+  fun `the synthetic arm maps to the direct kind`() {
+    assertThat(MeetingVideoSourceSpec.Synthetic.toConfig())
+      .isEqualTo(SourceConfig("", SourceKind.DIRECT))
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/source/SelectedIcePairTest.kt

@@ -0,0 +1,165 @@
+package com.mentra.acsmeeting.source
+
+import com.mentra.acsmeeting.network.Ipv4Prefix
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * This verifier is acceptance evidence for the SoftAP path, so its failure mode matters as much as
+ * its success one. The cases below pin that it follows the transport's selection instead of
+ * guessing, and that it reports insufficient evidence rather than passing on a plausible-looking
+ * pair — the previous behaviour, which could grade a run on a pair that was not carrying the call.
+ */
+class SelectedIcePairTest {
+
+    private val prefix = Ipv4Prefix("192.168.43.20", 24)
+
+    private fun pair(
+        id: String,
+        state: String? = "succeeded",
+        nominated: Boolean = false,
+        local: String? = "local-1",
+        remote: String? = "remote-1",
+        bytes: Long = 0,
+    ) = IceCandidatePairStats(id, state, nominated, local, remote, bytes)
+
+    private fun transport(selected: String? = "a", id: String = "T1") = IceTransportStats(id, selected)
+
+    private fun candidates(vararg entries: Pair<String, String>): Map<String, IceCandidateStats> =
+        entries.associate { (id, address) -> id to IceCandidateStats(id, address, "host") }
+
+    private fun verdict(
+        transports: List<IceTransportStats> = listOf(transport()),
+        pairs: List<IceCandidatePairStats> = listOf(pair("a", bytes = 9000)),
+        candidateMap: Map<String, IceCandidateStats> =
+            candidates("local-1" to "192.168.43.20", "remote-1" to "192.168.43.1"),
+        scopedPrefix: Ipv4Prefix? = prefix,
+        iceGeneration: Int = 3,
+    ) = SelectedIcePair.verdict(transports, pairs, candidateMap, scopedPrefix, iceGeneration)
+
+    @Test
+    fun `follows the pair the transport says is selected`() {
+        val chosen =
+            SelectedIcePair.selected(
+                listOf(transport(selected = "b")),
+                listOf(pair("a", nominated = true, bytes = 999_999), pair("b")),
+            )
+
+        assertEquals("b", chosen.getOrNull()?.id)
+    }
+
+    /**
+     * The behaviour that had to go. A succeeded pair is one that once passed a check, and historical
+     * bytes can belong to a pair that has since been replaced; neither is the current path.
+     */
+    @Test
+    fun `no fallback to a succeeded or high-traffic pair when nothing is selected`() {
+        val chosen =
+            SelectedIcePair.selected(
+                listOf(transport(selected = null)),
+                listOf(pair("a", nominated = true, bytes = 999_999)),
+            )
+
+        assertTrue(chosen.isFailure)
+        assertEquals("no_selected_pair", (chosen.exceptionOrNull() as SelectedIcePair.Missing).reason)
+    }
+
+    @Test
+    fun `a local candidate inside the prefix is on the hotspot`() {
+        assertEquals(
+            IcePathVerdict.OnHotspot("a", 3, "192.168.43.20", "192.168.43.1", 9000),
+            verdict(),
+        )
+    }
+
+    /** The silent failure this exists for: SDP looked private, ICE picked cellular. */
+    @Test
+    fun `a cellular local candidate is off the hotspot`() {
+        val result =
+            verdict(
+                candidateMap = candidates("local-1" to "10.171.36.4", "remote-1" to "192.168.43.1"),
+            )
+
+        assertEquals(IcePathVerdict.OffHotspot("a", "10.171.36.4", "192.168.43.20/24"), result)
+    }
+
+    @Test
+    fun `every gap in the evidence is its own unknown reason`() {
+        assertEquals(
+            IcePathVerdict.Unknown("no_transport_stats"),
+            verdict(transports = emptyList()),
+        )
+        assertEquals(
+            IcePathVerdict.Unknown("no_selected_pair"),
+            verdict(transports = listOf(transport(selected = null))),
+        )
+        assertEquals(
+            IcePathVerdict.Unknown("selected_pair_absent_from_report"),
+            verdict(pairs = listOf(pair("z"))),
+        )
+        assertEquals(IcePathVerdict.Unknown("no_scoped_prefix"), verdict(scopedPrefix = null))
+        assertEquals(IcePathVerdict.Unknown("no_local_candidate"), verdict(candidateMap = emptyMap()))
+    }
+
+    @Test
+    fun `an OEM hotspot on another subnet still passes`() {
+        val result =
+            verdict(
+                candidateMap = candidates("local-1" to "192.168.49.37", "remote-1" to "192.168.49.1"),
+                scopedPrefix = Ipv4Prefix("192.168.49.37", 24),
+            )
+
+        assertTrue(result is IcePathVerdict.OnHotspot)
+    }
+
+    // -----------------------------------------------------------------
+    // Byte growth, compared only within one path
+    // -----------------------------------------------------------------
+
+    private fun onHotspot(pairId: String = "a", generation: Int = 3, bytes: Long) =
+        IcePathVerdict.OnHotspot(pairId, generation, "192.168.43.20", "192.168.43.1", bytes)
+
+    @Test
+    fun `growth on the same pair and generation is a real comparison`() {
+        val flow = SelectedIcePair.flow(onHotspot(bytes = 1000), onHotspot(bytes = 4000))
+
+        assertEquals(SelectedIcePair.Flow.Compared(1000, 4000), flow)
+        assertTrue((flow as SelectedIcePair.Flow.Compared).flowing)
+    }
+
+    @Test
+    fun `a flat counter on the same pair is not flowing`() {
+        val flow = SelectedIcePair.flow(onHotspot(bytes = 4000), onHotspot(bytes = 4000))
+
+        assertTrue(flow is SelectedIcePair.Flow.Compared)
+        assertTrue(!(flow as SelectedIcePair.Flow.Compared).flowing)
+    }
+
+    /**
+     * The regression that made the old check meaningless: two samples were compared with no pair
+     * identity, so a renomination could turn an idle path into an apparently flowing one.
+     */
+    @Test
+    fun `a pair change between samples is not comparable rather than flowing`() {
+        val flow = SelectedIcePair.flow(onHotspot(pairId = "a", bytes = 0), onHotspot(pairId = "b", bytes = 9000))
+
+        assertEquals(SelectedIcePair.Flow.NotComparable("pair_changed"), flow)
+    }
+
+    @Test
+    fun `a session restart between samples is not comparable`() {
+        val flow =
+            SelectedIcePair.flow(onHotspot(generation = 3, bytes = 0), onHotspot(generation = 4, bytes = 9000))
+
+        assertEquals(SelectedIcePair.Flow.NotComparable("ice_generation_changed"), flow)
+    }
+
+    /** A first sample with no verdict cannot stand in for zero bytes; that would fake growth. */
+    @Test
+    fun `an unusable first sample is not treated as zero bytes`() {
+        val flow = SelectedIcePair.flow(IcePathVerdict.Unknown("no_selected_pair"), onHotspot(bytes = 9000))
+
+        assertEquals(SelectedIcePair.Flow.NotComparable("first_sample_unusable"), flow)
+    }
+}

package/android/src/test/java/com/mentra/acsmeeting/source/SoftApIceDiagnosisTest.kt

@@ -0,0 +1,148 @@
+package com.mentra.acsmeeting.source
+
+import com.mentra.acsmeeting.network.Ipv4Prefix
+import com.mentra.acsmeeting.network.ScopedNetworkChangeDetector.PublishedEntry
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+/**
+ * Each case here is a fault that really happened on device and was reported under the same error
+ * code as the others. If two of these ever collapse to one [SoftApIceDiagnosis.Fault], the next
+ * regression gets misattributed the way the handle change was.
+ */
+class SoftApIceDiagnosisTest {
+
+  private val prefix = Ipv4Prefix("192.168.43.79", 24)
+  private val hotspot = PublishedEntry("wlan0", "CONNECTION_WIFI", 0L, listOf("192.168.43.79"))
+
+  private fun onHotspot(address: String = "192.168.43.79") =
+    SoftApIceDiagnosis.CandidateFact(address, "wlan0", true)
+
+  private fun offHotspot(address: String = "10.48.51.7", owner: String? = "rmnet_data0") =
+    SoftApIceDiagnosis.CandidateFact(address, owner, false)
+
+  private fun diagnose(
+    scopedAddress: String? = "192.168.43.79",
+    scopedOwner: String? = "wlan0",
+    published: List<PublishedEntry> = listOf(hotspot),
+    candidates: List<SoftApIceDiagnosis.CandidateFact> = emptyList(),
+  ) = SoftApIceDiagnosis.diagnose(scopedAddress, scopedOwner, prefix, published, candidates)
+
+  /** The address landed in the table after `onAvailable`, so gathering had nothing to find. */
+  @Test
+  fun `an address absent from the kernel table is a missing interface`() {
+    val diagnosis = diagnose(scopedOwner = null)
+
+    assertThat(diagnosis.fault).isEqualTo(SoftApIceDiagnosis.Fault.MISSING_INTERFACE)
+    assertThat(diagnosis.code).isEqualTo(SoftApIceDiagnosis.CODE_NO_CANDIDATES)
+    assertThat(diagnosis.scopedInTable).isFalse
+  }
+
+  @Test
+  fun `no scoped address at all is a missing interface`() {
+    assertThat(diagnose(scopedAddress = null, scopedOwner = null).fault)
+      .isEqualTo(SoftApIceDiagnosis.Fault.MISSING_INTERFACE)
+  }
+
+  /** The hotspot never reached libwebrtc's inventory, so the interface was skipped entirely. */
+  @Test
+  fun `an inventory without the hotspot is an erased entry`() {
+    val diagnosis =
+      diagnose(published = listOf(PublishedEntry("rmnet_data0", "CONNECTION_4G", 7L, listOf("10.48.51.7"))))
+
+    assertThat(diagnosis.fault).isEqualTo(SoftApIceDiagnosis.Fault.ERASED_ENTRY)
+  }
+
+  /**
+   * The regression the decoys caused: two entries on [UNBINDABLE_HANDLE] overwrote each other in a
+   * monitor keyed by handle, and the survivor was whichever connected last.
+   */
+  @Test
+  fun `two entries sharing a handle is an erased entry even when the hotspot is present`() {
+    val diagnosis =
+      diagnose(
+        published =
+          listOf(hotspot, PublishedEntry("rmnet_data0", "CONNECTION_4G", 0L, listOf("10.48.51.7"))),
+      )
+
+    assertThat(diagnosis.fault).isEqualTo(SoftApIceDiagnosis.Fault.ERASED_ENTRY)
+    assertThat(diagnosis.hasHandleCollision()).isTrue
+  }
+
+  /** Address present, entry published, nothing gathered: only the socket bind is left. */
+  @Test
+  fun `zero candidates with everything else in place is a failed binding`() {
+    val diagnosis = diagnose()
+
+    assertThat(diagnosis.fault).isEqualTo(SoftApIceDiagnosis.Fault.FAILED_BINDING)
+    assertThat(diagnosis.code).isEqualTo(SoftApIceDiagnosis.CODE_NO_CANDIDATES)
+  }
+
+  /** A port truthfully on the hotspot that advertised the phone's cellular address. */
+  @Test
+  fun `candidates that are all off-hotspot is a wrong address`() {
+    val diagnosis = diagnose(candidates = listOf(offHotspot()))
+
+    assertThat(diagnosis.fault).isEqualTo(SoftApIceDiagnosis.Fault.WRONG_ADDRESS)
+    assertThat(diagnosis.code).isEqualTo(SoftApIceDiagnosis.CODE_ONLY_NON_HOTSPOT)
+    assertThat(diagnosis.offHotspot).hasSize(1)
+  }
+
+  @Test
+  fun `a hotspot candidate among off-hotspot ones is not classified as wrong address`() {
+    val diagnosis = diagnose(candidates = listOf(offHotspot(), onHotspot()))
+
+    assertThat(diagnosis.fault).isEqualTo(SoftApIceDiagnosis.Fault.INDETERMINATE)
+    assertThat(diagnosis.hotspotCandidates).hasSize(1)
+  }
+
+  /**
+   * Order matters: a missing interface also has zero candidates and an erased entry also has zero,
+   * so blaming the bind first would hide both.
+   */
+  @Test
+  fun `a missing interface outranks the collision and the bind`() {
+    val diagnosis =
+      diagnose(
+        scopedOwner = null,
+        published =
+          listOf(hotspot, PublishedEntry("rmnet_data0", "CONNECTION_4G", 0L, listOf("10.48.51.7"))),
+      )
+
+    assertThat(diagnosis.fault).isEqualTo(SoftApIceDiagnosis.Fault.MISSING_INTERFACE)
+  }
+
+  /** The analyzer reads these names, so they are a contract rather than log prose. */
+  @Test
+  fun `the fields carry every observation the analyzer reads`() {
+    val fields = diagnose(candidates = listOf(offHotspot())).fields().toMap()
+
+    assertThat(fields["code"]).isEqualTo(SoftApIceDiagnosis.CODE_ONLY_NON_HOTSPOT)
+    assertThat(fields["fault"]).isEqualTo("WRONG_ADDRESS")
+    assertThat(fields["scopedAddress"]).isEqualTo("192.168.43.79")
+    assertThat(fields["scopedOwner"]).isEqualTo("wlan0")
+    assertThat(fields["scopedInTable"]).isEqualTo(true)
+    assertThat(fields["scopedPrefix"]).isEqualTo("192.168.43.79/24")
+    assertThat(fields["publishedInventory"]).isEqualTo("wlan0[CONNECTION_WIFI]#0(192.168.43.79)")
+    assertThat(fields["publishedHotspot"]).isEqualTo(true)
+    assertThat(fields["handleCollision"]).isEqualTo(false)
+    assertThat(fields["gathered"]).isEqualTo(1)
+    assertThat(fields["hotspotCandidates"]).isEqualTo(0)
+    assertThat(fields["offHotspot"]).isEqualTo("10.48.51.7@rmnet_data0")
+  }
+
+  @Test
+  fun `an unattributable candidate address is reported as absent rather than dropped`() {
+    val fields = diagnose(candidates = listOf(offHotspot(owner = null))).fields().toMap()
+
+    assertThat(fields["offHotspot"]).isEqualTo("10.48.51.7@ABSENT")
+  }
+
+  @Test
+  fun `an empty inventory reads as none rather than blank`() {
+    val fields = diagnose(published = emptyList()).fields().toMap()
+
+    assertThat(fields["publishedInventory"]).isEqualTo("none")
+    assertThat(fields["offHotspot"]).isEqualTo("none")
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/source/SoftApIcePolicyTest.kt

@@ -0,0 +1,76 @@
+package com.mentra.acsmeeting.source
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import org.webrtc.PeerConnectionFactory
+
+/**
+ * Pins which adapters the SoftAP peer may gather on.
+ *
+ * Getting this wrong is not a crash. An answer carrying a cellular candidate negotiates fine and
+ * then never carries a frame, because the glasses have no route to the phone's mobile address — and
+ * the logs show a healthy call the whole time.
+ */
+class SoftApIcePolicyTest {
+
+  private val mask = SoftApIcePolicy.networkIgnoreMask()
+
+  @Test
+  fun `cellular is excluded because the glasses cannot reach it`() {
+    assertThat(SoftApIcePolicy.allowsAdapter(mask, PeerConnectionFactory.Options.ADAPTER_TYPE_CELLULAR))
+      .isFalse()
+  }
+
+  @Test
+  fun `vpn is excluded because a tunnel address is not on the hotspot`() {
+    assertThat(SoftApIcePolicy.allowsAdapter(mask, PeerConnectionFactory.Options.ADAPTER_TYPE_VPN))
+      .isFalse()
+  }
+
+  @Test
+  fun `loopback is excluded because no other device can reach it`() {
+    assertThat(SoftApIcePolicy.allowsAdapter(mask, PeerConnectionFactory.Options.ADAPTER_TYPE_LOOPBACK))
+      .isFalse()
+  }
+
+  /** The whole point: the hotspot presents as Wi-Fi, so Wi-Fi must survive the mask. */
+  @Test
+  fun `wifi is allowed`() {
+    assertThat(SoftApIcePolicy.allowsAdapter(mask, PeerConnectionFactory.Options.ADAPTER_TYPE_WIFI))
+      .isTrue()
+  }
+
+  /**
+   * The reason `ScopedNetworkChangeDetector` publishes decoy entries for interfaces it does not
+   * want. `ADAPTER_TYPE_UNKNOWN` is `0`, so no mask can ever exclude it: an interface the network
+   * monitor never announced is an interface ICE will gather on no matter what this mask says.
+   */
+  @Test
+  fun `an unknown adapter cannot be masked, so no interface may go unannounced`() {
+    assertThat(PeerConnectionFactory.Options.ADAPTER_TYPE_UNKNOWN).isEqualTo(0)
+    assertThat(SoftApIcePolicy.allowsAdapter(mask, PeerConnectionFactory.Options.ADAPTER_TYPE_UNKNOWN))
+      .isTrue()
+  }
+
+  @Test
+  fun `ethernet and ANY are excluded so a leftover AutoDetect network cannot gather`() {
+    assertThat(SoftApIcePolicy.allowsAdapter(mask, PeerConnectionFactory.Options.ADAPTER_TYPE_ETHERNET))
+      .isFalse()
+    assertThat(SoftApIcePolicy.allowsAdapter(mask, PeerConnectionFactory.Options.ADAPTER_TYPE_ANY))
+      .isFalse()
+  }
+
+  @Test
+  fun `the factory options carry the mask`() {
+    assertThat(SoftApIcePolicy.factoryOptions().networkIgnoreMask).isEqualTo(mask)
+  }
+
+  /**
+   * The network monitor must stay on. Disabling it would stop libwebrtc from noticing the Wi-Fi
+   * interface at all, which is the opposite of what this path needs.
+   */
+  @Test
+  fun `the network monitor is left enabled`() {
+    assertThat(SoftApIcePolicy.factoryOptions().disableNetworkMonitor).isFalse()
+  }
+}