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

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

@@ -1,187 +0,0 @@
-package com.mentra.acsmeeting.network
-
-import com.mentra.acsmeeting.network.ScopedNetworkState.Failure
-import com.mentra.acsmeeting.network.ScopedNetworkState.Phase
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-/**
- * ConnectivityManager gives no ordering or at-most-once guarantee, so these cover the awkward
- * orderings that would otherwise only show up on a device: duplicate callbacks, a callback from a
- * request that was already replaced, and a timeout racing a late onAvailable.
- */
-class ScopedNetworkLifecycleTest {
-
-    @Test
-    fun `starts idle`() {
-        val state = ScopedNetworkState()
-        assertThat(state.phase).isEqualTo(Phase.IDLE)
-        assertThat(state.failure).isEqualTo(Failure.NONE)
-        assertThat(state.isActive).isFalse()
-    }
-
-    @Test
-    fun `happy path is idle to requesting to available`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-        assertThat(state.phase).isEqualTo(Phase.REQUESTING)
-
-        assertThat(state.onAvailable(generation)).isTrue()
-        assertThat(state.phase).isEqualTo(Phase.AVAILABLE)
-        assertThat(state.failure).isEqualTo(Failure.NONE)
-    }
-
-    @Test
-    fun `a duplicate onAvailable does not re-transition`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-
-        assertThat(state.onAvailable(generation)).isTrue()
-        assertThat(state.onAvailable(generation)).isFalse()
-        assertThat(state.phase).isEqualTo(Phase.AVAILABLE)
-    }
-
-    @Test
-    fun `losing an available network reports LOST`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-        state.onAvailable(generation)
-
-        assertThat(state.onLost(generation)).isTrue()
-        assertThat(state.phase).isEqualTo(Phase.LOST)
-        assertThat(state.failure).isEqualTo(Failure.LOST)
-    }
-
-    @Test
-    fun `a second onLost is a no-op`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-        state.onAvailable(generation)
-        state.onLost(generation)
-
-        assertThat(state.onLost(generation)).isFalse()
-    }
-
-    @Test
-    fun `timeout while still requesting fails as TIMEOUT`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-
-        assertThat(state.onTimeout(generation)).isTrue()
-        assertThat(state.phase).isEqualTo(Phase.LOST)
-        assertThat(state.failure).isEqualTo(Failure.TIMEOUT)
-    }
-
-    /** The join succeeded just before the watchdog fired; the network must stay usable. */
-    @Test
-    fun `a timeout arriving after onAvailable is ignored`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-        state.onAvailable(generation)
-
-        assertThat(state.onTimeout(generation)).isFalse()
-        assertThat(state.phase).isEqualTo(Phase.AVAILABLE)
-        assertThat(state.failure).isEqualTo(Failure.NONE)
-    }
-
-    @Test
-    fun `onUnavailable fails as UNAVAILABLE`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-
-        assertThat(state.onUnavailable(generation)).isTrue()
-        assertThat(state.failure).isEqualTo(Failure.UNAVAILABLE)
-    }
-
-    @Test
-    fun `a SecurityException maps to PERMISSION_DENIED`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-
-        assertThat(state.onRequestFailed(generation, permissionDenied = true)).isTrue()
-        assertThat(state.failure).isEqualTo(Failure.PERMISSION_DENIED)
-    }
-
-    @Test
-    fun `any other request throw maps to REQUEST_FAILED`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-
-        assertThat(state.onRequestFailed(generation, permissionDenied = false)).isTrue()
-        assertThat(state.failure).isEqualTo(Failure.REQUEST_FAILED)
-    }
-
-    // -----------------------------------------------------------------
-    // Stale generations
-    // -----------------------------------------------------------------
-
-    @Test
-    fun `callbacks from a superseded request are rejected`() {
-        val state = ScopedNetworkState()
-        val first = state.startRequest()
-        val second = state.startRequest()
-        assertThat(second).isNotEqualTo(first)
-
-        assertThat(state.onAvailable(first)).isFalse()
-        assertThat(state.onLost(first)).isFalse()
-        assertThat(state.onUnavailable(first)).isFalse()
-        assertThat(state.onTimeout(first)).isFalse()
-        assertThat(state.phase).isEqualTo(Phase.REQUESTING)
-
-        assertThat(state.onAvailable(second)).isTrue()
-    }
-
-    @Test
-    fun `a late onLost after release does not resurrect state`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-        state.onAvailable(generation)
-        state.release()
-
-        assertThat(state.onLost(generation)).isFalse()
-        assertThat(state.failure).isEqualTo(Failure.NONE)
-    }
-
-    @Test
-    fun `release is idempotent`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-        state.onAvailable(generation)
-
-        assertThat(state.release()).isTrue()
-        assertThat(state.release()).isFalse()
-    }
-
-    @Test
-    fun `release from idle is a no-op`() {
-        assertThat(ScopedNetworkState().release()).isFalse()
-    }
-
-    @Test
-    fun `reset returns the machine to idle for reuse`() {
-        val state = ScopedNetworkState()
-        val generation = state.startRequest()
-        state.onLost(generation)
-        state.reset()
-
-        assertThat(state.phase).isEqualTo(Phase.IDLE)
-        assertThat(state.failure).isEqualTo(Failure.NONE)
-
-        val next = state.startRequest()
-        assertThat(state.onAvailable(next)).isTrue()
-    }
-
-    /** Ten start/stop cycles must leave no residue, matching the rejoin soak requirement. */
-    @Test
-    fun `ten join and release cycles end clean`() {
-        val state = ScopedNetworkState()
-        repeat(10) {
-            val generation = state.startRequest()
-            assertThat(state.onAvailable(generation)).isTrue()
-            assertThat(state.release()).isTrue()
-            state.reset()
-            assertThat(state.phase).isEqualTo(Phase.IDLE)
-        }
-        assertThat(state.generation).isEqualTo(10)
-    }
-}

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

@@ -1,172 +0,0 @@
-package com.mentra.acsmeeting.network
-
-import com.mentra.acsmeeting.network.ScopedNetworkChangeDetector.ScopedInterface
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-import org.webrtc.NetworkChangeDetector
-
-/**
- * The takeover keeps a process-wide monitor from answering SoftAP with a leftover cellular handle;
- * the restore keeps that takeover from breaking the next WHEP or LiveKit connection in the same
- * process. Both halves are tested against a recording observer rather than the on-device gate.
- */
-class ScopedNetworkObserverTest {
-
-    private val connected = mutableListOf<Long>()
-    private val disconnected = mutableListOf<Long>()
-    private var scoped: ScopedInterface? = softAp()
-
-    private val downstream =
-        object : NetworkChangeDetector.Observer() {
-            override fun onConnectionTypeChanged(connectionType: NetworkChangeDetector.ConnectionType) = Unit
-
-            override fun onNetworkConnect(networkInfo: NetworkChangeDetector.NetworkInformation) {
-                connected.add(networkInfo.handle)
-            }
-
-            override fun onNetworkDisconnect(networkHandle: Long) {
-                disconnected.add(networkHandle)
-            }
-
-            override fun onNetworkPreference(
-                types: MutableList<NetworkChangeDetector.ConnectionType>,
-                preference: Int,
-            ) = Unit
-        }
-
-    private val observer = ScopedNetworkObserver(downstream) { scoped }
-
-    private fun ipv4(a: Int, b: Int, c: Int, d: Int) =
-        byteArrayOf(a.toByte(), b.toByte(), c.toByte(), d.toByte())
-
-    private fun softAp() = ScopedInterface("wlan0", 99L, listOf(ipv4(192, 168, 43, 79)))
-
-    private fun hotspot() = ScopedNetworkChangeDetector.toNetworkInformation(softAp())!!
-
-    private fun info(name: String, handle: Long, address: ByteArray = ipv4(10, 1, 2, 3)) =
-        NetworkChangeDetector.NetworkInformation(
-            name,
-            NetworkChangeDetector.ConnectionType.CONNECTION_4G,
-            NetworkChangeDetector.ConnectionType.CONNECTION_NONE,
-            handle,
-            arrayOf(NetworkChangeDetector.IPAddress(address)),
-        )
-
-    @Test
-    fun `a stock connect is swallowed while SoftAP is joined`() {
-        observer.onNetworkConnect(info("rmnet_data0", 7L))
-
-        assertThat(connected).isEmpty()
-    }
-
-    /**
-     * The monitor is already running when a SoftAP call starts: ACS joins over cellular first, so
-     * those handles are in the native list before ingest exists. They have to be dropped.
-     */
-    @Test
-    fun `publish drops networks announced before the join and connects only the inventory`() {
-        observer.onNetworkConnect(info("rmnet_data0", 7L))
-        observer.onNetworkConnect(info("wlan0", 8L, ipv4(192, 168, 50, 7)))
-
-        observer.publish(listOf(hotspot()))
-
-        assertThat(disconnected).containsExactly(7L, 8L)
-        assertThat(connected).containsExactly(99L)
-    }
-
-    @Test
-    fun `a second publish of the same inventory is a no-op`() {
-        observer.publish(listOf(hotspot()))
-        connected.clear()
-
-        observer.publish(listOf(hotspot()))
-
-        assertThat(connected).isEmpty()
-        assertThat(disconnected).isEmpty()
-    }
-
-    /**
-     * Teardown followed by ordinary WebRTC. Resuming pass-through alone would leave these networks
-     * missing until the OS happened to re-announce them, and leave the synthetic entry in place.
-     */
-    @Test
-    fun `teardown drops the synthetic entry and replays the suppressed networks`() {
-        observer.onNetworkConnect(info("rmnet_data0", 7L))
-        observer.publish(listOf(hotspot()))
-        connected.clear()
-        disconnected.clear()
-
-        scoped = null
-        observer.restore()
-
-        assertThat(disconnected).containsExactly(99L)
-        assertThat(connected).containsExactly(7L)
-    }
-
-    /** A network that genuinely went away while SoftAP was up must not come back in the replay. */
-    @Test
-    fun `a network lost during the call is not replayed on teardown`() {
-        observer.onNetworkConnect(info("rmnet_data0", 7L))
-        observer.onNetworkConnect(info("wlan0", 8L, ipv4(192, 168, 50, 7)))
-        observer.publish(listOf(hotspot()))
-        observer.onNetworkDisconnect(8L)
-        connected.clear()
-
-        scoped = null
-        observer.restore()
-
-        assertThat(connected).containsExactly(7L)
-    }
-
-    @Test
-    fun `restore is idempotent and a no-op when ownership was never taken`() {
-        scoped = null
-
-        observer.restore()
-        observer.restore()
-
-        assertThat(connected).isEmpty()
-        assertThat(disconnected).isEmpty()
-    }
-
-    /** Restoration is also driven from the OS side, since after teardown it may be the only caller. */
-    @Test
-    fun `a stock callback after teardown restores before forwarding, and forwards once`() {
-        observer.onNetworkConnect(info("rmnet_data0", 7L))
-        observer.publish(listOf(hotspot()))
-        connected.clear()
-        disconnected.clear()
-
-        scoped = null
-        observer.onNetworkConnect(info("wlan0", 8L, ipv4(192, 168, 50, 7)))
-
-        assertThat(disconnected).containsExactly(99L)
-        assertThat(connected).containsExactly(7L, 8L)
-    }
-
-    @Test
-    fun `stock callbacks pass through once the hotspot is gone`() {
-        scoped = null
-
-        observer.onNetworkConnect(info("rmnet_data0", 7L))
-
-        assertThat(connected).containsExactly(7L)
-    }
-
-    /** Rejoin is part of the acceptance bar, so the takeover has to re-arm after a restore. */
-    @Test
-    fun `an immediate rejoin takes the monitor back over`() {
-        observer.onNetworkConnect(info("rmnet_data0", 7L))
-        observer.publish(listOf(hotspot()))
-        scoped = null
-        observer.restore()
-        connected.clear()
-        disconnected.clear()
-
-        scoped = softAp()
-        observer.publish(listOf(hotspot()))
-
-        assertThat(disconnected).containsExactly(7L)
-        assertThat(connected).containsExactly(99L)
-    }
-}

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

@@ -1,141 +0,0 @@
-package com.mentra.acsmeeting.network
-
-import com.mentra.acsmeeting.network.ScopedNetworkReadiness.Verdict
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-/**
- * The race these cases pin cost a misdiagnosis: ingest started on `onAvailable`, the hotspot address
- * was not yet in the kernel table, and the resulting candidate-less answer was blamed on socket
- * binding. Readiness now has to agree from three sources, and the missing one has to be named.
- */
-class ScopedNetworkReadinessTest {
-
-    private val readiness = ScopedNetworkReadiness()
-
-    private fun joined() {
-        readiness.onAvailable()
-        readiness.onCapabilities()
-        readiness.onLinkProperties("wlan0", "192.168.43.79")
-    }
-
-    @Test
-    fun `a fresh gate waits for onAvailable`() {
-        assertThat(readiness.verdict()).isEqualTo(Verdict.Waiting("onAvailable"))
-        assertThat(readiness.callbacksSatisfied()).isFalse
-    }
-
-    /** Android's guidance, and the reason `onAvailable` alone was not enough. */
-    @Test
-    fun `onAvailable alone is not ready`() {
-        readiness.onAvailable()
-
-        assertThat(readiness.verdict()).isEqualTo(Verdict.Waiting("onCapabilitiesChanged"))
-    }
-
-    @Test
-    fun `capabilities without an address is not ready`() {
-        readiness.onAvailable()
-        readiness.onCapabilities()
-
-        assertThat(readiness.verdict()).isEqualTo(Verdict.Waiting("an IPv4 address from onLinkPropertiesChanged"))
-    }
-
-    /** The whole point: the callbacks can all agree while ICE still has nothing to gather. */
-    @Test
-    fun `every callback reporting is not ready until the kernel table has the address`() {
-        joined()
-
-        assertThat(readiness.callbacksSatisfied()).isTrue
-        assertThat(readiness.verdict())
-            .isEqualTo(Verdict.Waiting("the kernel interface table to carry 192.168.43.79"))
-    }
-
-    @Test
-    fun `the address appearing in the table late completes readiness`() {
-        joined()
-
-        readiness.onInterfaceTable("wlan0")
-
-        assertThat(readiness.verdict()).isEqualTo(Verdict.Ready("192.168.43.79", "wlan0", "wlan0"))
-    }
-
-    /**
-     * A name disagreement is reported, not blocked on: ICE gathers per address, so the address being
-     * in the table is what matters. Blocking here would fail calls that actually work.
-     */
-    @Test
-    fun `the kernel owning the address under another name is still ready`() {
-        joined()
-
-        readiness.onInterfaceTable("wlan1")
-
-        val verdict = readiness.verdict() as Verdict.Ready
-        assertThat(verdict.interfaceName).isEqualTo("wlan0")
-        assertThat(verdict.owner).isEqualTo("wlan1")
-    }
-
-    /** A later poll that no longer finds the address must un-ready the gate, not latch. */
-    @Test
-    fun `the address leaving the table takes readiness away again`() {
-        joined()
-        readiness.onInterfaceTable("wlan0")
-
-        readiness.onInterfaceTable(null)
-
-        assertThat(readiness.verdict()).isInstanceOf(Verdict.Waiting::class.java)
-    }
-
-    /** LinkProperties is a whole-state snapshot, so a later one without an address means gone. */
-    @Test
-    fun `a link properties update without an address clears the observation`() {
-        joined()
-        readiness.onInterfaceTable("wlan0")
-
-        readiness.onLinkProperties("wlan0", null)
-
-        assertThat(readiness.callbacksSatisfied()).isFalse
-    }
-
-    /** The synchronous read inside `onAvailable` is a hint; it must not erase a real callback. */
-    @Test
-    fun `seeding with no address does not clear what a callback reported`() {
-        readiness.onLinkProperties("wlan0", "192.168.43.79")
-
-        readiness.seedLinkProperties(null, null)
-
-        assertThat(readiness.observations.linkAddress).isEqualTo("192.168.43.79")
-    }
-
-    @Test
-    fun `seeding supplies the address when the callback has not arrived`() {
-        readiness.onAvailable()
-        readiness.seedLinkProperties("wlan0", "192.168.43.79")
-        readiness.onCapabilities()
-
-        assertThat(readiness.callbacksSatisfied()).isTrue
-    }
-
-    /** Rejoin reuses the instance, so a stale Ready from the previous call would be fatal. */
-    @Test
-    fun `reset returns the gate to waiting for onAvailable`() {
-        joined()
-        readiness.onInterfaceTable("wlan0")
-
-        readiness.reset()
-
-        assertThat(readiness.verdict()).isEqualTo(Verdict.Waiting("onAvailable"))
-    }
-
-    @Test
-    fun `callbacks arriving out of order still resolve`() {
-        readiness.onCapabilities()
-        readiness.onLinkProperties("wlan0", "192.168.43.79")
-        readiness.onInterfaceTable("wlan0")
-        assertThat(readiness.verdict()).isEqualTo(Verdict.Waiting("onAvailable"))
-
-        readiness.onAvailable()
-
-        assertThat(readiness.verdict()).isInstanceOf(Verdict.Ready::class.java)
-    }
-}

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

@@ -1,69 +0,0 @@
-package com.mentra.acsmeeting.network
-
-import android.net.NetworkCapabilities
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-/**
- * Guards the one property the whole dual-homing design rests on: the SoftAP request must not ask
- * for `NET_CAPABILITY_INTERNET`. If that regresses, Android can promote the glasses hotspot to the
- * default network and ACS traffic silently stops using cellular.
- */
-class ScopedNetworkRequestSpecTest {
-
-    @Test
-    fun `the softap request removes the internet capability`() {
-        val spec = ScopedNetworkRequestSpec.forSoftAp("MentraLive-1234", "hunter2")
-
-        assertThat(spec.removedCapabilities).contains(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-        assertThat(spec.avoidsInternetCapability).isTrue()
-    }
-
-    @Test
-    fun `the softap request is wifi only`() {
-        val spec = ScopedNetworkRequestSpec.forSoftAp("MentraLive-1234", "hunter2")
-
-        assertThat(spec.transportTypes).containsExactly(NetworkCapabilities.TRANSPORT_WIFI)
-    }
-
-    @Test
-    fun `ssid and passphrase are carried through`() {
-        val spec = ScopedNetworkRequestSpec.forSoftAp("MentraLive-1234", "hunter2")
-
-        assertThat(spec.ssid).isEqualTo("MentraLive-1234")
-        assertThat(spec.passphrase).isEqualTo("hunter2")
-        assertThat(spec.hasPassphrase).isTrue()
-    }
-
-    @Test
-    fun `an open network reports no passphrase`() {
-        assertThat(ScopedNetworkRequestSpec.forSoftAp("Open-AP", "").hasPassphrase).isFalse()
-    }
-
-    @Test
-    fun `the default timeout matches the bluetooth sdk hotspot join`() {
-        assertThat(ScopedNetworkRequestSpec.forSoftAp("x", "y").timeoutMs).isEqualTo(30_000)
-        assertThat(ScopedNetworkRequestSpec.DEFAULT_TIMEOUT_MS).isEqualTo(30_000)
-    }
-
-    @Test
-    fun `the timeout is overridable`() {
-        assertThat(ScopedNetworkRequestSpec.forSoftAp("x", "y", timeoutMs = 5_000).timeoutMs)
-            .isEqualTo(5_000)
-    }
-
-    /** A spec that kept the internet capability must not read as safe. */
-    @Test
-    fun `avoidsInternetCapability is false when the capability is not removed`() {
-        val unsafe =
-            ScopedNetworkRequestSpec(
-                ssid = "x",
-                passphrase = "y",
-                transportTypes = setOf(NetworkCapabilities.TRANSPORT_WIFI),
-                removedCapabilities = emptySet(),
-                timeoutMs = 1_000,
-            )
-
-        assertThat(unsafe.avoidsInternetCapability).isFalse()
-    }
-}

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

@@ -1,22 +0,0 @@
-package com.mentra.acsmeeting.source
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-import java.nio.ByteBuffer
-
-class BitmapFontTest {
-  @Test
-  fun drawsOnPixelsForDigitEight() {
-    val width = 80
-    val height = 40
-    val dest = ByteBuffer.allocate(width * height)
-    BitmapFont.draw(dest, width, height, "8", 0, 0, 2, 0xEB.toByte())
-    var on = 0
-    for (i in 0 until dest.capacity()) {
-      if (dest.get(i) == 0xEB.toByte()) on += 1
-    }
-    assertThat(on).isGreaterThan(0)
-    assertThat(BitmapFont.textWidth(1, 2)).isEqualTo(5 * 2)
-    assertThat(BitmapFont.textHeight(2)).isEqualTo(7 * 2)
-  }
-}

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

@@ -1,41 +0,0 @@
-package com.mentra.acsmeeting.source
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-/**
- * Covers the scale decision the relay makes on every frame.
- *
- * This code was previously inline in [CloudflareWhepSource] with no coverage at all, and it is
- * decided per frame on the decode thread. Both directions are invisible when wrong: an unnecessary
- * scale is a silent per-frame CPU cost, and a skipped one is a plane-size mismatch at the ACS
- * sender rather than an exception here.
- */
-class DecodedTrackRelayTest {
-
-  @Test
-  fun `no target size means ACS has not negotiated yet, so the buffer passes through`() {
-    assertThat(DecodedTrackRelay.needsScale(null, 1280, 720)).isFalse()
-  }
-
-  @Test
-  fun `a target matching the buffer needs no scale`() {
-    assertThat(DecodedTrackRelay.needsScale(TargetSize(1280, 720), 1280, 720)).isFalse()
-  }
-
-  @Test
-  fun `a differing width or height needs a scale`() {
-    assertThat(DecodedTrackRelay.needsScale(TargetSize(640, 720), 1280, 720)).isTrue()
-    assertThat(DecodedTrackRelay.needsScale(TargetSize(1280, 360), 1280, 720)).isTrue()
-    assertThat(DecodedTrackRelay.needsScale(TargetSize(640, 360), 1280, 720)).isTrue()
-  }
-
-  /**
-   * A transposed target is a real size change, not a rotation to be ignored. The relay works in
-   * unrotated buffer coordinates, so 720x1280 against a 1280x720 buffer must scale.
-   */
-  @Test
-  fun `a transposed target still needs a scale`() {
-    assertThat(DecodedTrackRelay.needsScale(TargetSize(720, 1280), 1280, 720)).isTrue()
-  }
-}

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

@@ -1,60 +0,0 @@
-package com.mentra.acsmeeting.source
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-class FirstFrameGateTest {
-  @Test
-  fun answerAloneDoesNotPromote() {
-    val gate = FirstFrameGate()
-    gate.arm(1)
-    // The answer is armed, not live: nothing has reached the sink yet.
-    assertThat(gate.expired(1)).isTrue()
-  }
-
-  @Test
-  fun firstFrameForTheArmedGenerationPromotesExactlyOnce() {
-    val gate = FirstFrameGate()
-    gate.arm(7)
-    assertThat(gate.onFrame(7)).isTrue()
-    assertThat(gate.onFrame(7)).isFalse()
-    assertThat(gate.expired(7)).isFalse()
-  }
-
-  @Test
-  fun framesFromAPeerBeingTornDownNeverPromote() {
-    val gate = FirstFrameGate()
-    gate.arm(2)
-    assertThat(gate.onFrame(1)).isFalse()
-    assertThat(gate.expired(2)).isTrue()
-  }
-
-  @Test
-  fun deadlineForASupersededGenerationDoesNotFailTheNewPeer() {
-    val gate = FirstFrameGate()
-    gate.arm(3)
-    gate.arm(4)
-    assertThat(gate.expired(3)).isFalse()
-    assertThat(gate.expired(4)).isTrue()
-  }
-
-  @Test
-  fun iceRecoveryRearmsSoTheNextFramePromotesAgain() {
-    val gate = FirstFrameGate()
-    gate.arm(5)
-    assertThat(gate.onFrame(5)).isTrue()
-    // ICE bounced and came back on the same peer: LIVE has to be re-earned.
-    gate.arm(5)
-    assertThat(gate.expired(5)).isTrue()
-    assertThat(gate.onFrame(5)).isTrue()
-  }
-
-  @Test
-  fun resetClearsTheArmSoAStoppedSourceCannotBeFailedLater() {
-    val gate = FirstFrameGate()
-    gate.arm(6)
-    gate.reset()
-    assertThat(gate.expired(6)).isFalse()
-    assertThat(gate.onFrame(6)).isFalse()
-  }
-}