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

package/android/src/test/java/com/mentra/acsmeeting/telemetry/PipelineStatsTest.kt

@@ -1,322 +0,0 @@
-package com.mentra.acsmeeting.telemetry
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-class PipelineStatsTest {
-  @Test
-  fun conservationHoldsAcrossEveryDisposition() {
-    val stats = PipelineStats()
-    repeat(5) { stats.onSink() }
-    stats.onQueued(); stats.onSub()
-    stats.onDropSize()
-    stats.onDropBusy()
-    stats.onDropNullI420()
-    stats.onDropPaced()
-    assertThat(stats.conserved()).isTrue()
-    assertThat(stats.sinkCount()).isEqualTo(5)
-    assertThat(stats.subCount()).isEqualTo(1)
-    assertThat(stats.dropCount()).isEqualTo(4)
-    assertThat(stats.inFlightCount()).isEqualTo(0)
-  }
-
-  @Test
-  fun latencyStraddleIsOneHundredPercentOverTenTicks() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    val ticks = ArrayList<String>()
-    stats.onSink()
-    stats.onQueued()
-    clock += 1000
-    ticks.add(stats.tick())
-    stats.onSub()
-    repeat(9) {
-      clock += 1000
-      ticks.add(stats.tick())
-    }
-    assertThat(stats.subCount()).isEqualTo(stats.sinkCount())
-    assertThat(stats.conserved()).isTrue()
-    val last = ticks.last()
-    assertThat(last).contains("cum{sink=1 sub=1 drop=0 inFlight=0}")
-    assertThat(last).doesNotContain("CONSERVE_FAIL")
-  }
-
-  @Test
-  fun cumulativeCountersNeverDecrease() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    stats.onSink(); stats.onQueued(); stats.onSub()
-    clock += 1000
-    val first = stats.tick()
-    clock += 1000
-    val idle = stats.tick()
-    assertThat(extractCum(first)).isEqualTo(extractCum(idle))
-    assertThat(stats.sinkCount()).isEqualTo(1)
-    assertThat(stats.subCount()).isEqualTo(1)
-  }
-
-  @Test
-  fun idleTickStillEmitsSinkZero() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    clock += 1000
-    val line = stats.tick()
-    assertThat(line).startsWith("P6 ladder")
-    assertThat(line).contains("sink=0.0")
-    assertThat(line).contains("dec=na")
-    assertThat(line).contains("wire=0x0@na kbps=na codec=na")
-    assertThat(line).contains("drop{")
-    assertThat(line).contains("pace=0")
-    assertThat(line).contains("ms{")
-    assertThat(line).contains("chroma{")
-    assertThat(line).contains("cum{sink=0 sub=0 drop=0 inFlight=0}")
-  }
-
-  @Test
-  fun queuedFrameCountsAsInFlightUntilSettled() {
-    val stats = PipelineStats()
-    stats.onSink()
-    stats.onQueued()
-    assertThat(stats.conserved()).isTrue()
-    assertThat(stats.inFlightCount()).isEqualTo(1)
-    stats.onSub()
-    assertThat(stats.inFlightCount()).isEqualTo(0)
-    assertThat(stats.conserved()).isTrue()
-  }
-
-  /**
-   * The device logged 14 CONSERVE_FAIL lines on a pipeline with zero drops.
-   * Cause was a tracked inFlight counter read mid-settle, not lost frames.
-   */
-  @Test
-  fun concurrentSendsNeverReportConserveFail() {
-    val stats = PipelineStats { 0L }
-    val sender = Thread {
-      repeat(20_000) {
-        stats.onSink()
-        stats.onQueued()
-        stats.onSub()
-      }
-    }
-    val failures = ArrayList<String>()
-    val reader = Thread {
-      repeat(20_000) {
-        if (!stats.conserved()) failures.add("inFlight=${stats.inFlightCount()}")
-      }
-    }
-    sender.start(); reader.start()
-    sender.join(); reader.join()
-    assertThat(failures).isEmpty()
-    assertThat(stats.inFlightCount()).isEqualTo(0)
-    assertThat(stats.tick()).doesNotContain("CONSERVE_FAIL")
-  }
-
-  @Test
-  fun recvHealthReportsDeltasNotAbsolutes() {
-    val stats = PipelineStats { 0L }
-    assertThat(stats.recvLabel()).isEqualTo("recv{na}")
-    stats.setRecvHealth(
-      PipelineStats.RecvHealth(assembled = 100, dropped = 5, packetsLost = 40, nack = 7, pli = 2, freezes = 1),
-    )
-    assertThat(stats.recvLabel()).contains("drop=5", "lost=40", "nack=7", "pli=2", "freeze=1")
-    stats.setRecvHealth(
-      PipelineStats.RecvHealth(assembled = 115, dropped = 5, packetsLost = 52, nack = 9, pli = 2, freezes = 3),
-    )
-    assertThat(stats.recvLabel()).contains("drop=0", "lost=12", "nack=2", "pli=0", "freeze=2")
-  }
-
-  @Test
-  fun recvHealthAveragesPerFrameTimings() {
-    val stats = PipelineStats { 0L }
-    stats.setRecvHealth(
-      PipelineStats.RecvHealth(
-        assembled = 200,
-        decodeSec = 0.8,
-        jitterBufferSec = 12.0,
-        jitterBufferEmits = 200,
-        jitter = 0.015,
-      ),
-    )
-    val label = stats.recvLabel()
-    assertThat(label).contains("decMs=4.0")
-    assertThat(label).contains("jbMs=60.0")
-    assertThat(label).contains("jit=15.0")
-  }
-
-  @Test
-  fun recvHealthToleratesMissingMembers() {
-    val stats = PipelineStats { 0L }
-    stats.setRecvHealth(PipelineStats.RecvHealth())
-    val label = stats.recvLabel()
-    assertThat(label).contains("drop=na", "lost=na", "decMs=na", "jbMs=na", "decImpl=na")
-    assertThat(stats.tick()).contains("recv{")
-  }
-
-  @Test
-  fun recvHealthPrintsDecoderImplementation() {
-    val stats = PipelineStats { 0L }
-    stats.setRecvHealth(PipelineStats.RecvHealth(decImpl = "OMX.qcom.video.decoder.avc"))
-    assertThat(stats.recvLabel()).contains("decImpl=OMX.qcom.video.decoder.avc")
-  }
-
-  @Test
-  fun ladderIncludesArmLabel() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    clock += 1000
-    assertThat(stats.tick()).contains("arm=whep")
-    stats.arm = "synthetic"
-    clock += 1000
-    assertThat(stats.tick()).contains("arm=synthetic")
-  }
-
-  @Test
-  fun ladderExposesCpuAttributionFields() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    stats.toI420.record(4_000_000)
-    stats.sinkCb.record(8_000_000)
-    stats.split.record(1_000_000)
-    stats.onDestAlloc()
-    stats.onPlaneAlloc()
-    stats.onPlaneAlloc()
-    clock += 1000
-    val line = stats.tick()
-    assertThat(line).contains("i420P95=4.0")
-    assertThat(line).contains("sinkCbP95=8.0")
-    assertThat(line).contains("splitP95=1.0")
-    assertThat(line).contains("alloc{dest=1 plane=2}")
-  }
-
-  @Test
-  fun ladderCarriesPathBufStrideZcAndCopyP95Na() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    clock += 1000
-    val idle = stats.tick()
-    assertThat(idle).contains("path{mode=texture copy=packsplit pix=i420}")
-    assertThat(idle).contains("wire=0x0@na kbps=na codec=na")
-    assertThat(idle).contains("buf{tex=0 i420=0 other=0}")
-    assertThat(idle).contains("stride{y=0 u=0 v=0 tight=0 padded=0}")
-    assertThat(idle).contains("zc{on=0 used=0 fell=0 padded=0 heldMax=0 timeout=0}")
-    assertThat(idle).contains("copyP95=na")
-
-    stats.pathMode = "bytebuf"
-    stats.pathCopy = "nv12"
-    stats.pix = "nv12"
-    stats.codecName = "h264 sw"
-    stats.onFrameBuffer("tex")
-    stats.onFrameBuffer("i420")
-    stats.onFrameBuffer("i420")
-    stats.onFrameBuffer("nv12")
-    stats.onStrides(1280, 640, 640, 1280)
-    stats.onStrides(1280, 768, 768, 1280)
-    stats.zcOn = 1
-    stats.onZcUsed(1)
-    stats.onZcUsed(2)
-    stats.onZcFell()
-    stats.onZcPadded()
-    stats.onZcTimeout()
-    stats.copy.record(3_000_000)
-    clock += 1000
-    val line = stats.tick()
-    assertThat(line).contains("path{mode=bytebuf copy=nv12 pix=nv12}")
-    assertThat(line).contains("codec=h264_sw")
-    assertThat(line).contains("buf{tex=1 i420=2 other=1}")
-    assertThat(line).contains("stride{y=1280 u=768 v=768 tight=1 padded=1}")
-    assertThat(line).contains("zc{on=1 used=2 fell=1 padded=1 heldMax=2 timeout=1}")
-    assertThat(line).contains("copyP95=3.0")
-  }
-
-  @Test
-  fun ladderPrintsAcsWireGeometryAndBitrate() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    stats.wireWidth = 960
-    stats.wireHeight = 540
-    stats.wireFps = 29.8
-    stats.wireBitrateBps = 1_480_000
-    clock += 1000
-    stats.codecName = "H264SkypeEncoder_HW"
-    assertThat(stats.tick()).contains("wire=960x540@29.8 kbps=1480 codec=H264SkypeEncoder_HW")
-  }
-
-  @Test
-  fun ladderExposesRecvRateSeparateFromDecode() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    stats.recvFps = 14.8
-    stats.decodedFps = 8.1
-    clock += 1000
-    val line = stats.tick()
-    assertThat(line).contains("recv=14.8")
-    assertThat(line).contains("dec=8.1")
-  }
-
-  @Test
-  fun ladderReportsFrameAgeAndEndToEndLatency() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    stats.age.record(40_000_000)
-    stats.e2e.record(95_000_000)
-    clock += 1000
-    val line = stats.tick()
-    assertThat(line).contains("ageP50=40.0")
-    assertThat(line).contains("e2eP50=95.0")
-  }
-
-  /**
-   * A backed-up ACS send thread has no other symptom on this ladder: `sendP95` times the ACS call
-   * itself, so the wait in front of it has to be its own measurement.
-   */
-  @Test
-  fun ladderSeparatesSenderQueueWaitFromTheAcsCall() {
-    var clock = 0L
-    val stats = PipelineStats { clock }
-    stats.queue.record(30_000_000)
-    stats.send.record(2_000_000)
-    clock += 1000
-    val line = stats.tick()
-    assertThat(line).contains("queueP95=30.0")
-    assertThat(line).contains("sendP95=2.0")
-  }
-
-  @Test
-  fun slowestStageNamesTheWorstPhoneSideStage() {
-    val stats = PipelineStats { 0 }
-    stats.scale.record(2_000_000)
-    stats.toI420.record(9_000_000)
-    stats.copy.record(1_000_000)
-    stats.send.record(12_000_000)
-    assertThat(stats.slowestStage()).isEqualTo("send=12.0")
-  }
-
-  /** Ranking must compare numbers: as strings "9.0" sorts above "12.0". */
-  @Test
-  fun slowestStageRanksNumericallyNotLexically() {
-    val stats = PipelineStats { 0 }
-    stats.toI420.record(9_000_000)
-    stats.copy.record(12_000_000)
-    assertThat(stats.slowestStage()).isEqualTo("copy=12.0")
-  }
-
-  /**
-   * Frame age is dominated by capture, encode and the network, so blaming a phone-side stage for it
-   * would make every healthy call accuse a stage this device does not run.
-   */
-  @Test
-  fun slowestStageIgnoresUpstreamFrameAge() {
-    val stats = PipelineStats { 0 }
-    stats.age.record(400_000_000)
-    stats.copy.record(3_000_000)
-    assertThat(stats.slowestStage()).isEqualTo("copy=3.0")
-  }
-
-  @Test
-  fun slowestStageIsNotAvailableBeforeAnySamples() {
-    assertThat(PipelineStats { 0 }.slowestStage()).isEqualTo("na")
-  }
-
-  private fun extractCum(line: String): String =
-    Regex("""cum\{[^}]+\}""").find(line)?.value ?: line
-}

package/android/src/test/java/com/mentra/acsmeeting/telemetry/ProcessCpuTest.kt

@@ -1,18 +0,0 @@
-package com.mentra.acsmeeting.telemetry
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-class ProcessCpuTest {
-  @Test
-  fun percentMatchesTopStyleOverOneSecond() {
-    assertThat(ProcessCpu.percent(cpuDeltaMs = 1120, wallDeltaMs = 1000)).isEqualTo(112.0)
-    assertThat(ProcessCpu.percent(cpuDeltaMs = 200, wallDeltaMs = 1000)).isEqualTo(20.0)
-  }
-
-  @Test
-  fun labelFormatsNaUntilFirstSample() {
-    assertThat(ProcessCpu.label(null, 8)).isEqualTo("cpu{proc=na cores=8}")
-    assertThat(ProcessCpu.label(112.4, 8)).isEqualTo("cpu{proc=112.4 cores=8}")
-  }
-}

package/android/src/test/java/com/mentra/acsmeeting/telemetry/RingPercentileTest.kt

@@ -1,49 +0,0 @@
-package com.mentra.acsmeeting.telemetry
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.Executors
-import java.util.concurrent.TimeUnit
-
-class RingPercentileTest {
-  @Test
-  fun emptyIsNa() {
-    assertThat(RingPercentile().p50()).isEqualTo("na")
-    assertThat(RingPercentile().p95()).isEqualTo("na")
-  }
-
-  @Test
-  fun knownInputs() {
-    val ring = RingPercentile(8)
-    ring.record(10_000_000)
-    ring.record(20_000_000)
-    ring.record(40_000_000)
-    assertThat(ring.p50()).isEqualTo("20.0")
-  }
-
-  @Test
-  fun wraparoundKeepsNewest() {
-    val ring = RingPercentile(3)
-    repeat(6) { index -> ring.record((index + 1) * 1_000_000L) }
-    assertThat(ring.size()).isEqualTo(3)
-    assertThat(ring.p50()).isEqualTo("5.0")
-  }
-
-  @Test
-  fun concurrentRecordDoesNotCorruptCount() {
-    val ring = RingPercentile(32)
-    val pool = Executors.newFixedThreadPool(4)
-    val latch = CountDownLatch(4)
-    repeat(4) {
-      pool.execute {
-        repeat(50) { ring.record(1_000_000) }
-        latch.countDown()
-      }
-    }
-    assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue()
-    pool.shutdown()
-    assertThat(ring.size()).isEqualTo(32)
-    assertThat(ring.p50()).isNotEqualTo("na")
-  }
-}

package/android/src/test/java/com/mentra/acsmeeting/telemetry/VideoRateVerdictTest.kt

@@ -1,149 +0,0 @@
-package com.mentra.acsmeeting.telemetry
-
-import com.mentra.acsmeeting.telemetry.VideoRateVerdict.Bound
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-class VideoRateVerdictTest {
-  /** 540p15 against a starved 1.5 Mbps budget — the grant Mentra Call used to send. */
-  private fun verdict(
-    advertisedFps: Double = 15.0,
-    sinkFps: Double = 15.0,
-    admittedFps: Double = 15.0,
-    wireFps: Double? = 15.0,
-    wireBitrateBps: Long? = 1_400_000,
-    budgetBps: Int = 1_500_000,
-    cpuPercent: Double? = 55.0,
-  ) = VideoRateVerdict.of(
-    advertisedFps = advertisedFps,
-    sinkFps = sinkFps,
-    admittedFps = admittedFps,
-    wireFps = wireFps,
-    wireBitrateBps = wireBitrateBps,
-    budgetBps = budgetBps,
-    cpuPercent = cpuPercent,
-  )
-
-  @Test
-  fun aWireHoldingTheAdvertisedRateIsOk() {
-    assertThat(verdict()).isEqualTo(Bound.OK)
-  }
-
-  /**
-   * The verdict that decides whether "the call quality is low" is answered by raising the grant.
-   * Every frame is on the wire, so nothing here is short — but the bits are pressed against the
-   * ceiling, which is the one condition under which a bigger number changes the picture. Without
-   * this the same tick reads OK and the ceiling never enters the conversation.
-   */
-  @Test
-  fun aFullRateRidingTheCeilingIsNamedAsCapBound() {
-    assertThat(verdict(wireBitrateBps = 1_480_000)).isEqualTo(Bound.CAP_BOUND)
-    // The controller routinely overshoots the grant; that is still the ceiling binding.
-    assertThat(verdict(wireBitrateBps = 1_623_000)).isEqualTo(Bound.CAP_BOUND)
-  }
-
-  /** Headroom under the grant at a full rate is a healthy stream, not a ceiling problem. */
-  @Test
-  fun aFullRateWithBitsToSpareIsStillPlainOk() {
-    assertThat(verdict(wireBitrateBps = 1_100_000)).isEqualTo(Bound.OK)
-    assertThat(verdict(wireBitrateBps = null)).isEqualTo(Bound.OK)
-  }
-
-  /**
-   * Cap-bound is about the ceiling, and a short frame rate means something else is wrong first.
-   * Raising the grant for a stream that cannot fill the one it has buys nothing.
-   */
-  @Test
-  fun aShortRateIsDiagnosedBeforeTheCeilingIsConsidered() {
-    assertThat(verdict(wireFps = 8.0, wireBitrateBps = 1_480_000, cpuPercent = 92.0))
-      .isEqualTo(Bound.ENCODER_SHORT)
-  }
-
-  /**
-   * The exact shape of the greedy-gate bug: the glasses supplied 14.6 fps, the
-   * pacer admitted 7.3 against an advertised 8, and every counter downstream
-   * looked like an encoder problem. It was ours.
-   */
-  @Test
-  fun aGateThatDropsFramesTheSourceSuppliedIsBlamedOnThePacer() {
-    assertThat(verdict(advertisedFps = 8.0, sinkFps = 14.6, admittedFps = 7.3, wireFps = 7.0))
-      .isEqualTo(Bound.PACER_SHORT)
-  }
-
-  @Test
-  fun aShortSourceIsNotBlamedOnAnythingDownstream() {
-    assertThat(verdict(sinkFps = 6.0, admittedFps = 6.0, wireFps = 6.0))
-      .isEqualTo(Bound.SOURCE_SHORT)
-  }
-
-  /**
-   * A source a little under the advertise is not the pacer's fault. Scoring the
-   * gate against the advertise alone would read every slightly slow glasses leg
-   * as our own bug and send the next fix to the wrong place.
-   */
-  @Test
-  fun thePacerIsNotBlamedForFramesTheSourceNeverSent() {
-    assertThat(verdict(sinkFps = 13.0, admittedFps = 13.0, wireFps = 13.0))
-      .isEqualTo(Bound.OK)
-  }
-
-  /**
-   * The two verdicts that matter, because they want opposite fixes. Same short
-   * wire rate, same delivered rate; only CPU and the bitrate headroom differ.
-   */
-  @Test
-  fun aBusyCpuMeansTheEncoderIsTheCeiling() {
-    assertThat(verdict(wireFps = 8.0, cpuPercent = 92.0)).isEqualTo(Bound.ENCODER_SHORT)
-  }
-
-  @Test
-  fun sparecpuAndACollapsedBitrateMeansTheRateControllerIsThrottling() {
-    assertThat(verdict(wireFps = 8.0, wireBitrateBps = 496_000, cpuPercent = 50.0))
-      .isEqualTo(Bound.BITRATE_STARVED)
-  }
-
-  /** Spare CPU but the budget is being spent: the encoder really is the limit. */
-  @Test
-  fun sparecpuWithTheBudgetSpentIsStillTheEncoder() {
-    assertThat(verdict(wireFps = 8.0, wireBitrateBps = 1_450_000, cpuPercent = 50.0))
-      .isEqualTo(Bound.ENCODER_SHORT)
-  }
-
-  @Test
-  fun aMissingWireReportIsNotAVerdict() {
-    assertThat(verdict(wireFps = null)).isEqualTo(Bound.UNKNOWN)
-    assertThat(verdict(advertisedFps = 0.0)).isEqualTo(Bound.UNKNOWN)
-  }
-
-  /** Every bound carries an action, or the line makes the reader open this file. */
-  @Test
-  fun everyBoundHasANonEmptyHint() {
-    for (bound in Bound.entries) {
-      assertThat(VideoRateVerdict.hint(bound)).isNotBlank()
-    }
-  }
-
-  @Test
-  fun theLinePrintsTheInputsBesideTheVerdict() {
-    val line = VideoRateVerdict.line(
-      advertisedFps = 15.0,
-      sinkFps = 14.6,
-      admittedFps = 7.3,
-      wireFps = 7.0,
-      wireBitrateBps = 496_000,
-      budgetBps = 1_500_000,
-      cpuPercent = 61.3,
-      codecName = "h264 sw",
-    )
-    assertThat(line).startsWith("P7 rate bound=PACER_SHORT")
-    assertThat(line).contains("advertised=15.0")
-    assertThat(line).contains("sink=14.6")
-    assertThat(line).contains("admitted=7.3")
-    assertThat(line).contains("wire=7.0")
-    assertThat(line).contains("kbps=496")
-    assertThat(line).contains("budgetKbps=1500")
-    assertThat(line).contains("cpu=61.3")
-    assertThat(line).contains("codec=h264_sw")
-    assertThat(line).contains(VideoRateVerdict.hint(Bound.PACER_SHORT))
-  }
-}

package/android/src/test/java/com/mentra/acsmeeting/trace/SoftApTraceTest.kt

@@ -1,97 +0,0 @@
-package com.mentra.acsmeeting.trace
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-/**
- * Covers the pure formatter. The `Log.i` wrapper is a one-liner and is exercised on device.
- */
-class SoftApTraceTest {
-
-    @Test
-    fun `format carries the grep marker`() {
-        assertThat(SoftApTrace.format("t1", "scoped_network_available", 12))
-            .contains("SOFTAP_TRACE")
-    }
-
-    @Test
-    fun `format includes traceId stage and elapsed`() {
-        assertThat(SoftApTrace.format("abc123", "ice_selected_pair", 450))
-            .isEqualTo("[SOFTAP_TRACE] traceId=abc123 stage=ice_selected_pair elapsedMs=450")
-    }
-
-    @Test
-    fun `format omits traceId when absent`() {
-        assertThat(SoftApTrace.format("", "boot", 0))
-            .isEqualTo("[SOFTAP_TRACE] stage=boot elapsedMs=0")
-    }
-
-    @Test
-    fun `format appends fields in order`() {
-        assertThat(SoftApTrace.format("t", "whip_request", 7, "method" to "POST", "status" to 201))
-            .endsWith("method=POST status=201")
-    }
-
-    @Test
-    fun `sanitize redacts the hotspot password`() {
-        assertThat(SoftApTrace.sanitize("password", "hunter2")).isEqualTo("<redacted>")
-        assertThat(SoftApTrace.sanitize("hotspotPassword", "hunter2")).isEqualTo("<redacted>")
-        assertThat(SoftApTrace.sanitize("psk", "hunter2")).isEqualTo("<redacted>")
-        assertThat(SoftApTrace.sanitize("passphrase", "hunter2")).isEqualTo("<redacted>")
-    }
-
-    @Test
-    fun `sanitize redacts tokens and credentials`() {
-        assertThat(SoftApTrace.sanitize("token", "eyJhbGciOi")).isEqualTo("<redacted>")
-        assertThat(SoftApTrace.sanitize("acsToken", "eyJhbGciOi")).isEqualTo("<redacted>")
-        assertThat(SoftApTrace.sanitize("Authorization", "Bearer x")).isEqualTo("<redacted>")
-        assertThat(SoftApTrace.sanitize("meetingUrl", "https://teams.microsoft.com/l/x"))
-            .isEqualTo("<redacted>")
-    }
-
-    @Test
-    fun `format never leaks a secret value into the line`() {
-        val line = SoftApTrace.format(
-            "t", "hotspot_started", 5,
-            "ssid" to "MentraLive", "password" to "hunter2",
-        )
-        assertThat(line).doesNotContain("hunter2")
-        assertThat(line).contains("ssid=MentraLive")
-        assertThat(line).contains("password=<redacted>")
-    }
-
-    @Test
-    fun `sanitize keeps the local whip url which is diagnostic`() {
-        assertThat(SoftApTrace.sanitize("whipUrl", "http://192.168.43.20:8790/whip/abc"))
-            .isEqualTo("http://192.168.43.20:8790/whip/abc")
-    }
-
-    @Test
-    fun `sanitize strips query strings that may carry tokens`() {
-        assertThat(SoftApTrace.sanitize("playbackUrl", "https://example.com/live?token=secret123"))
-            .isEqualTo("https://example.com/live?<redacted>")
-    }
-
-    @Test
-    fun `sanitize strips userinfo from urls`() {
-        val result = SoftApTrace.sanitize("endpoint", "https://user:pw@example.com/x")
-        assertThat(result).doesNotContain("pw@")
-        assertThat(result).contains("<redacted>@example.com/x")
-    }
-
-    @Test
-    fun `sanitize quotes values containing spaces`() {
-        assertThat(SoftApTrace.sanitize("reason", "two words")).isEqualTo("\"two words\"")
-    }
-
-    @Test
-    fun `sanitize renders null and empty`() {
-        assertThat(SoftApTrace.sanitize("reason", null)).isEqualTo("null")
-        assertThat(SoftApTrace.sanitize("reason", "")).isEqualTo("\"\"")
-    }
-
-    @Test
-    fun `newTraceId produces distinct ids`() {
-        assertThat(SoftApTrace.newTraceId()).isNotEqualTo(SoftApTrace.newTraceId())
-    }
-}

package/android/src/test/java/com/mentra/acsmeeting/video/FrameGeometryTest.kt

@@ -1,33 +0,0 @@
-package com.mentra.acsmeeting.video
-
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-
-class FrameGeometryTest {
-  @Test
-  fun rotationZeroUsesBufferSize() {
-    val size = FrameGeometry.packSize(1280, 720, 0)
-    assertThat(size.width).isEqualTo(1280)
-    assertThat(size.height).isEqualTo(720)
-    assertThat(size.rotationNonZero).isFalse()
-  }
-
-  @Test
-  fun rotation90KeepsBufferCoordinatesNotRotatedDisplaySize() {
-    val bufferW = 1280
-    val bufferH = 720
-    val rotatedWidth = bufferH
-    val rotatedHeight = bufferW
-    val size = FrameGeometry.packSize(bufferW, bufferH, 90)
-    assertThat(size.width).isEqualTo(bufferW)
-    assertThat(size.height).isEqualTo(bufferH)
-    assertThat(size.rotationNonZero).isTrue()
-    assertThat(size.width).isNotEqualTo(rotatedWidth)
-    assertThat(size.height).isNotEqualTo(rotatedHeight)
-    val overrun = I420Packer.packedSize(rotatedWidth, rotatedHeight)
-    val actual = I420Packer.packedSize(size.width, size.height)
-    assertThat(overrun).isEqualTo(actual)
-    val planeIfRotated = rotatedHeight * 1280
-    assertThat(planeIfRotated).isGreaterThan(bufferW * bufferH)
-  }
-}