react-native-audio-browser 0.2.0-next.8 → 0.2.0

package/android/src/test/java/com/audiobrowser/player/PlaybackStateMachineTest.kt

@@ -1,198 +0,0 @@
-package com.audiobrowser.player
-
-import androidx.media3.common.Player as MediaPlayer
-import com.margelo.nitro.audiobrowser.PlaybackState
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-/**
- * Truth table for the playback state transitions — the Android analog of iOS's
- * `nextPlaybackState(from:on:)`, previously inline branching in PlayerListener.onEvents. Guards
- * here are state-related; context guards arrive as event fields captured at the call site.
- */
-class PlaybackStateMachineTest {
-
-  private fun on(
-    event: PlaybackEvent,
-    from: PlaybackState = PlaybackState.PLAYING,
-  ): List<PlaybackState> = PlaybackStateMachine.transitions(from, event)
-
-  // MARK: ExoPlayer state changes
-
-  @Test
-  fun `buffering maps directly`() {
-    assertEquals(
-      listOf(PlaybackState.BUFFERING),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          MediaPlayer.STATE_BUFFERING,
-          mediaItemCount = 1,
-          playWhenReady = true,
-        )
-      ),
-    )
-  }
-
-  @Test
-  fun `ready is emitted only while paused, suppressed while playing`() {
-    // Paused (playWhenReady=false): READY is the settled signal consumers need to
-    // clear a spinner from a buffer that finished while paused (mono#3325).
-    assertEquals(
-      listOf(PlaybackState.READY),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          MediaPlayer.STATE_READY,
-          mediaItemCount = 1,
-          playWhenReady = false,
-        ),
-        from = PlaybackState.BUFFERING,
-      ),
-    )
-    // Playing (playWhenReady=true): READY is a transient before PLAYING — suppressed
-    // so consumers don't flash a settled/non-loading state mid-startup.
-    assertEquals(
-      emptyList<PlaybackState>(),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          MediaPlayer.STATE_READY,
-          mediaItemCount = 1,
-          playWhenReady = true,
-        ),
-        from = PlaybackState.BUFFERING,
-      ),
-    )
-  }
-
-  @Test
-  fun `idle maps to none except from error or stopped`() {
-    val idle =
-      PlaybackEvent.ExoPlaybackStateChanged(
-        MediaPlayer.STATE_IDLE,
-        mediaItemCount = 1,
-        playWhenReady = false,
-      )
-    assertEquals(listOf(PlaybackState.NONE), on(idle, from = PlaybackState.PLAYING))
-    // A terminal error idles ExoPlayer; transitioning to NONE would clear the ERROR state the
-    // session is rendering. Same for an explicit stop.
-    assertEquals(emptyList<PlaybackState>(), on(idle, from = PlaybackState.ERROR))
-    assertEquals(emptyList<PlaybackState>(), on(idle, from = PlaybackState.STOPPED))
-  }
-
-  @Test
-  fun `ended maps to ended only while the queue has items`() {
-    assertEquals(
-      listOf(PlaybackState.ENDED),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          MediaPlayer.STATE_ENDED,
-          mediaItemCount = 3,
-          playWhenReady = false,
-        )
-      ),
-    )
-    // An emptied queue also reports STATE_ENDED; that is "nothing loaded", not "played to end".
-    assertEquals(
-      listOf(PlaybackState.NONE),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          MediaPlayer.STATE_ENDED,
-          mediaItemCount = 0,
-          playWhenReady = false,
-        )
-      ),
-    )
-  }
-
-  @Test
-  fun `recovery out of error is allowed`() {
-    // The asymmetry that makes the session-error mask work: IDLE is suppressed from ERROR (the
-    // error keeps rendering), but a real recovery (re-prepare reaching BUFFERING/READY) must
-    // transition out of ERROR.
-    assertEquals(
-      listOf(PlaybackState.BUFFERING),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          MediaPlayer.STATE_BUFFERING,
-          mediaItemCount = 1,
-          playWhenReady = true,
-        ),
-        from = PlaybackState.ERROR,
-      ),
-    )
-    // A paused recovery reaching READY (playWhenReady=false) also leaves ERROR.
-    assertEquals(
-      listOf(PlaybackState.READY),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          MediaPlayer.STATE_READY,
-          mediaItemCount = 1,
-          playWhenReady = false,
-        ),
-        from = PlaybackState.ERROR,
-      ),
-    )
-  }
-
-  @Test
-  fun `an unmapped exo state is a no-op`() {
-    assertEquals(
-      emptyList<PlaybackState>(),
-      on(
-        PlaybackEvent.ExoPlaybackStateChanged(
-          exoState = 99,
-          mediaItemCount = 1,
-          playWhenReady = false,
-        )
-      ),
-    )
-  }
-
-  // MARK: media item transitions
-
-  @Test
-  fun `a transition to a track synthesizes the loading burst`() {
-    assertEquals(
-      listOf(PlaybackState.LOADING),
-      on(PlaybackEvent.MediaItemTransition(hasTrack = true, isPlaying = false)),
-    )
-    // Already audibly playing (gapless auto-advance): run the full burst so consumers see the
-    // canonical sequence rather than staying stuck on LOADING.
-    assertEquals(
-      listOf(PlaybackState.LOADING, PlaybackState.READY, PlaybackState.PLAYING),
-      on(PlaybackEvent.MediaItemTransition(hasTrack = true, isPlaying = true)),
-    )
-  }
-
-  @Test
-  fun `a transition without a track is suppressed`() {
-    assertEquals(
-      emptyList<PlaybackState>(),
-      on(PlaybackEvent.MediaItemTransition(hasTrack = false, isPlaying = true)),
-    )
-  }
-
-  // MARK: playWhenReady / isPlaying
-
-  @Test
-  fun `losing playWhenReady pauses except from stopped or ended`() {
-    val paused = PlaybackEvent.PlayWhenReadyChanged(playWhenReady = false)
-    assertEquals(listOf(PlaybackState.PAUSED), on(paused, from = PlaybackState.PLAYING))
-    assertEquals(emptyList<PlaybackState>(), on(paused, from = PlaybackState.STOPPED))
-    // ENDED is terminal the same way: dropping the intent after a natural end (the
-    // clear at ENDED, or a dead toggle press) must not re-report the state as PAUSED.
-    assertEquals(emptyList<PlaybackState>(), on(paused, from = PlaybackState.ENDED))
-    assertEquals(
-      emptyList<PlaybackState>(),
-      on(PlaybackEvent.PlayWhenReadyChanged(playWhenReady = true)),
-    )
-  }
-
-  @Test
-  fun `audible playback maps to playing`() {
-    assertEquals(
-      listOf(PlaybackState.PLAYING),
-      on(PlaybackEvent.IsPlayingChanged(isPlaying = true), from = PlaybackState.READY),
-    )
-    assertEquals(emptyList<PlaybackState>(), on(PlaybackEvent.IsPlayingChanged(isPlaying = false)))
-  }
-}

package/android/src/test/java/com/audiobrowser/player/PlaybackTimerTest.kt

@@ -1,137 +0,0 @@
-package com.audiobrowser.player
-
-import com.margelo.nitro.audiobrowser.PlaybackState
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.test.UnconfinedTestDispatcher
-import kotlinx.coroutines.test.advanceTimeBy
-import kotlinx.coroutines.test.resetMain
-import kotlinx.coroutines.test.runTest
-import kotlinx.coroutines.test.setMain
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class PlaybackTimerTest {
-
-  @Before
-  fun setup() {
-    Dispatchers.setMain(UnconfinedTestDispatcher())
-  }
-
-  @After
-  fun tearDown() {
-    Dispatchers.resetMain()
-  }
-
-  private fun playingTimer(onTick: () -> Unit) =
-    PlaybackTimer(isActive = { it == PlaybackState.PLAYING }, onTick = onTick)
-
-  @Test
-  fun `interval set but not active does not emit`() = runTest {
-    var callCount = 0
-    val timer = playingTimer { callCount++ }
-
-    timer.setInterval(0.1) // active is still false (no state change)
-
-    advanceTimeBy(500)
-    assertEquals(0, callCount)
-  }
-
-  @Test
-  fun `active without interval does nothing`() = runTest {
-    var callCount = 0
-    val timer = playingTimer { callCount++ }
-
-    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
-
-    advanceTimeBy(500)
-    assertEquals(0, callCount)
-  }
-
-  @Test
-  fun `active and interval set begins emitting, leaving active ceases`() = runTest {
-    var callCount = 0
-    val timer = playingTimer { callCount++ }
-
-    timer.setInterval(0.1)
-    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
-
-    advanceTimeBy(350)
-    assertTrue("Expected events while active", callCount > 0)
-
-    timer.onPlaybackStateChanged(PlaybackState.PAUSED)
-    val afterPause = callCount
-
-    advanceTimeBy(500)
-    assertEquals(afterPause, callCount)
-  }
-
-  @Test
-  fun `changing interval while running restarts with new interval`() = runTest {
-    var callCount = 0
-    val timer = playingTimer { callCount++ }
-
-    timer.setInterval(0.1)
-    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
-    advanceTimeBy(350)
-    assertTrue("Expected events while running, got $callCount", callCount > 0)
-
-    val before = callCount
-    timer.setInterval(0.2) // different value — should restart
-    advanceTimeBy(500)
-    assertTrue("Expected more events after interval change", callCount > before)
-
-    timer.setInterval(null)
-  }
-
-  @Test
-  fun `nil interval stops`() = runTest {
-    var callCount = 0
-    val timer = playingTimer { callCount++ }
-
-    timer.setInterval(0.1)
-    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
-    advanceTimeBy(350)
-    assertTrue("Expected events before clearing", callCount > 0)
-
-    timer.setInterval(null)
-    val afterNil = callCount
-
-    advanceTimeBy(500)
-    assertEquals(afterNil, callCount)
-  }
-
-  @Test
-  fun `isActive predicate gates which states run`() = runTest {
-    // playing-only timer must NOT tick while buffering...
-    var playingOnly = 0
-    val strict = playingTimer { playingOnly++ }
-    strict.setInterval(0.1)
-    strict.onPlaybackStateChanged(PlaybackState.BUFFERING)
-    advanceTimeBy(350)
-    assertEquals(0, playingOnly)
-    strict.setInterval(null)
-
-    // ...while a progress-style predicate that includes buffering does.
-    var progress = 0
-    val lenient =
-      PlaybackTimer(
-        isActive = {
-          it == PlaybackState.LOADING ||
-            it == PlaybackState.BUFFERING ||
-            it == PlaybackState.PLAYING
-        }
-      ) {
-        progress++
-      }
-    lenient.setInterval(0.1)
-    lenient.onPlaybackStateChanged(PlaybackState.BUFFERING)
-    advanceTimeBy(350)
-    assertTrue("Expected events when buffering with lenient predicate", progress > 0)
-    lenient.setInterval(null)
-  }
-}

package/android/src/test/java/com/audiobrowser/player/PlayerEngineFactoryTest.kt

@@ -1,36 +0,0 @@
-package com.audiobrowser.player
-
-import com.audiobrowser.model.PlayerSetupOptions
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-/** Pins the buffer-config mapping — the one decision inside engine construction. */
-class PlayerEngineFactoryTest {
-
-  @Test
-  fun `maps the buffer fields and converts to Int millis`() {
-    val config =
-      bufferConfig(
-        PlayerSetupOptions(
-          minBuffer = 1000.0,
-          maxBuffer = 5000.0,
-          playBuffer = 1500.0,
-          backBuffer = 2000.0,
-          rebufferBuffer = 3000.0,
-        )
-      )
-    assertEquals(1000, config.minBufferMs)
-    assertEquals(5000, config.maxBufferMs)
-    assertEquals(1500, config.bufferForPlaybackMs)
-    assertEquals(3000, config.bufferForPlaybackAfterRebufferMs)
-    assertEquals(2000, config.backBufferMs)
-  }
-
-  @Test
-  fun `automatic rebuffer falls back to playBuffer`() {
-    // rebufferBuffer unset = automatic: start post-rebuffer playback at playBuffer and let
-    // AutomaticBufferManager adjust from there.
-    val config = bufferConfig(PlayerSetupOptions(playBuffer = 1500.0, rebufferBuffer = null))
-    assertEquals(1500, config.bufferForPlaybackAfterRebufferMs)
-  }
-}

package/android/src/test/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicyTest.kt

@@ -1,268 +0,0 @@
-package com.audiobrowser.player
-
-import androidx.media3.common.C
-import androidx.media3.common.ParserException
-import androidx.media3.datasource.DataSourceException
-import androidx.media3.datasource.DataSpec
-import androidx.media3.datasource.HttpDataSource
-import androidx.media3.exoplayer.source.LoadEventInfo
-import androidx.media3.exoplayer.source.MediaLoadData
-import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
-import androidx.media3.exoplayer.upstream.Loader
-import java.io.FileNotFoundException
-import java.io.IOException
-import java.net.SocketTimeoutException
-import java.net.UnknownHostException
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.mockito.Mockito.mock
-
-class RetryLoadErrorHandlingPolicyTest {
-  // LoadEventInfo requires a DataSpec (Android Uri) to construct, so mock it.
-  // MediaLoadData has a dependency-free constructor. The policy only ever reads
-  // LoadErrorInfo.exception and LoadErrorInfo.errorCount.
-  private val loadEventInfo = mock(LoadEventInfo::class.java)
-  private val mediaLoadData = MediaLoadData(C.DATA_TYPE_MEDIA)
-
-  private fun errorInfo(exception: IOException, errorCount: Int = 1) =
-    LoadErrorHandlingPolicy.LoadErrorInfo(loadEventInfo, mediaLoadData, exception, errorCount)
-
-  /** Builds an [HttpDataSource.InvalidResponseCodeException] for the given HTTP status code. */
-  private fun httpError(responseCode: Int): HttpDataSource.InvalidResponseCodeException =
-    HttpDataSource.InvalidResponseCodeException(
-      responseCode,
-      "response message",
-      /* cause= */ null,
-      emptyMap(),
-      mock(DataSpec::class.java),
-      ByteArray(0),
-    )
-
-  /**
-   * Asserts the given error is classified non-recoverable: the default policy gives up (no retry is
-   * scheduled) and the network-retry callback is never armed.
-   */
-  private fun assertNonRecoverable(exception: IOException) {
-    var pendingNetwork: Boolean? = null
-    val policy =
-      RetryLoadErrorHandlingPolicy(
-        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError }
-      )
-    val delay = policy.getRetryDelayMsFor(errorInfo(exception))
-    assertEquals(C.TIME_UNSET, delay)
-    assertNull(pendingNetwork)
-  }
-
-  @Test
-  fun `offline network IOException is retried and arms the network-retry callback`() {
-    var pendingNetwork: Boolean? = null
-    val policy =
-      RetryLoadErrorHandlingPolicy(
-        maxRetries = null,
-        isOnline = { false },
-        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError },
-      )
-
-    // A wifi drop surfaces as a raw IOException from the socket/DNS layer, NOT a
-    // PlaybackException. This must still be treated as a recoverable network error.
-    val delay = policy.getRetryDelayMsFor(errorInfo(UnknownHostException("Unable to resolve host")))
-
-    // Recoverable -> a real (non-TIME_UNSET) retry delay is scheduled.
-    assertNotEquals(C.TIME_UNSET, delay)
-    // While offline we use the short fixed delay so reconnect can accelerate.
-    assertEquals(1000L, delay)
-    // The network-retry callback must be armed so connectivity restoration can
-    // trigger an immediate exoPlayer.prepare().
-    assertEquals(true, pendingNetwork)
-  }
-
-  @Test
-  fun `socket timeout is classified as a recoverable network error`() {
-    var pendingNetwork: Boolean? = null
-    val policy =
-      RetryLoadErrorHandlingPolicy(
-        isOnline = { true },
-        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError },
-      )
-
-    val delay = policy.getRetryDelayMsFor(errorInfo(SocketTimeoutException("timeout")))
-
-    assertNotEquals(C.TIME_UNSET, delay)
-    assertTrue("expected a positive retry delay, got $delay", delay > 0)
-    assertEquals(true, pendingNetwork)
-  }
-
-  @Test
-  fun `retry is skipped when shouldRetry is false`() {
-    val policy = RetryLoadErrorHandlingPolicy(shouldRetry = { false })
-    val delay = policy.getRetryDelayMsFor(errorInfo(UnknownHostException("offline")))
-    assertEquals(C.TIME_UNSET, delay)
-  }
-
-  @Test
-  fun `retry stops once max retries is exceeded`() {
-    val policy = RetryLoadErrorHandlingPolicy(maxRetries = 3)
-    val delay =
-      policy.getRetryDelayMsFor(errorInfo(UnknownHostException("offline"), errorCount = 4))
-    assertEquals(C.TIME_UNSET, delay)
-  }
-
-  @Test
-  fun `retryable HTTP status (503) is recoverable and arms the network-retry callback`() {
-    var pendingNetwork: Boolean? = null
-    val policy =
-      RetryLoadErrorHandlingPolicy(
-        isOnline = { true },
-        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError },
-      )
-
-    val delay = policy.getRetryDelayMsFor(errorInfo(httpError(503)))
-
-    assertNotEquals(C.TIME_UNSET, delay)
-    assertEquals(true, pendingNetwork)
-  }
-
-  @Test
-  fun `non-retryable HTTP status (404) is not retried`() {
-    var pendingNetwork: Boolean? = null
-    val policy =
-      RetryLoadErrorHandlingPolicy(
-        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError }
-      )
-
-    val delay = policy.getRetryDelayMsFor(errorInfo(httpError(404)))
-
-    // A 404 will never succeed on retry: stop immediately rather than spinning until the
-    // max-retry-duration timeout, and never arm the connectivity-restoration path.
-    assertEquals(C.TIME_UNSET, delay)
-    assertNull(pendingNetwork)
-  }
-
-  @Test
-  fun `parser errors are non-recoverable`() {
-    assertNonRecoverable(ParserException.createForMalformedContainer("bad container", null))
-  }
-
-  @Test
-  fun `file-not-found errors are non-recoverable`() {
-    assertNonRecoverable(FileNotFoundException("missing"))
-  }
-
-  @Test
-  fun `unexpected loader errors are non-recoverable`() {
-    assertNonRecoverable(Loader.UnexpectedLoaderException(IllegalStateException("boom")))
-  }
-
-  @Test
-  @Suppress("DEPRECATION") // DataSourceException(reason) is the only way to build this in a test
-  fun `reads past the available position are non-recoverable`() {
-    assertNonRecoverable(DataSourceException(DataSourceException.POSITION_OUT_OF_RANGE))
-  }
-}
-
-/**
- * The two duration budgets: a never-played load gives up fast while online; a load that produced
- * audio — or a device that is offline — keeps the full recovery budget. Clock-based: budgets are
- * 100ms and the tests sleep 150ms between errors, comfortable margins in both directions.
- */
-class RetryLoadErrorHandlingPolicyBudgetTest {
-  private val loadEventInfo = org.mockito.Mockito.mock(LoadEventInfo::class.java)
-  private val mediaLoadData = MediaLoadData(C.DATA_TYPE_MEDIA)
-
-  private fun errorInfo(errorCount: Int = 1) =
-    LoadErrorHandlingPolicy.LoadErrorInfo(
-      loadEventInfo,
-      mediaLoadData,
-      UnknownHostException("dead host"),
-      errorCount,
-    )
-
-  @Test
-  fun `never-played load gives up after the first-connect budget`() {
-    val policy =
-      RetryLoadErrorHandlingPolicy(firstConnectMaxRetryDurationMs = 100, hasPlayed = { false })
-
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
-    Thread.sleep(150)
-    assertEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
-  }
-
-  @Test
-  fun `played load ignores the first-connect budget`() {
-    val policy =
-      RetryLoadErrorHandlingPolicy(firstConnectMaxRetryDurationMs = 100, hasPlayed = { true })
-
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
-    Thread.sleep(150)
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
-  }
-
-  /**
-   * Offline failures must not burn the first-connect budget (a station tapped in a tunnel parks for
-   * connectivity); the budget's clock starts at the first error observed online, so a dead station
-   * still gets a fast verdict after restoration.
-   */
-  @Test
-  fun `offline time does not burn the first-connect budget`() {
-    var online = false
-    val policy =
-      RetryLoadErrorHandlingPolicy(
-        firstConnectMaxRetryDurationMs = 100,
-        isOnline = { online },
-        hasPlayed = { false },
-      )
-
-    // Offline: the short budget never engages.
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
-    Thread.sleep(150)
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
-
-    // Connectivity returns: the short clock starts now — one more error is
-    // retried, then the budget is spent.
-    online = true
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 3)))
-    Thread.sleep(150)
-    assertEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 4)))
-  }
-
-  /**
-   * An offline stretch in the middle of the budget must not count against it: any offline
-   * observation wipes the clock, which restarts at the next error observed online.
-   */
-  @Test
-  fun `offline stretch mid-budget restarts the first-connect clock`() {
-    var online = true
-    val policy =
-      RetryLoadErrorHandlingPolicy(
-        firstConnectMaxRetryDurationMs = 100,
-        isOnline = { online },
-        hasPlayed = { false },
-      )
-
-    // Online failure starts the clock, then the budget elapses while offline.
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
-    Thread.sleep(150)
-    online = false
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
-
-    // Back online: the clock restarted — a full budget remains.
-    online = true
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 3)))
-    Thread.sleep(150)
-    assertEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 4)))
-  }
-
-  @Test
-  fun `reset restarts the first-connect clock`() {
-    val policy =
-      RetryLoadErrorHandlingPolicy(firstConnectMaxRetryDurationMs = 100, hasPlayed = { false })
-
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
-    Thread.sleep(150)
-    policy.reset()
-    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
-  }
-}

package/android/src/test/java/com/audiobrowser/player/SessionErrorMaskTest.kt

@@ -1,68 +0,0 @@
-package com.audiobrowser.player
-
-import androidx.media3.common.Player as MediaPlayer
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-/**
- * Truth table for the session-error masking that keeps the platform session alive through a
- * terminal load error (Android Auto reads STATE_NONE as "nothing playing" and tears down the
- * now-playing screen): idle+error masks to paused-but-ready, everything else passes through.
- */
-class SessionErrorMaskTest {
-
-  @Test
-  fun `idle with an error masks to ready while keep-alive is on`() {
-    assertEquals(
-      MediaPlayer.STATE_READY,
-      SessionErrorMask.playbackState(MediaPlayer.STATE_IDLE, hasError = true, keepAlive = true),
-    )
-    assertEquals(
-      false,
-      SessionErrorMask.playWhenReady(
-        raw = true,
-        state = MediaPlayer.STATE_IDLE,
-        hasError = true,
-        keepAlive = true,
-      ),
-    )
-  }
-
-  @Test
-  fun `no masking without keep-alive`() {
-    assertEquals(
-      MediaPlayer.STATE_IDLE,
-      SessionErrorMask.playbackState(MediaPlayer.STATE_IDLE, hasError = true, keepAlive = false),
-    )
-    assertEquals(
-      true,
-      SessionErrorMask.playWhenReady(
-        raw = true,
-        state = MediaPlayer.STATE_IDLE,
-        hasError = true,
-        keepAlive = false,
-      ),
-    )
-  }
-
-  @Test
-  fun `no masking without an error or outside idle`() {
-    assertEquals(
-      MediaPlayer.STATE_IDLE,
-      SessionErrorMask.playbackState(MediaPlayer.STATE_IDLE, hasError = false, keepAlive = true),
-    )
-    assertEquals(
-      MediaPlayer.STATE_BUFFERING,
-      SessionErrorMask.playbackState(MediaPlayer.STATE_BUFFERING, hasError = true, keepAlive = true),
-    )
-    assertEquals(
-      true,
-      SessionErrorMask.playWhenReady(
-        raw = true,
-        state = MediaPlayer.STATE_READY,
-        hasError = true,
-        keepAlive = true,
-      ),
-    )
-  }
-}