react-native-queue-player 1.0.0

package/android/src/test/java/com/margelo/nitro/queueplayer/QueueSkipArithmeticTest.kt

@@ -0,0 +1,343 @@
+package com.margelo.nitro.queueplayer
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * pure Kotlin port of iOS `SkipIndexTests`.
+ *
+ * Exercises [QueueSkipArithmetic.computeNext] and
+ * [QueueSkipArithmetic.computePrevious] across every [QueueSkipRepeatMode]
+ * plus wrap behaviour, empty-queue, and not-started guards. The
+ * contract is identical on iOS / Android / C++ (same three enum
+ * values, same value order 0/1/2, same boundary semantics).
+ */
+class QueueSkipArithmeticTest {
+
+  // --- raw-value parity (catches spec reordering)
+
+  @Test
+  fun `QueueSkipRepeatMode raw values match the nitro-ts RepeatMode spec`() {
+    // OFF=0, TRACK=1, QUEUE=2 — the same order as the C++ enum
+    // and iOS QueueSkipRepeatMode. The raw integers are part of the
+    // cross-platform contract, so pin them.
+    assertEquals(0, QueueSkipRepeatMode.OFF.rawValue)
+    assertEquals(1, QueueSkipRepeatMode.TRACK.rawValue)
+    assertEquals(2, QueueSkipRepeatMode.QUEUE.rawValue)
+  }
+
+  // --- computeNext — REPEAT OFF
+
+  @Test
+  fun `computeNext — empty queue returns null`() {
+    assertNull(
+      QueueSkipArithmetic.computeNext(0, -1, QueueSkipRepeatMode.OFF)
+    )
+  }
+
+  @Test
+  fun `computeNext — cur is less than 0 returns null regardless of mode`() {
+    for (mode in QueueSkipRepeatMode.entries) {
+      assertNull(QueueSkipArithmetic.computeNext(5, -1, mode))
+    }
+  }
+
+  @Test
+  fun `computeNext OFF — mid-queue advances by 1`() {
+    assertEquals(
+      3,
+      QueueSkipArithmetic.computeNext(5, 2, QueueSkipRepeatMode.OFF)
+    )
+  }
+
+  @Test
+  fun `computeNext OFF — at last index returns null (no wrap)`() {
+    assertNull(
+      QueueSkipArithmetic.computeNext(5, 4, QueueSkipRepeatMode.OFF)
+    )
+  }
+
+  // --- computeNext — REPEAT TRACK
+
+  @Test
+  fun `computeNext TRACK — advances like OFF with no wrap`() {
+    // TRACK navigates identically to OFF: advance by 1, null at the
+    // last track. Repeat-one persists so the new track loops on
+    // natural end (handled in TrackPlayer, not the arithmetic).
+    assertEquals(
+      1,
+      QueueSkipArithmetic.computeNext(5, 0, QueueSkipRepeatMode.TRACK)
+    )
+    assertEquals(
+      3,
+      QueueSkipArithmetic.computeNext(5, 2, QueueSkipRepeatMode.TRACK)
+    )
+    assertEquals(
+      null,
+      QueueSkipArithmetic.computeNext(5, 4, QueueSkipRepeatMode.TRACK)
+    )
+  }
+
+  // --- computeNext — REPEAT QUEUE
+
+  @Test
+  fun `computeNext QUEUE — mid-queue advances by 1`() {
+    assertEquals(
+      3,
+      QueueSkipArithmetic.computeNext(5, 2, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  @Test
+  fun `computeNext QUEUE — at last index wraps to 0`() {
+    assertEquals(
+      0,
+      QueueSkipArithmetic.computeNext(5, 4, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  @Test
+  fun `computeNext QUEUE — single-item queue wraps to self`() {
+    assertEquals(
+      0,
+      QueueSkipArithmetic.computeNext(1, 0, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  // --- computePrevious — REPEAT OFF
+
+  @Test
+  fun `computePrevious — empty queue returns null`() {
+    assertNull(
+      QueueSkipArithmetic.computePrevious(0, -1, QueueSkipRepeatMode.OFF)
+    )
+  }
+
+  @Test
+  fun `computePrevious — cur is less than 0 returns null regardless of mode`() {
+    for (mode in QueueSkipRepeatMode.entries) {
+      assertNull(QueueSkipArithmetic.computePrevious(5, -1, mode))
+    }
+  }
+
+  @Test
+  fun `computePrevious OFF — mid-queue goes back by 1`() {
+    assertEquals(
+      2,
+      QueueSkipArithmetic.computePrevious(5, 3, QueueSkipRepeatMode.OFF)
+    )
+  }
+
+  @Test
+  fun `computePrevious OFF — at index 0 returns null (no wrap)`() {
+    // The "tap Previous at track 0 restarts current" UX behaviour
+    // is applied by the skipToPrevious glue, not here.
+    assertNull(
+      QueueSkipArithmetic.computePrevious(5, 0, QueueSkipRepeatMode.OFF)
+    )
+  }
+
+  // --- computePrevious — REPEAT TRACK
+
+  @Test
+  fun `computePrevious TRACK — goes back like OFF with no wrap`() {
+    assertEquals(
+      null,
+      QueueSkipArithmetic.computePrevious(5, 0, QueueSkipRepeatMode.TRACK)
+    )
+    assertEquals(
+      2,
+      QueueSkipArithmetic.computePrevious(5, 3, QueueSkipRepeatMode.TRACK)
+    )
+    assertEquals(
+      3,
+      QueueSkipArithmetic.computePrevious(5, 4, QueueSkipRepeatMode.TRACK)
+    )
+  }
+
+  // --- computePrevious — REPEAT QUEUE
+
+  @Test
+  fun `computePrevious QUEUE — mid-queue goes back by 1`() {
+    assertEquals(
+      2,
+      QueueSkipArithmetic.computePrevious(5, 3, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  @Test
+  fun `computePrevious QUEUE — at index 0 wraps to last`() {
+    assertEquals(
+      4,
+      QueueSkipArithmetic.computePrevious(5, 0, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  @Test
+  fun `computePrevious QUEUE — single-item queue wraps to self`() {
+    assertEquals(
+      0,
+      QueueSkipArithmetic.computePrevious(1, 0, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  // --- trackCount edge cases
+
+  @Test
+  fun `computeNext — cur at or past trackCount returns null in OFF`() {
+    // Defensive: the caller should keep cur in range, but the
+    // helper must still be total — no crash, just a null bail-out.
+    assertNull(
+      QueueSkipArithmetic.computeNext(5, 5, QueueSkipRepeatMode.OFF)
+    )
+    assertNull(
+      QueueSkipArithmetic.computeNext(5, 10, QueueSkipRepeatMode.OFF)
+    )
+  }
+
+  @Test
+  fun `computeNext QUEUE — cur at or past trackCount wraps to 0`() {
+    // Consistent with the "last → 0" wrap branch: any out-of-range
+    // cur past trackCount produces currentIndex + 1 > trackCount →
+    // falls through to 0. This is the caller's responsibility to
+    // avoid, but the helper remains total.
+    assertEquals(
+      0,
+      QueueSkipArithmetic.computeNext(5, 5, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  @Test
+  fun `computePrevious QUEUE — cur at or past trackCount walks back by 1`() {
+    // Symmetric to the computeNext out-of-range branch above.
+    // Defensive totality, not a contract consumers should rely on.
+    assertEquals(
+      4,
+      QueueSkipArithmetic.computePrevious(5, 5, QueueSkipRepeatMode.QUEUE)
+    )
+  }
+
+  // --- canSkipNext
+
+  @Test
+  fun `canSkipNext — empty queue is false`() {
+    assertFalse(QueueSkipArithmetic.canSkipNext(0, -1, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipNext — nothing playing is false in any mode`() {
+    for (mode in QueueSkipRepeatMode.entries) {
+      assertFalse(QueueSkipArithmetic.canSkipNext(5, -1, mode))
+    }
+  }
+
+  @Test
+  fun `canSkipNext OFF — mid-queue is true`() {
+    assertTrue(QueueSkipArithmetic.canSkipNext(5, 2, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipNext OFF — at last index is false`() {
+    assertFalse(QueueSkipArithmetic.canSkipNext(5, 4, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipNext OFF — single-track queue is false`() {
+    assertFalse(QueueSkipArithmetic.canSkipNext(1, 0, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipNext QUEUE — at last wraps so true`() {
+    assertTrue(QueueSkipArithmetic.canSkipNext(5, 4, QueueSkipRepeatMode.QUEUE))
+  }
+
+  @Test
+  fun `canSkipNext QUEUE — single-track wraps to self so true`() {
+    assertTrue(QueueSkipArithmetic.canSkipNext(1, 0, QueueSkipRepeatMode.QUEUE))
+  }
+
+  @Test
+  fun `canSkipNext TRACK — true except at the last track (no wrap)`() {
+    for (idx in 0 until 4) {
+      assertTrue(
+        "canSkipNext should be true at index $idx under TRACK",
+        QueueSkipArithmetic.canSkipNext(5, idx, QueueSkipRepeatMode.TRACK)
+      )
+    }
+    assertFalse(
+      "canSkipNext should be false at the last track under TRACK",
+      QueueSkipArithmetic.canSkipNext(5, 4, QueueSkipRepeatMode.TRACK)
+    )
+  }
+
+  // --- canSkipPrevious
+  //
+  // Symmetric with canSkipNext — defined as `computePrevious(...) !=
+  // null`. Apps that want "tap Previous restarts current at >3s"
+  // implement that themselves in their button handler.
+
+  @Test
+  fun `canSkipPrevious — empty queue is false`() {
+    assertFalse(QueueSkipArithmetic.canSkipPrevious(0, -1, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipPrevious — nothing playing is false in any mode`() {
+    for (mode in QueueSkipRepeatMode.entries) {
+      assertFalse(QueueSkipArithmetic.canSkipPrevious(5, -1, mode))
+    }
+  }
+
+  @Test
+  fun `canSkipPrevious OFF — mid-queue is true`() {
+    assertTrue(QueueSkipArithmetic.canSkipPrevious(5, 2, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipPrevious OFF — at index 0 is false`() {
+    // No previous track in OFF at index 0 — computePrevious returns
+    // null. App can implement restart-on-tap-prev itself by reading
+    // position; the lib reports the primitive.
+    assertFalse(QueueSkipArithmetic.canSkipPrevious(5, 0, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipPrevious OFF — single-track is false`() {
+    assertFalse(QueueSkipArithmetic.canSkipPrevious(1, 0, QueueSkipRepeatMode.OFF))
+  }
+
+  @Test
+  fun `canSkipPrevious QUEUE — at index 0 wraps so true`() {
+    assertTrue(QueueSkipArithmetic.canSkipPrevious(5, 0, QueueSkipRepeatMode.QUEUE))
+  }
+
+  @Test
+  fun `canSkipPrevious QUEUE — single-track wraps to self so true`() {
+    assertTrue(QueueSkipArithmetic.canSkipPrevious(1, 0, QueueSkipRepeatMode.QUEUE))
+  }
+
+  @Test
+  fun `canSkipPrevious TRACK — true except at index 0 (no wrap)`() {
+    assertFalse(
+      "canSkipPrevious should be false at index 0 under TRACK",
+      QueueSkipArithmetic.canSkipPrevious(5, 0, QueueSkipRepeatMode.TRACK)
+    )
+    for (idx in 1 until 5) {
+      assertTrue(
+        "canSkipPrevious should be true at index $idx under TRACK",
+        QueueSkipArithmetic.canSkipPrevious(5, idx, QueueSkipRepeatMode.TRACK)
+      )
+    }
+  }
+
+  @Test
+  fun `TRACK single-track queue — no next, no previous (no wrap)`() {
+    assertEquals(null, QueueSkipArithmetic.computeNext(1, 0, QueueSkipRepeatMode.TRACK))
+    assertEquals(null, QueueSkipArithmetic.computePrevious(1, 0, QueueSkipRepeatMode.TRACK))
+    assertFalse(QueueSkipArithmetic.canSkipNext(1, 0, QueueSkipRepeatMode.TRACK))
+    assertFalse(QueueSkipArithmetic.canSkipPrevious(1, 0, QueueSkipRepeatMode.TRACK))
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/RadixTwoFFTTest.kt

@@ -0,0 +1,109 @@
+package com.margelo.nitro.queueplayer
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.sin
+
+/**
+ * Unit coverage for the radix-2 forward FFT — synthesizes inputs with
+ * known spectra and asserts the magnitude bins land where they should.
+ */
+class RadixTwoFFTTest {
+
+  @Test
+  fun `DC input puts all energy in bin 0`() {
+    val n = 64
+    val real = FloatArray(n) { 1.0f }
+    val imag = FloatArray(n)
+    val mags = FloatArray(n / 2)
+    RadixTwoFFT.forward(real, imag)
+    RadixTwoFFT.magnitudes(real, imag, mags)
+    assertEquals(2.0f, mags[0], 1e-3f) // 2 * (sum / n) for DC=1 input
+    for (k in 1 until mags.size) {
+      assertTrue("bin $k should be ~0 for DC input, was ${mags[k]}", mags[k] < 1e-3f)
+    }
+  }
+
+  @Test
+  fun `pure sine at bin k peaks magnitude at bin k`() {
+    val n = 256
+    val k = 8
+    val real = FloatArray(n) { i -> cos(2.0 * PI * k * i / n).toFloat() }
+    val imag = FloatArray(n)
+    val mags = FloatArray(n / 2)
+    RadixTwoFFT.forward(real, imag)
+    RadixTwoFFT.magnitudes(real, imag, mags)
+    val peakBin = (0 until mags.size).maxBy { mags[it] }
+    assertEquals("peak should be at bin $k", k, peakBin)
+    // Other bins should be far below the peak (numerical leakage allowed).
+    for (i in 0 until mags.size) {
+      if (i == k) continue
+      assertTrue(
+        "bin $i (${mags[i]}) should be < bin $k (${mags[k]}) / 100",
+        mags[i] < mags[k] / 100f,
+      )
+    }
+  }
+
+  @Test
+  fun `power-of-two requirement is enforced`() {
+    val real = FloatArray(7)
+    val imag = FloatArray(7)
+    try {
+      RadixTwoFFT.forward(real, imag)
+      throw AssertionError("expected IllegalArgumentException for non-power-of-two length")
+    } catch (e: IllegalArgumentException) {
+      assertTrue(e.message?.contains("power of two") == true)
+    }
+  }
+
+  @Test
+  fun `Hann window has the expected shape`() {
+    val w = RadixTwoFFT.hannWindow(8)
+    assertEquals(8, w.size)
+    assertEquals(0.0f, w[0], 1e-6f) // first sample
+    assertEquals(0.0f, w[7], 1e-6f) // last sample
+    // Symmetric: w[i] == w[n-1-i]
+    for (i in 0 until w.size / 2) {
+      assertEquals(w[i], w[w.size - 1 - i], 1e-6f)
+    }
+    // Peak in the middle (between indices 3 and 4 for n=8).
+    assertTrue(w[3] > w[0])
+    assertTrue(w[4] > w[7])
+  }
+
+  @Test
+  fun `mismatched array lengths throw`() {
+    try {
+      RadixTwoFFT.forward(FloatArray(8), FloatArray(4))
+      throw AssertionError("expected IllegalArgumentException for length mismatch")
+    } catch (e: IllegalArgumentException) {
+      assertTrue(e.message?.contains("equal length") == true)
+    }
+  }
+
+  @Test
+  fun `forward of single-sample is a no-op`() {
+    val real = floatArrayOf(7f)
+    val imag = floatArrayOf(0f)
+    RadixTwoFFT.forward(real, imag)
+    assertEquals(7f, real[0], 0f)
+    assertEquals(0f, imag[0], 0f)
+  }
+
+  @Test
+  fun `magnitudes output size must be n div 2`() {
+    val real = FloatArray(8) { 1f }
+    val imag = FloatArray(8)
+    RadixTwoFFT.forward(real, imag)
+    try {
+      RadixTwoFFT.magnitudes(real, imag, FloatArray(3))
+      throw AssertionError("expected IllegalArgumentException for wrong out length")
+    } catch (e: IllegalArgumentException) {
+      assertTrue(e.message?.contains("n/2") == true)
+    }
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/RemoteCommandDeduperTest.kt

@@ -0,0 +1,106 @@
+package com.margelo.nitro.queueplayer
+
+import com.margelo.nitro.queueplayer.RemoteCommandDeduper.Channel
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Truth-table coverage for the cross-channel remote-command deduper.
+ * Windows are pinned (cross=200, same=80) so the cases are exact. Pure JVM —
+ * no Android runtime, time is injected.
+ */
+class RemoteCommandDeduperTest {
+  private val next = "skipNext"
+  private val play = "play"
+
+  private fun deduper() = RemoteCommandDeduper(crossWindowMs = 200, sameWindowMs = 80)
+
+  @Test
+  fun firstPressEmits() {
+    assertTrue(deduper().shouldEmit(next, Channel.BROADCAST, 1000))
+  }
+
+  @Test
+  fun crossChannelFanoutWithinWindowSuppressed() {
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))
+    assertFalse(d.shouldEmit(next, Channel.SESSION_KEY, 1015)) // same press, other route, 15ms
+  }
+
+  @Test
+  fun distinctPressesSameChannelBothEmit() {
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1300)) // deliberate skip 300ms later
+  }
+
+  @Test
+  fun bluetoothWedge_distinctPressesPassWithNoDownTimeSignal() {
+    // downTime is not an input. Distinct presses on one channel, each past the
+    // window, all pass — the constant-downTime Bluetooth wedge cannot recur.
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1250))
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1600))
+  }
+
+  @Test
+  fun sameChannelRedeliveryWithinSameWindowSuppressed() {
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.SESSION_KEY, 1000))
+    assertFalse(d.shouldEmit(next, Channel.SESSION_KEY, 1003)) // 3ms near-instant redelivery
+  }
+
+  @Test
+  fun fastDoublePressSameChannelJustOutsideSameWindowEmits() {
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.SESSION_KEY, 1000))
+    assertTrue(d.shouldEmit(next, Channel.SESSION_KEY, 1090)) // 90ms > sameWindow(80)
+  }
+
+  @Test
+  fun sameChannelUsesSameWindowNotCrossWindow() {
+    // 150ms on the same channel: > same(80) but < cross(200) -> still a distinct press.
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1150))
+  }
+
+  @Test
+  fun crossChannelOutsideWindowEmits() {
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))
+    assertTrue(d.shouldEmit(next, Channel.SESSION_KEY, 1250)) // 250 > cross(200)
+  }
+
+  @Test
+  fun interleavedCommandsAreIndependent() {
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))
+    assertTrue(d.shouldEmit(play, Channel.BROADCAST, 1010))     // different command
+    assertFalse(d.shouldEmit(next, Channel.SESSION_KEY, 1015))  // next twin vs next anchor
+    assertFalse(d.shouldEmit(play, Channel.SESSION_KEY, 1020))  // play twin vs play anchor
+  }
+
+  @Test
+  fun anchorNotAdvancedOnSuppress() {
+    // A burst of suppressed duplicates must not keep extending the window.
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))     // emit, anchor @1000
+    assertFalse(d.shouldEmit(next, Channel.SESSION_KEY, 1050))  // suppress, anchor stays @1000
+    assertFalse(d.shouldEmit(next, Channel.SESSION_KEY, 1100))  // suppress, anchor stays @1000
+    // 210ms after the EMIT (not the last suppress); had the anchor advanced this would suppress.
+    assertTrue(d.shouldEmit(next, Channel.SESSION_KEY, 1210))
+  }
+
+  @Test
+  fun crossChannelFanoutTwoPressesEachActOnce() {
+    // Device fans every press across BROADCAST(lead)+SESSION; presses 300ms apart.
+    val d = deduper()
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1000))     // press 1 lead
+    assertFalse(d.shouldEmit(next, Channel.SESSION_KEY, 1015))  // press 1 twin
+    assertTrue(d.shouldEmit(next, Channel.BROADCAST, 1300))     // press 2 lead (same channel, > same window)
+    assertFalse(d.shouldEmit(next, Channel.SESSION_KEY, 1315))  // press 2 twin
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/ReplayGainAudioProcessorTest.kt

@@ -0,0 +1,141 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.C
+import androidx.media3.common.audio.AudioProcessor
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/**
+ * Unit coverage for [ReplayGainAudioProcessor] — the per-sample
+ * Float32 gain stage Media3 wires into the AudioSink chain. Exercises
+ * the [AudioProcessor] contract: configure, isActive gating, in-place
+ * multiply, encoding gate.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class ReplayGainAudioProcessorTest {
+
+  @Test
+  fun `isActive is false at unity gain regardless of float configuration`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(floatFormat(48000, 2))
+    assertFalse(proc.isActive)
+
+    proc.setLinearGain(1.0f)
+    assertFalse(proc.isActive)
+  }
+
+  @Test
+  fun `isActive is true with non-unity gain on a Float32 input`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(floatFormat(48000, 2))
+    proc.setLinearGain(0.5f)
+    assertTrue(proc.isActive)
+  }
+
+  @Test
+  fun `isActive is false on a non-Float32 input regardless of gain`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(int16Format(48000, 2))
+    proc.setLinearGain(0.5f)
+    assertFalse(proc.isActive)
+  }
+
+  @Test
+  fun `queueInput multiplies every sample by the linear gain in place`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(floatFormat(48000, 1))
+    proc.setLinearGain(0.5f)
+
+    val input = floatBuffer(floatArrayOf(1.0f, 0.5f, -0.25f, 0.0f, -1.0f))
+    proc.queueInput(input)
+
+    val output = readFloats(proc.output, 5)
+    assertEquals(0.5f, output[0], 1e-6f)
+    assertEquals(0.25f, output[1], 1e-6f)
+    assertEquals(-0.125f, output[2], 1e-6f)
+    assertEquals(0.0f, output[3], 1e-6f)
+    assertEquals(-0.5f, output[4], 1e-6f)
+  }
+
+  @Test
+  fun `queueInput with gain above unity applies the boost in place`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(floatFormat(44100, 1))
+    proc.setLinearGain(2.0f)
+
+    val input = floatBuffer(floatArrayOf(0.1f, -0.2f, 0.3f))
+    proc.queueInput(input)
+
+    val output = readFloats(proc.output, 3)
+    assertEquals(0.2f, output[0], 1e-6f)
+    assertEquals(-0.4f, output[1], 1e-6f)
+    assertEquals(0.6f, output[2], 1e-6f)
+  }
+
+  @Test
+  fun `queueInput consumes the input buffer`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(floatFormat(48000, 1))
+    proc.setLinearGain(0.5f)
+
+    val input = floatBuffer(floatArrayOf(1.0f, 1.0f, 1.0f, 1.0f))
+    proc.queueInput(input)
+
+    assertEquals(0, input.remaining())
+  }
+
+  @Test
+  fun `setLinearGain is observed on the next queueInput`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(floatFormat(48000, 1))
+    proc.setLinearGain(0.5f)
+    val first = floatBuffer(floatArrayOf(1.0f))
+    proc.queueInput(first)
+    val firstOut = readFloats(proc.output, 1)
+    assertEquals(0.5f, firstOut[0], 1e-6f)
+
+    // Mid-stream gain change — the next queueInput observes it.
+    proc.setLinearGain(0.25f)
+    val second = floatBuffer(floatArrayOf(1.0f))
+    proc.queueInput(second)
+    val secondOut = readFloats(proc.output, 1)
+    assertEquals(0.25f, secondOut[0], 1e-6f)
+  }
+
+  // region Helpers
+
+  private fun floatFormat(sampleRate: Int, channelCount: Int) =
+    AudioProcessor.AudioFormat(sampleRate, channelCount, C.ENCODING_PCM_FLOAT)
+
+  private fun int16Format(sampleRate: Int, channelCount: Int) =
+    AudioProcessor.AudioFormat(sampleRate, channelCount, C.ENCODING_PCM_16BIT)
+
+  private fun floatBuffer(values: FloatArray): ByteBuffer {
+    val buffer = ByteBuffer
+      .allocateDirect(values.size * Float.SIZE_BYTES)
+      .order(ByteOrder.nativeOrder())
+    val asFloat = buffer.asFloatBuffer()
+    for (v in values) asFloat.put(v)
+    buffer.position(0).limit(values.size * Float.SIZE_BYTES)
+    return buffer
+  }
+
+  private fun readFloats(buffer: ByteBuffer, count: Int): FloatArray {
+    val out = FloatArray(count)
+    val asFloat = buffer.asFloatBuffer()
+    for (i in 0 until count) out[i] = asFloat.get()
+    return out
+  }
+
+  // endregion
+}