react-native-audio-browser 0.2.0-next.1 → 0.2.0-next.11

package/ios/Player/RetryManager.swift

@@ -1,3 +1,4 @@
+import AVFoundation
 import Foundation
 #if canImport(NitroModules)
   import NitroModules
@@ -122,30 +123,89 @@ class RetryManager {
 
   // MARK: - Error Classification
 
-  func isRetryable(_ error: Error?) -> Bool {
+  /// HTTP statuses worth another attempt. Same set as Android's
+  /// `RetryLoadErrorHandlingPolicy.RETRYABLE_HTTP_STATUS_CODES`, so a flaky
+  /// server behaves the same on both platforms.
+  private static let retryableHTTPStatusCodes: Set<Int> = [408, 429]
+
+  /// AVFoundation failures a retry cannot fix: the media is unusable rather
+  /// than the transport unreliable. Everything not listed falls through to
+  /// retry — `AVErrorUnknown` especially, which is the wrapper AVFoundation
+  /// puts around opaque CoreMedia transport failures.
+  private static let fatalAVErrorCodes: Set<Int> = [
+    AVError.fileFormatNotRecognized.rawValue,
+    AVError.failedToParse.rawValue,
+    AVError.decodeFailed.rawValue,
+    AVError.contentIsProtected.rawValue,
+    AVError.contentIsNotAuthorized.rawValue,
+  ]
+
+  /// Whether another attempt could plausibly succeed.
+  ///
+  /// Mirrors Android's `classifyError`, including its default: an unrecognized
+  /// failure is treated as *transient* and retried, bounded by the retry
+  /// budgets, rather than being terminal. Defaulting the other way made
+  /// `retry: true` largely inert on iOS, because AVFoundation reports most
+  /// stream failures as opaque `CoreMediaErrorDomain` / `AVFoundationErrorDomain`
+  /// errors rather than `URLError`.
+  ///
+  /// - Parameter httpStatusCode: The status from the item's error log, when the
+  ///   caller has one. `AVPlayerItem.error` never carries it — a 404 arrives as
+  ///   an opaque CoreMedia error — so this is the only reliable HTTP signal and
+  ///   it outranks the error itself.
+  func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool {
+    if let status = httpStatusCode {
+      let retryable = Self.retryableHTTPStatusCodes.contains(status) || (500 ... 599).contains(status)
+      logger.debug("HTTP \(status) \(retryable ? "is" : "not") retryable")
+      return retryable
+    }
+
     guard let error else { return false }
 
-    if let urlError = error as? URLError {
-      switch urlError.code {
-      // Transient network errors - safe to retry
-      case .timedOut,
-           .networkConnectionLost,
-           .notConnectedToInternet,
-           .cannotConnectToHost,
-           .cannotFindHost,
-           .dnsLookupFailed:
-        logger.debug("URLError is retryable: code=\(urlError.code.rawValue)")
-        return true
-      default:
-        logger.debug("URLError not retryable: code=\(urlError.code.rawValue)")
+    // Walk the underlying-error chain: AVFoundation routinely wraps the real
+    // cause (a URLError, or a CoreMedia code) in an AVError.
+    for candidate in Self.errorChain(error) {
+      if let urlError = candidate as? URLError {
+        switch urlError.code {
+        // Transient network errors - safe to retry
+        case .timedOut,
+             .networkConnectionLost,
+             .notConnectedToInternet,
+             .cannotConnectToHost,
+             .cannotFindHost,
+             .dnsLookupFailed:
+          logger.debug("URLError is retryable: code=\(urlError.code.rawValue)")
+          return true
+        default:
+          logger.debug("URLError not retryable: code=\(urlError.code.rawValue)")
+          return false
+        }
+      }
+
+      let nsError = candidate as NSError
+      if nsError.domain == AVFoundationErrorDomain,
+         Self.fatalAVErrorCodes.contains(nsError.code)
+      {
+        logger.debug("AVError not retryable: code=\(nsError.code)")
         return false
       }
     }
 
-    // Unknown errors - don't retry
     let nsError = error as NSError
-    logger.debug("Error not retryable: domain=\(nsError.domain), code=\(nsError.code)")
-    return false
+    logger.debug("Treating as transient: domain=\(nsError.domain), code=\(nsError.code)")
+    return true
+  }
+
+  /// The error and its `NSUnderlyingError` ancestors, outermost first.
+  private static func errorChain(_ error: Error) -> [Error] {
+    var chain: [Error] = []
+    var current: Error? = error
+    // Bounded: a malformed cycle must not spin here.
+    while let error = current, chain.count < 8 {
+      chain.append(error)
+      current = (error as NSError).userInfo[NSUnderlyingErrorKey] as? Error
+    }
+    return chain
   }
 
   // MARK: - Retry Management
@@ -170,7 +230,8 @@ class RetryManager {
       return "max retry duration (\(maxRetryDuration)s)"
     }
     if !hasPlayed, isOnline, let start = firstOnlineRetryTime,
-       now.timeIntervalSince(start) >= firstConnectMaxRetryDuration {
+       now.timeIntervalSince(start) >= firstConnectMaxRetryDuration
+    {
       return "first-connect retry duration (\(firstConnectMaxRetryDuration)s)"
     }
     return nil

package/ios/Player/ShuffleOrder.swift

@@ -39,6 +39,16 @@ struct ShuffleOrder {
     indexInShuffled = Self.buildIndexInShuffled(from: shuffled)
   }
 
+  /// Creates a shuffle order for the given length with `firstIndex` pinned to shuffle position 0.
+  ///
+  /// Playback starts on that track, so leaving it wherever the permutation put it would end the
+  /// queue as soon as it is reached — on average after half the queue, and immediately whenever it
+  /// lands last.
+  init(length: Int, firstIndex: Int) {
+    self.init(length: length)
+    reshuffle(keepingFirst: firstIndex)
+  }
+
   /// Creates a shuffle order with pre-defined indices
   init(shuffledIndices: [Int]) {
     shuffled = shuffledIndices

package/ios/Player/SleepTimerManager.swift

@@ -7,15 +7,51 @@ import Foundation
 /// Type alias for the Nitro SleepTimer variant type
 typealias SleepTimerState = SleepTimer
 
+/// A scheduled job that has not run yet. `cancel()` is nonisolated so `deinit`
+/// — always nonisolated in Swift 6 — can tear pending work down.
+protocol SleepTimerJob: AnyObject {
+  func cancel()
+}
+
+extension DispatchWorkItem: SleepTimerJob {}
+
+/// Runs work after a delay. Injected into `SleepTimerManager` so tests can
+/// drive the clock instead of racing it: production schedules on the main
+/// queue, tests hand in a scheduler they advance by hand.
+@MainActor
+protocol SleepTimerScheduling {
+  func schedule(
+    after delay: TimeInterval,
+    _ work: @escaping @Sendable @MainActor () -> Void,
+  ) -> any SleepTimerJob
+}
+
+struct MainQueueSleepTimerScheduler: SleepTimerScheduling {
+  func schedule(
+    after delay: TimeInterval,
+    _ work: @escaping @Sendable @MainActor () -> Void,
+  ) -> any SleepTimerJob {
+    let job = DispatchWorkItem { MainActor.assumeIsolated { work() } }
+    DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: job)
+    return job
+  }
+}
+
 /// Manages sleep timer functionality for the audio player.
 /// Supports both time-based timers and end-of-track timers.
 @MainActor
 class SleepTimerManager: SleepTimerHandling {
   // MARK: - Properties
 
+  private let scheduler: any SleepTimerScheduling
+
   // nonisolated(unsafe) for deinit cleanup — deinit is always nonisolated in Swift 6.
-  private nonisolated(unsafe) var sleepTimerJob: DispatchWorkItem?
-  private nonisolated(unsafe) var fadeJob: DispatchWorkItem?
+  private nonisolated(unsafe) var sleepTimerJob: (any SleepTimerJob)?
+  private nonisolated(unsafe) var fadeJob: (any SleepTimerJob)?
+
+  init(scheduler: any SleepTimerScheduling = MainQueueSleepTimerScheduler()) {
+    self.scheduler = scheduler
+  }
 
   /// The time when playback should stop (seconds since epoch), or -1 if inactive
   private(set) var sleepTimerTime: TimeInterval = -1 {
@@ -94,23 +130,15 @@ class SleepTimerManager: SleepTimerHandling {
   func set(seconds: TimeInterval, fadeDuration: TimeInterval? = nil) {
     cancelSleepTimerJob()
     onFadeCancel?()
-    let job = DispatchWorkItem { [weak self] in
-      MainActor.assumeIsolated {
-        self?.complete()
-      }
-    }
-    sleepTimerJob = job
     sleepTimerTime = Date().timeIntervalSince1970 + seconds
-    DispatchQueue.main.asyncAfter(deadline: .now() + seconds, execute: job)
+    sleepTimerJob = scheduler.schedule(after: seconds) { [weak self] in
+      self?.complete()
+    }
     if let fadeDuration, fadeDuration > 0 {
       let fade = min(fadeDuration, seconds)
-      let fadeJob = DispatchWorkItem { [weak self] in
-        MainActor.assumeIsolated {
-          self?.onFadeStart?(fade)
-        }
+      fadeJob = scheduler.schedule(after: seconds - fade) { [weak self] in
+        self?.onFadeStart?(fade)
       }
-      self.fadeJob = fadeJob
-      DispatchQueue.main.asyncAfter(deadline: .now() + (seconds - fade), execute: fadeJob)
     }
     if let state = get() { onChanged?(state) }
   }

package/ios/RemoteCommand/RemoteCommandCallbacks.swift

@@ -0,0 +1,47 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+/// The callbacks `RemoteCommandController` invokes when the system delivers a
+/// remote command (lock screen, Control Center, CarPlay, headset).
+///
+/// Split out of `TrackPlayerCallbacks` — which the controller does not otherwise
+/// use — so the controller depends only on what it calls. `TrackPlayerCallbacks`
+/// extends this protocol, so conformers implement both at once.
+@MainActor protocol RemoteCommandCallbacks: AnyObject {
+  /// Called when play is triggered remotely.
+  func remotePlay()
+
+  /// Called when pause is triggered remotely.
+  func remotePause()
+
+  /// Called when stop is triggered remotely.
+  func remoteStop()
+
+  /// Called when toggle play/pause is triggered remotely.
+  func remotePlayPause()
+
+  /// Called when next is triggered remotely.
+  func remoteNext()
+
+  /// Called when previous is triggered remotely.
+  func remotePrevious()
+
+  /// Called when jump forward is triggered remotely.
+  func remoteJumpForward(interval: Double)
+
+  /// Called when jump backward is triggered remotely.
+  func remoteJumpBackward(interval: Double)
+
+  /// Called when seek is triggered remotely.
+  func remoteSeek(position: Double)
+
+  /// Called when repeat mode change is triggered remotely (CarPlay/lock screen).
+  func remoteChangeRepeatMode(mode: RepeatMode)
+
+  /// Called when shuffle mode change is triggered remotely (CarPlay/lock screen).
+  func remoteChangeShuffleMode(enabled: Bool)
+
+  /// Called when playback rate change is triggered remotely (CarPlay/lock screen).
+  func remoteChangePlaybackRate(rate: Float)
+}

package/ios/RemoteCommand/RemoteCommandController.swift

@@ -46,7 +46,7 @@ class RemoteCommandController {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "RemoteCommandController")
   private var center: MPRemoteCommandCenter
 
-  weak var callbacks: TrackPlayerCallbacks?
+  weak var callbacks: RemoteCommandCallbacks?
 
   var commandTargetPointers: [String: Any] = [:]
   private var enabledCommands: [RemoteCommand] = []
@@ -72,7 +72,7 @@ class RemoteCommandController {
    */
   init(
     remoteCommandCenter: MPRemoteCommandCenter = MPRemoteCommandCenter.shared(),
-    callbacks: TrackPlayerCallbacks? = nil,
+    callbacks: RemoteCommandCallbacks? = nil,
   ) {
     center = remoteCommandCenter
     self.callbacks = callbacks
@@ -112,13 +112,16 @@ class RemoteCommandController {
   }
 
   func enable(commands: [RemoteCommand]) {
-    let commandsToDisable = enabledCommands.filter { command in
-      !commands.contains(command)
-    }
+    let commandsToDisable = RemoteCommand.commandsToDisable(
+      enabled: enabledCommands, replacedBy: commands,
+    )
 
     enabledCommands = commands
-    commands.forEach { self.enable(command: $0) }
+    // Disable first. The key diff already makes the two sets disjoint, so this
+    // is belt-and-braces: it keeps a disable from tearing down a command the
+    // enable pass just configured should the two ever overlap again.
     disable(commands: commandsToDisable)
+    commands.forEach { self.enable(command: $0) }
   }
 
   func disable(commands: [RemoteCommand]) {

package/ios/Tests/LRUCacheTests.swift

@@ -0,0 +1,111 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("LRUCache")
+struct LRUCacheTests {
+  /// A class so the tests can observe release through a weak reference.
+  private final class Box {
+    let id: Int
+    init(_ id: Int) { self.id = id }
+  }
+
+  @Test func evictsTheLeastRecentlyUsed() {
+    let cache = LRUCache<String, Int>(maxSize: 2)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    cache.set("c", value: 3)
+
+    #expect(cache.get("a") == nil)
+    #expect(cache.get("b") == 2)
+    #expect(cache.get("c") == 3)
+    #expect(cache.count == 2)
+  }
+
+  /// A read is a use: it must move the entry off the eviction end.
+  @Test func readingPromotesAnEntry() {
+    let cache = LRUCache<String, Int>(maxSize: 2)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    _ = cache.get("a")
+    cache.set("c", value: 3)
+
+    #expect(cache.get("a") == 1)
+    #expect(cache.get("b") == nil)
+  }
+
+  @Test func removeDropsOnlyItsOwnEntry() {
+    let cache = LRUCache<String, Int>(maxSize: 3)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    cache.set("c", value: 3)
+
+    cache.remove("b")
+
+    #expect(cache.get("b") == nil)
+    #expect(cache.get("a") == 1)
+    #expect(cache.get("c") == 3)
+    #expect(cache.count == 2)
+  }
+
+  /// The nodes form a doubly-linked list. If both directions were strong, adjacent nodes would
+  /// retain each other and clearing would drop only the dictionary and the two ends — the chain,
+  /// and everything it holds, would survive (#96).
+  @Test func clearReleasesEveryNode() {
+    let cache = LRUCache<String, Box>(maxSize: 10)
+    weak var first: Box?
+    weak var middle: Box?
+    weak var last: Box?
+
+    do {
+      let a = Box(1), b = Box(2), c = Box(3)
+      (first, middle, last) = (a, b, c)
+      cache.set("a", value: a)
+      cache.set("b", value: b)
+      cache.set("c", value: c)
+    }
+
+    #expect(first != nil, "the cache should still hold its entries")
+
+    cache.clear()
+
+    #expect(first == nil)
+    #expect(middle == nil)
+    #expect(last == nil)
+    #expect(cache.count == 0)
+  }
+
+  /// Same cycle, reached by dropping the cache itself rather than clearing it.
+  @Test func droppingTheCacheReleasesEveryNode() {
+    weak var first: Box?
+    weak var last: Box?
+
+    do {
+      let cache = LRUCache<String, Box>(maxSize: 10)
+      let a = Box(1), b = Box(2)
+      (first, last) = (a, b)
+      cache.set("a", value: a)
+      cache.set("b", value: b)
+      #expect(first != nil)
+    }
+
+    #expect(first == nil)
+    #expect(last == nil)
+  }
+
+  /// Eviction has always unlinked the node it drops; this pins that down alongside the rest.
+  @Test func evictionReleasesTheEvictedNode() {
+    let cache = LRUCache<String, Box>(maxSize: 1)
+    weak var evicted: Box?
+
+    do {
+      let a = Box(1)
+      evicted = a
+      cache.set("a", value: a)
+      cache.set("b", value: Box(2))
+    }
+
+    #expect(evicted == nil)
+  }
+}

package/ios/Tests/LoadSeekCoordinatorTests.swift

@@ -246,7 +246,9 @@ struct ResetTests {
     c.capture(position: 25.0)
 
     // Let the (immediately-cancelled, itemless) seek completion drain.
-    for _ in 0 ..< 20 { await Task.yield() }
+    for _ in 0 ..< 20 {
+      await Task.yield()
+    }
 
     #expect(spy.calls.isEmpty)
     #expect(c.pendingTime == 25.0)

package/ios/Tests/MediaIntentCriteriaTests.swift

@@ -57,12 +57,12 @@ struct MediaIntentCriteriaFromTests {
     mediaTypeMode: String? = nil,
     reference: MediaIntentCriteria.Reference = .unknown,
     hasMediaType: Bool = false,
-    appName: String? = "Radio Garden"
+    appName: String? = "Radio Garden",
   ) -> MediaIntentCriteria {
     MediaIntentCriteria.from(
       mediaName: mediaName, genreNames: genreNames, artistName: artistName,
       albumName: albumName, mediaTypeMode: mediaTypeMode,
-      reference: reference, hasMediaType: hasMediaType, appName: appName
+      reference: reference, hasMediaType: hasMediaType, appName: appName,
     )
   }
 

package/ios/Tests/MediaLoaderTests.swift

@@ -123,8 +123,7 @@ struct ResolveAndLoadTests {
     }
     loader.resolveAndLoad(src: "https://example.com/audio.mp3")
 
-    // Allow the resolver task to run
-    await Task.yield()
+    await loader.mediaResolverTask?.value
 
     #expect(resolverCalled == true)
   }
@@ -136,12 +135,9 @@ struct ResolveAndLoadTests {
     }
     loader.resolveAndLoad(src: "https://example.com/audio.mp3")
 
-    // The resolver runs in a Task that awaits the resolver then does MainActor.run,
-    // so we need multiple yields for the full chain to settle.
-    for _ in 0 ..< 10 {
-      await Task.yield()
-      if !spy.playbackErrors.isEmpty { break }
-    }
+    // The task awaits the resolver then hops back to the main actor, so the
+    // delegate call has landed by the time the task itself completes.
+    await loader.mediaResolverTask?.value
 
     #expect(spy.playbackErrors.count == 1)
     if case let .invalidSourceUrl(url) = spy.playbackErrors.first {
@@ -166,8 +162,8 @@ struct ResolveAndLoadTests {
     // Immediately start second — should cancel first
     loader.resolveAndLoad(src: "https://example.com/second.mp3")
 
-    // Wait for both to settle
-    try? await Task.sleep(for: .milliseconds(200))
+    // Await the surviving task; the cancelled one bailed before its resolver.
+    await loader.mediaResolverTask?.value
 
     // Only the second resolver should have run (first was cancelled before calling resolver)
     #expect(callCount == 1)
@@ -188,10 +184,11 @@ struct CancelAllTests {
       return MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
     }
     loader.resolveAndLoad(src: "https://example.com/audio.mp3")
+    // cancelAll() drops the handle, so grab it first to await the point where
+    // the callback would have fired.
+    let resolve = loader.mediaResolverTask
     loader.cancelAll()
-
-    // Wait for what would have been the callback
-    try? await Task.sleep(for: .milliseconds(100))
+    await resolve?.value
 
     #expect(spy.preparedItems.isEmpty)
     #expect(spy.playbackErrors.isEmpty)

package/ios/Tests/PlaybackCoordinatorTests.swift

@@ -120,7 +120,7 @@ struct TransitionTests {
 @MainActor
 private func makeRetrying() -> (
   PlaybackCoordinator, MockRetryHandling, MockPlaybackCoordinatorCallbacks,
-  MockPlaybackEffectHandler
+  MockPlaybackEffectHandler,
 ) {
   let retryHandler = MockRetryHandling()
   retryHandler.isRetryableResult = true
@@ -743,7 +743,7 @@ struct NaturalEndPlayIntentTests {
 @Suite("PlaybackCoordinator - healthy playback resets retry budget")
 struct HealthyPlaybackRetryResetTests {
   @Test @MainActor
-  func sustainedPlayback_resetsRetryBudget() async throws {
+  func sustainedPlayback_resetsRetryBudget() async {
     let retryHandler = MockRetryHandling()
     let errorHandler = PlaybackErrorHandler(retryHandler: retryHandler)
     let coordinator = PlaybackCoordinator(
@@ -754,7 +754,7 @@ struct HealthyPlaybackRetryResetTests {
     coordinator.healthyPlaybackDuration = 0.01
 
     coordinator.transition(.avPlayerPlaying)
-    try await Task.sleep(nanoseconds: 100_000_000)
+    await coordinator.healthyPlaybackTask?.value
 
     #expect(retryHandler.resetCallCount == 1)
   }
@@ -762,7 +762,7 @@ struct HealthyPlaybackRetryResetTests {
   /// resetRetry() cancels a pending retry — firing the refill mid-episode
   /// would kill an in-flight reconnect silently (stuck .playing forever).
   @Test @MainActor
-  func refill_skipsWhileRetryIsPending() async throws {
+  func refill_skipsWhileRetryIsPending() async {
     let retryHandler = MockRetryHandling()
     retryHandler.isRetryableResult = true
     retryHandler.attemptRetryDelayNs = 1_000_000_000
@@ -776,14 +776,14 @@ struct HealthyPlaybackRetryResetTests {
 
     coordinator.transition(.avPlayerPlaying)
     errorHandler.handleError(URLError(.timedOut), context: .playback)
-    try await Task.sleep(nanoseconds: 100_000_000)
+    await coordinator.healthyPlaybackTask?.value
 
     #expect(retryHandler.resetCallCount == 0)
     #expect(errorHandler.pendingRetryTask != nil)
   }
 
   @Test @MainActor
-  func playbackInterruptedBeforeThreshold_doesNotReset() async throws {
+  func playbackInterruptedBeforeThreshold_doesNotReset() async {
     let retryHandler = MockRetryHandling()
     let errorHandler = PlaybackErrorHandler(retryHandler: retryHandler)
     let coordinator = PlaybackCoordinator(
@@ -795,9 +795,12 @@ struct HealthyPlaybackRetryResetTests {
     coordinator.healthyPlaybackDuration = 0.5
 
     coordinator.transition(.avPlayerPlaying)
+    let refill = coordinator.healthyPlaybackTask
     coordinator.transition(.avPlayerWaiting) // stalls before the threshold
 
-    try await Task.sleep(nanoseconds: 100_000_000)
+    // Leaving .playing cancels the refill; awaiting the cancelled task is the
+    // deterministic way to reach the point where it would have fired.
+    await refill?.value
 
     #expect(retryHandler.resetCallCount == 0)
   }

package/ios/Tests/PlaybackErrorHandlerTests.swift

@@ -14,9 +14,11 @@ private final class MockRetryHandler: RetryHandling {
   var attemptRetryResult = false
   var attemptRetryCallCount = 0
   var lastStartFromCurrentTime: Bool?
+  var lastHTTPStatusCode: Int??
   var resetCallCount = 0
 
-  func isRetryable(_ error: Error?) -> Bool {
+  func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool {
+    lastHTTPStatusCode = .some(httpStatusCode)
     guard let error else { return false }
     let code = (error as NSError).code
     return retryableErrors.contains(code)

package/ios/Tests/PlayerTimeObserverTests.swift

@@ -0,0 +1,37 @@
+import AVFoundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@MainActor
+@Suite("PlayerTimeObserver")
+struct PlayerTimeObserverTests {
+  /// An AVPlayer retains its time observers, so one left registered outlives both this object and
+  /// the caller's interest in it (#96).
+  @Test func unregisteringDropsTheToken() {
+    // Held: `avPlayer` is weak, so a temporary is gone before the next line.
+    let player = AVPlayer()
+    let observer = PlayerTimeObserver(onAudioDidStart: {})
+    observer.avPlayer = player
+
+    observer.registerForBoundaryTimeEvents()
+    #expect(observer.boundaryTimeStartObserverToken != nil)
+
+    observer.unregisterForBoundaryTimeEvents()
+    #expect(observer.boundaryTimeStartObserverToken == nil)
+  }
+
+  /// Swapping players has to unregister from the outgoing one — it is a different AVPlayer, and
+  /// the token cannot be removed from it afterwards.
+  @Test func swappingPlayersUnregistersFromThePrevious() {
+    let first = AVPlayer()
+    let second = AVPlayer()
+    let observer = PlayerTimeObserver(onAudioDidStart: {})
+    observer.avPlayer = first
+    observer.registerForBoundaryTimeEvents()
+
+    observer.avPlayer = second
+
+    #expect(observer.boundaryTimeStartObserverToken == nil)
+  }
+}