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

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

@@ -1,275 +0,0 @@
-package com.mentra.acsmeeting.source
-
-import com.mentra.acsmeeting.network.Ipv4Prefix
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-/**
- * Pins the candidate classification the SoftAP path depends on.
- *
- * The cases here deliberately mirror
- * `com.mentra.asg_client.io.streaming.config.IcePostPolicyTest` on the glasses. The two
- * implementations cannot share code across the module boundary, and if they disagree the symptom is
- * a call that negotiates and then carries nothing: one side posts an offer it considers ready while
- * the other rejects it, or worse, both accept a candidate pair that cannot actually reach across
- * the hotspot.
- */
-class SoftApSdpGuardTest {
-
-  private val hostCandidate =
-    "a=candidate:1 1 udp 2122260223 192.168.43.20 51234 typ host generation 0"
-  private val srflxCandidate =
-    "a=candidate:2 1 udp 1686052607 203.0.113.7 51234 typ srflx raddr 192.168.43.20 rport 51234"
-
-  private fun sdp(vararg lines: String) =
-    (listOf("v=0", "m=video 9 UDP/TLS/RTP/SAVPF 96") + lines).joinToString("\r\n")
-
-  // -----------------------------------------------------------------
-  // Accepting a usable negotiation
-  // -----------------------------------------------------------------
-
-  @Test
-  fun `an sdp with a hotspot host candidate is accepted`() {
-    val verdict = SoftApSdpGuard.inspect(sdp(hostCandidate))
-
-    assertThat(verdict).isInstanceOf(SoftApSdpGuard.Verdict.Ok::class.java)
-    val ok = verdict as SoftApSdpGuard.Verdict.Ok
-    assertThat(ok.hostCandidates).hasSize(1)
-    assertThat(ok.routableCandidates).isEmpty()
-  }
-
-  /**
-   * Not a rejection. A stale glasses build may still gather srflx candidates, and dropping the call
-   * over it would be worse than a warning when a usable hotspot candidate is also present — but it
-   * is reported, because ICE could otherwise select it.
-   */
-  @Test
-  fun `a stray srflx candidate is reported but does not reject`() {
-    val verdict = SoftApSdpGuard.inspect(sdp(hostCandidate, srflxCandidate))
-
-    val ok = verdict as SoftApSdpGuard.Verdict.Ok
-    assertThat(ok.hostCandidates).hasSize(1)
-    assertThat(ok.routableCandidates).hasSize(1)
-    assertThat(ok.routableCandidates.single()).contains("typ srflx")
-  }
-
-  @Test
-  fun `any rfc1918 subnet counts, not just the default hotspot range`() {
-    // A hotspot on a non-default subnet must not silently fail the gate.
-    for (address in listOf("192.168.1.5", "10.0.0.9", "172.16.4.4", "172.31.255.254")) {
-      val verdict = SoftApSdpGuard.inspect(
-        sdp("a=candidate:1 1 udp 2122260223 $address 51234 typ host generation 0"),
-      )
-
-      assertThat(verdict)
-        .describedAs(address)
-        .isInstanceOf(SoftApSdpGuard.Verdict.Ok::class.java)
-    }
-  }
-
-  // -----------------------------------------------------------------
-  // Rejecting an unusable negotiation
-  // -----------------------------------------------------------------
-
-  @Test
-  fun `an sdp with only a srflx candidate is rejected`() {
-    val verdict = SoftApSdpGuard.inspect(sdp(srflxCandidate))
-
-    val rejected = verdict as SoftApSdpGuard.Verdict.Rejected
-    assertThat(rejected.code).isEqualTo(SoftApSdpGuard.REASON_ONLY_NON_HOTSPOT)
-    assertThat(rejected.detail).contains("typ srflx")
-  }
-
-  @Test
-  fun `an sdp with no candidates at all is rejected and says so`() {
-    val verdict = SoftApSdpGuard.inspect(sdp())
-
-    val rejected = verdict as SoftApSdpGuard.Verdict.Rejected
-    assertThat(rejected.code).isEqualTo(SoftApSdpGuard.REASON_NO_CANDIDATES)
-    assertThat(rejected.detail).isEqualTo("no candidates at all")
-  }
-
-  /** Public and loopback host candidates are unreachable from the glasses. */
-  @Test
-  fun `a host candidate on a public or loopback address is rejected`() {
-    for (address in listOf("203.0.113.7", "127.0.0.1", "8.8.8.8", "172.32.0.1", "192.169.0.1")) {
-      val verdict = SoftApSdpGuard.inspect(
-        sdp("a=candidate:1 1 udp 2122260223 $address 51234 typ host generation 0"),
-      )
-
-      assertThat(verdict)
-        .describedAs(address)
-        .isInstanceOf(SoftApSdpGuard.Verdict.Rejected::class.java)
-    }
-  }
-
-  /**
-   * A link-local address means the interface never got a DHCP lease from the glasses. ICE would
-   * gather it and connect to nothing.
-   */
-  @Test
-  fun `a link local host candidate is rejected`() {
-    val verdict = SoftApSdpGuard.inspect(
-      sdp("a=candidate:1 1 udp 2122260223 169.254.10.20 51234 typ host generation 0"),
-    )
-
-    assertThat(verdict).isInstanceOf(SoftApSdpGuard.Verdict.Rejected::class.java)
-  }
-
-  /**
-   * libwebrtc emits these to hide private addresses from remote peers. The glasses cannot resolve
-   * them, so a negotiation carrying only mDNS candidates is broken however healthy it looks.
-   */
-  @Test
-  fun `an mdns obfuscated candidate is rejected`() {
-    val verdict = SoftApSdpGuard.inspect(
-      sdp(
-        "a=candidate:1 1 udp 2122260223 " +
-          "b8e7c1f2-0000-4000-8000-000000000000.local 51234 typ host generation 0",
-      ),
-    )
-
-    val rejected = verdict as SoftApSdpGuard.Verdict.Rejected
-    assertThat(rejected.code).isEqualTo(SoftApSdpGuard.REASON_ONLY_NON_HOTSPOT)
-  }
-
-  @Test
-  fun `an ipv6 host candidate does not satisfy the gate`() {
-    // The SoftAP link is IPv4 only, so an IPv6 candidate cannot carry this media.
-    val verdict = SoftApSdpGuard.inspect(
-      sdp("a=candidate:1 1 udp 2122260223 fe80::1 51234 typ host generation 0"),
-    )
-
-    assertThat(verdict).isInstanceOf(SoftApSdpGuard.Verdict.Rejected::class.java)
-  }
-
-  @Test
-  fun `empty and non sdp input is malformed rather than candidate-less`() {
-    for (input in listOf(null, "", "   ", "v=0\r\no=- 0 0 IN IP4 0.0.0.0")) {
-      val verdict = SoftApSdpGuard.inspect(input)
-
-      assertThat((verdict as SoftApSdpGuard.Verdict.Rejected).code)
-        .describedAs(input.orEmpty())
-        .isEqualTo(SoftApSdpGuard.REASON_MALFORMED)
-    }
-  }
-
-  // -----------------------------------------------------------------
-  // Parsing details
-  // -----------------------------------------------------------------
-
-  @Test
-  fun `candidate extraction strips the attribute prefix and ignores other lines`() {
-    val candidates = SoftApSdpGuard.candidateLines(
-      sdp("a=mid:0", hostCandidate, "a=sendrecv", srflxCandidate),
-    )
-
-    assertThat(candidates).hasSize(2)
-    assertThat(candidates).allSatisfy { assertThat(it).startsWith("candidate:") }
-  }
-
-  @Test
-  fun `candidate extraction tolerates trailing whitespace and lone newlines`() {
-    val candidates = SoftApSdpGuard.candidateLines("m=video 9\n$hostCandidate  \n")
-
-    assertThat(candidates).hasSize(1)
-  }
-
-  @Test
-  fun `private ipv4 boundaries match rfc1918 exactly`() {
-    assertThat(SoftApSdpGuard.isPrivateIpv4("10.0.0.0")).isTrue()
-    assertThat(SoftApSdpGuard.isPrivateIpv4("10.255.255.255")).isTrue()
-    assertThat(SoftApSdpGuard.isPrivateIpv4("172.15.0.1")).isFalse()
-    assertThat(SoftApSdpGuard.isPrivateIpv4("172.16.0.0")).isTrue()
-    assertThat(SoftApSdpGuard.isPrivateIpv4("172.31.0.0")).isTrue()
-    assertThat(SoftApSdpGuard.isPrivateIpv4("172.32.0.0")).isFalse()
-    assertThat(SoftApSdpGuard.isPrivateIpv4("192.168.0.0")).isTrue()
-    assertThat(SoftApSdpGuard.isPrivateIpv4("192.167.0.0")).isFalse()
-  }
-
-  @Test
-  fun `malformed addresses are not private`() {
-    for (token in listOf("192.168.1", "192.168.1.1.1", "192.168.1.256", "a.b.c.d", "", "host")) {
-      assertThat(SoftApSdpGuard.isPrivateIpv4(token)).describedAs(token).isFalse()
-    }
-  }
-
-  @Test
-  fun `a candidate must be typ host to count`() {
-    assertThat(SoftApSdpGuard.isSoftApHostCandidate(hostCandidate.removePrefix("a="))).isTrue()
-    assertThat(
-      SoftApSdpGuard.isSoftApHostCandidate(
-        "candidate:1 1 udp 2122260223 192.168.43.20 51234 typ relay",
-      ),
-    ).isFalse()
-  }
-
-  @Test
-  fun `the candidate address is read positionally, with or without the a= prefix`() {
-    assertThat(SoftApSdpGuard.candidateAddress(hostCandidate)).isEqualTo("192.168.43.20")
-    assertThat(
-      SoftApSdpGuard.candidateAddress(
-        "candidate:3558496604 1 udp 2122260223 10.48.51.202 35664 typ host generation 0",
-      ),
-    ).isEqualTo("10.48.51.202")
-  }
-
-  /** `raddr` would win a scan for anything dotted-quad-shaped and blame the wrong interface. */
-  @Test
-  fun `a reflexive candidate reports its local address, not its raddr`() {
-    assertThat(
-      SoftApSdpGuard.candidateAddress(
-        "candidate:2 1 udp 1686052607 203.0.113.9 44444 typ srflx raddr 192.168.43.20 rport 51234",
-      ),
-    ).isEqualTo("203.0.113.9")
-  }
-
-  @Test
-  fun `a line without an address reports none rather than a stray token`() {
-    assertThat(SoftApSdpGuard.candidateAddress("a=mid:0")).isNull()
-    assertThat(SoftApSdpGuard.candidateAddress("")).isNull()
-  }
-
-  // -----------------------------------------------------------------
-  // Pinning a cellular-substituted host address back onto the hotspot
-  // -----------------------------------------------------------------
-
-  @Test
-  fun `a cellular host address is rewritten to the scoped SoftAP address`() {
-    val prefix = Ipv4Prefix("192.168.43.79", 24)
-    val original =
-      sdp("a=candidate:1 1 udp 2122260223 10.48.51.202 35664 typ host generation 0")
-
-    val pinned = SoftApSdpGuard.pinHostAddresses(original, "192.168.43.79", prefix)
-
-    assertThat(pinned.rewritten).containsExactly("10.48.51.202")
-    assertThat(pinned.sdp).contains("192.168.43.79 35664 typ host")
-    assertThat(pinned.sdp).doesNotContain("10.48.51.202")
-    assertThat(SoftApSdpGuard.inspect(pinned.sdp, prefix)).isInstanceOf(SoftApSdpGuard.Verdict.Ok::class.java)
-  }
-
-  @Test
-  fun `a host address already on the hotspot is left alone`() {
-    val prefix = Ipv4Prefix("192.168.43.79", 24)
-    val original = sdp(hostCandidate)
-
-    val pinned = SoftApSdpGuard.pinHostAddresses(original, "192.168.43.79", prefix)
-
-    assertThat(pinned.rewritten).isEmpty()
-    assertThat(pinned.sdp).isEqualTo(original)
-  }
-
-  @Test
-  fun `a reflexive raddr is not treated as the connection address to pin`() {
-    // Field 5 is 203.0.113.7; raddr is already the hotspot. Rewriting raddr would hide a srflx
-    // that ICE could still select, and would not fix the address the glasses send to.
-    val prefix = Ipv4Prefix("192.168.43.79", 24)
-    val original = sdp(srflxCandidate)
-
-    val pinned = SoftApSdpGuard.pinHostAddresses(original, "192.168.43.79", prefix)
-
-    assertThat(pinned.rewritten).isEmpty()
-    assertThat(pinned.sdp).contains("203.0.113.7")
-    assertThat(pinned.sdp).contains("raddr 192.168.43.20")
-  }
-}

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

@@ -1,193 +0,0 @@
-package com.mentra.acsmeeting.source
-
-import com.mentra.acsmeeting.telemetry.ChromaProbe
-import com.mentra.acsmeeting.video.I420Packer
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-import java.nio.ByteBuffer
-
-class SyntheticFrameFactoryTest {
-  @Test
-  fun packedLengthMatchesI420() {
-    val dest = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory().write(dest, WIDTH, HEIGHT, 0)
-    assertThat(dest.remaining()).isEqualTo(I420Packer.packedSize(WIDTH, HEIGHT))
-  }
-
-  /**
-   * Regression for the 1.4 fps wire collapse: a noisy CHEAP background is
-   * incompressible and starves the ACS encoder. CHEAP must stay flat.
-   */
-  @Test
-  fun cheapBackgroundStaysCompressible() {
-    val dest = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(dest, WIDTH, HEIGHT, 0)
-    val y = yBytes(dest)
-    var background = 0
-    for (row in HEIGHT - 40 until HEIGHT) {
-      val rowOff = row * WIDTH
-      for (col in 0 until WIDTH) {
-        if (y[rowOff + col] == SyntheticFrameFactory.BG_Y) background += 1
-      }
-    }
-    assertThat(background).isGreaterThan(30 * WIDTH)
-  }
-
-  @Test
-  fun consecutiveCheapFramesDifferInY() {
-    val a = buffer(WIDTH, HEIGHT)
-    val b = buffer(WIDTH, HEIGHT)
-    val factory = SyntheticFrameFactory(SyntheticEntropy.CHEAP)
-    factory.write(a, WIDTH, HEIGHT, 0)
-    factory.write(b, WIDTH, HEIGHT, 1)
-    assertThat(yBytes(a)).isNotEqualTo(yBytes(b))
-  }
-
-  @Test
-  fun cheapIsDeterministicForAGivenIndex() {
-    val a = buffer(WIDTH, HEIGHT)
-    val b = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(a, WIDTH, HEIGHT, 7)
-    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(b, WIDTH, HEIGHT, 7)
-    assertThat(copy(a)).isEqualTo(copy(b))
-  }
-
-  @Test
-  fun incrementalCheapMatchesFreshWrite() {
-    val stepped = buffer(WIDTH, HEIGHT)
-    val fresh = buffer(WIDTH, HEIGHT)
-    val factory = SyntheticFrameFactory(SyntheticEntropy.CHEAP)
-    factory.write(stepped, WIDTH, HEIGHT, 0)
-    factory.write(stepped, WIDTH, HEIGHT, 1)
-    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(fresh, WIDTH, HEIGHT, 1)
-    assertThat(copy(stepped)).isEqualTo(copy(fresh))
-  }
-
-  @Test
-  fun chromaAveragesLandAt128() {
-    for (entropy in SyntheticEntropy.entries) {
-      val dest = buffer(WIDTH, HEIGHT)
-      SyntheticFrameFactory(entropy).write(dest, WIDTH, HEIGHT, 3)
-      val sample = ChromaProbe.samplePacked(dest, WIDTH, HEIGHT)
-      assertThat(sample.u).isEqualTo(128)
-      assertThat(sample.v).isEqualTo(128)
-    }
-  }
-
-  @Test
-  fun motionPansAlmostEveryPixel() {
-    val a = buffer(WIDTH, HEIGHT)
-    val b = buffer(WIDTH, HEIGHT)
-    val factory = SyntheticFrameFactory(SyntheticEntropy.MOTION)
-    factory.write(a, WIDTH, HEIGHT, 0)
-    factory.write(b, WIDTH, HEIGHT, 1)
-    val ya = yBytes(a)
-    val yb = yBytes(b)
-    var differ = 0
-    for (i in ya.indices) if (ya[i] != yb[i]) differ += 1
-    assertThat(differ).isGreaterThan(ya.size / 2)
-  }
-
-  /**
-   * Glasses motion still has neighbors that look alike. A 32×32 patch in the
-   * corner must stay a gradient, not snow — that is what lets an I-frame fit
-   * the bitrate budget.
-   */
-  @Test
-  fun motionKeepsSpatialStructure() {
-    val dest = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory(SyntheticEntropy.MOTION).write(dest, WIDTH, HEIGHT, 0)
-    val y = yBytes(dest)
-    val unique = mutableSetOf<Byte>()
-    for (row in HEIGHT - 80 until HEIGHT - 48) {
-      val rowOff = row * WIDTH
-      for (col in 0 until 32) unique.add(y[rowOff + col])
-    }
-    assertThat(unique.size).isLessThan(40)
-  }
-
-  @Test
-  fun motionIsDeterministicForAGivenIndex() {
-    val a = buffer(WIDTH, HEIGHT)
-    val b = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory(SyntheticEntropy.MOTION).write(a, WIDTH, HEIGHT, 11)
-    SyntheticFrameFactory(SyntheticEntropy.MOTION).write(b, WIDTH, HEIGHT, 11)
-    assertThat(copy(a)).isEqualTo(copy(b))
-  }
-
-  @Test
-  fun noiseRewritesTheFullYPlane() {
-    val a = buffer(WIDTH, HEIGHT)
-    val b = buffer(WIDTH, HEIGHT)
-    val factory = SyntheticFrameFactory(SyntheticEntropy.NOISE)
-    factory.write(a, WIDTH, HEIGHT, 0)
-    factory.write(b, WIDTH, HEIGHT, 1)
-    val ya = yBytes(a)
-    val yb = yBytes(b)
-    var differ = 0
-    for (i in ya.indices) if (ya[i] != yb[i]) differ += 1
-    assertThat(differ).isGreaterThan(ya.size / 2)
-  }
-
-  @Test
-  fun stampPaintsFrameIdAndFpsOnADarkBox() {
-    val dest = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(dest, WIDTH, HEIGHT, 42, 15.0)
-    val y = yBytes(dest)
-    val boxX = WIDTH / 16
-    val boxY = HEIGHT / 2 - 80
-    var dark = 0
-    var bright = 0
-    for (row in boxY until boxY + 160) {
-      val rowOff = row * WIDTH
-      for (col in boxX until boxX + 400) {
-        val value = y[rowOff + col].toInt() and 0xFF
-        if (value <= 20) dark += 1
-        if (value >= 220) bright += 1
-      }
-    }
-    assertThat(dark).isGreaterThan(1_000)
-    assertThat(bright).isGreaterThan(200)
-  }
-
-  @Test
-  fun stampFrameIndexChangesTheOverlay() {
-    val a = buffer(WIDTH, HEIGHT)
-    val b = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(a, WIDTH, HEIGHT, 1, 15.0)
-    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(b, WIDTH, HEIGHT, 2, 15.0)
-    assertThat(copy(a)).isNotEqualTo(copy(b))
-  }
-
-  @Test
-  fun noiseIsDeterministicForAGivenIndex() {
-    val a = buffer(WIDTH, HEIGHT)
-    val b = buffer(WIDTH, HEIGHT)
-    SyntheticFrameFactory(SyntheticEntropy.NOISE).write(a, WIDTH, HEIGHT, 11)
-    SyntheticFrameFactory(SyntheticEntropy.NOISE).write(b, WIDTH, HEIGHT, 11)
-    assertThat(copy(a)).isEqualTo(copy(b))
-  }
-
-  private fun buffer(width: Int, height: Int): ByteBuffer =
-    ByteBuffer.allocate(I420Packer.packedSize(width, height))
-
-  private fun yBytes(src: ByteBuffer): ByteArray {
-    val view = src.duplicate()
-    view.position(0)
-    val y = ByteArray(WIDTH * HEIGHT)
-    view.get(y)
-    return y
-  }
-
-  private fun copy(src: ByteBuffer): ByteArray {
-    val view = src.duplicate()
-    val out = ByteArray(view.remaining())
-    view.get(out)
-    return out
-  }
-
-  companion object {
-    private const val WIDTH = 1280
-    private const val HEIGHT = 720
-  }
-}

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

@@ -1,176 +0,0 @@
-package com.mentra.acsmeeting.source
-
-import com.mentra.acsmeeting.telemetry.PipelineStats
-import com.mentra.acsmeeting.video.I420Packer
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-import java.util.concurrent.atomic.AtomicBoolean
-
-class SyntheticI420SourceTest {
-  @Test
-  fun withheldWhileNotReadyThenEmitsOnceReady() {
-    val ready = AtomicBoolean(false)
-    val frames = ArrayList<Triple<Int, Int, Int>>()
-    val stats = PipelineStats()
-    val source = source(stats, ready) { planes ->
-      frames.add(Triple(I420Planes.remaining(planes.y) + I420Planes.remaining(planes.u) + I420Planes.remaining(planes.v), planes.width, planes.height))
-    }
-    source.becomeLive()
-    source.setTargetSize(TargetSize(1280, 720))
-
-    assertThat(source.emitOnce()).isFalse()
-    assertThat(frames).isEmpty()
-    assertThat(stats.sinkCount()).isEqualTo(0)
-
-    ready.set(true)
-    assertThat(source.emitOnce()).isTrue()
-    assertThat(frames).hasSize(1)
-    assertThat(frames[0].second).isEqualTo(1280)
-    assertThat(frames[0].third).isEqualTo(720)
-    assertThat(frames[0].first).isEqualTo(I420Packer.packedSize(1280, 720))
-    assertThat(stats.sinkCount()).isEqualTo(1)
-    assertThat(source.events.any { it.startsWith("P6 synthetic first-frame") }).isTrue()
-  }
-
-  @Test
-  fun withheldWhileTargetSizeIsNull() {
-    val frames = ArrayList<Int>()
-    val stats = PipelineStats()
-    val source = source(stats, AtomicBoolean(true)) { _ -> frames.add(1) }
-    source.becomeLive()
-
-    assertThat(source.emitOnce()).isFalse()
-    assertThat(frames).isEmpty()
-    assertThat(stats.sinkCount()).isEqualTo(0)
-
-    source.setTargetSize(TargetSize(640, 360))
-    assertThat(source.emitOnce()).isTrue()
-    assertThat(frames).hasSize(1)
-  }
-
-  @Test
-  fun nReadyCallsDeliverNFramesAndHonorResize() {
-    val frames = ArrayList<Pair<Int, Int>>()
-    val stats = PipelineStats()
-    val source = source(stats, AtomicBoolean(true)) { planes -> frames.add(planes.width to planes.height) }
-    source.becomeLive()
-    source.setTargetSize(TargetSize(1280, 720))
-    repeat(4) { source.emitOnce() }
-    source.setTargetSize(TargetSize(640, 360))
-    source.emitOnce()
-
-    assertThat(frames).containsExactly(
-      1280 to 720,
-      1280 to 720,
-      1280 to 720,
-      1280 to 720,
-      640 to 360,
-    )
-    assertThat(stats.sinkCount()).isEqualTo(5)
-  }
-
-  @Test
-  fun withheldTicksTouchNoCounters() {
-    val stats = PipelineStats()
-    val source = source(stats, AtomicBoolean(false)) { _ -> }
-    source.becomeLive()
-    source.setTargetSize(TargetSize(1280, 720))
-    repeat(5) { source.emitOnce() }
-    assertThat(stats.sinkCount()).isEqualTo(0)
-    assertThat(stats.dropCount()).isEqualTo(0)
-    assertThat(stats.subCount()).isEqualTo(0)
-    assertThat(stats.pack.p95()).isEqualTo("na")
-  }
-
-  @Test
-  fun readinessFlapProducesOnePauseAndOneResume() {
-    val ready = AtomicBoolean(true)
-    val source = source(PipelineStats(), ready) { _ -> }
-    source.becomeLive()
-    source.setTargetSize(TargetSize(1280, 720))
-    source.emitOnce()
-    ready.set(false)
-    source.emitOnce()
-    ready.set(true)
-    source.emitOnce()
-
-    val pauses = source.events.filter { it.contains("paused") }
-    val resumes = source.events.filter { it.contains("resumed") }
-    assertThat(pauses).hasSize(1)
-    assertThat(resumes).hasSize(1)
-  }
-
-  @Test
-  fun stopEmitsNothingAndRestartResetsIndex() {
-    val indexes = ArrayList<Int>()
-    val ready = AtomicBoolean(true)
-    val source = source(PipelineStats(), ready) { planes ->
-      indexes.add(yCorner(planes))
-    }
-    source.becomeLive()
-    source.setTargetSize(TargetSize(64, 64))
-    source.emitOnce()
-    source.emitOnce()
-    source.stop()
-    assertThat(source.state).isEqualTo(SourceState.IDLE)
-    assertThat(source.emitOnce()).isFalse()
-
-    source.becomeLive()
-    source.setTargetSize(TargetSize(64, 64))
-    source.emitOnce()
-    assertThat(indexes).hasSize(3)
-    assertThat(indexes[0]).isEqualTo(indexes[2])
-  }
-
-  @Test
-  fun restartLeavesSourceLive() {
-    val source = source(PipelineStats(), AtomicBoolean(false)) { _ -> }
-    source.start(SourceConfig("ignored", SourceKind.DIRECT))
-    source.restart(SourceConfig("ignored-2", SourceKind.DIRECT))
-    assertThat(source.state).isEqualTo(SourceState.LIVE)
-    source.stop()
-    assertThat(source.state).isEqualTo(SourceState.IDLE)
-  }
-
-  @Test
-  fun pcmListenerIsNeverInvoked() {
-    val source = SyntheticI420Source(
-      video = { _ -> },
-      stats = PipelineStats(),
-      isReady = { true },
-    )
-    source.setPcmDeliveryEnabled(true)
-    assertThat(source.pcmDeliveryEnabled()).isTrue()
-    source.setPcmDeliveryEnabled(false)
-    assertThat(source.pcmDeliveryEnabled()).isFalse()
-  }
-
-  private fun source(
-    stats: PipelineStats,
-    ready: AtomicBoolean,
-    video: VideoFrameListener,
-  ): SyntheticI420Source = SyntheticI420Source(
-    video = video,
-    stats = stats,
-    isReady = { ready.get() },
-  )
-
-  @Test
-  fun emitsTightStridePlanesAliasingThePackedBuffer() {
-    val seen = ArrayList<I420Planes>()
-    val source = source(PipelineStats(), AtomicBoolean(true)) { seen.add(it) }
-    source.becomeLive()
-    source.setTargetSize(TargetSize(64, 64))
-    assertThat(source.emitOnce()).isTrue()
-    val planes = seen.single()
-    assertThat(planes.isTight()).isTrue()
-    assertThat(planes.retain == null).isTrue()
-    assertThat(planes.release == null).isTrue()
-    assertThat(I420Planes.remaining(planes.y)).isEqualTo(64 * 64)
-    assertThat(I420Planes.remaining(planes.u)).isEqualTo(32 * 32)
-  }
-
-  private fun yCorner(planes: I420Planes): Int {
-    return planes.y.duplicate().get(0).toInt() and 0xFF
-  }
-}

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

@@ -1,45 +0,0 @@
-package com.mentra.acsmeeting.source
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-class TrackRegistryTest {
-  @Test
-  fun threeClaimsOfOneIdYieldTrueFalseFalse() {
-    val registry = TrackRegistry()
-    assertThat(registry.claim("track-a")).isTrue()
-    assertThat(registry.claim("track-a")).isFalse()
-    assertThat(registry.claim("track-a")).isFalse()
-    assertThat(registry.size()).isEqualTo(1)
-    assertThat(registry.skipped()).isEqualTo(2)
-  }
-
-  @Test
-  fun distinctIdsEachClaimOnce() {
-    val registry = TrackRegistry()
-    assertThat(registry.claim("video")).isTrue()
-    assertThat(registry.claim("audio")).isTrue()
-    assertThat(registry.size()).isEqualTo(2)
-    assertThat(registry.skipped()).isEqualTo(0)
-  }
-
-  @Test
-  fun resetMakesTheSameIdClaimableAgain() {
-    val registry = TrackRegistry()
-    assertThat(registry.claim("track-a")).isTrue()
-    registry.reset()
-    assertThat(registry.size()).isEqualTo(0)
-    assertThat(registry.skipped()).isEqualTo(0)
-    assertThat(registry.claim("track-a")).isTrue()
-    assertThat(registry.size()).isEqualTo(1)
-  }
-
-  @Test
-  fun softapWhipReconnectCanReclaimVideo0() {
-    val registry = TrackRegistry()
-    assertThat(registry.claim("video0")).isTrue()
-    assertThat(registry.claim("video0")).isFalse()
-    registry.reset()
-    assertThat(registry.claim("video0")).isTrue()
-  }
-}