react-native-queue-player 1.0.3 → 1.0.6

package/ios/Tests/AudioTapProviderReplayGainTests.swift

@@ -3,19 +3,15 @@ import XCTest
 @testable import QueuePlayer
 
 /// Unit tests for the ReplayGain mode + gain-math paths in
-/// `AudioTapProvider`. The metadata-extraction async path + per-item
-/// recompute walk are covered at the integration layer (auto-suite
-/// `replaygain.ts` step). These tests drive the pure
+/// `AudioTapProvider`. These tests drive the pure
 /// `computeLinearGain(data:mode:)` static helper plus the mode
 /// getter/setter round-trip.
 final class AudioTapProviderReplayGainTests: XCTestCase {
 
-  // Mode getter / setter round-trip is exercised at the integration
-  // layer (`replaygain.ts` auto-suite) — `getReplayGainMode`'s
-  // `ReplayGainMode` return type touches the Swift↔C++ interop
-  // graph, so direct equality from `@testable` XCTest can't observe
-  // it (NOTES.md §6). The pure gain-math matrix below is the unit
-  // surface; mode propagation lands in the integration tests.
+  // `getReplayGainMode`'s `ReplayGainMode` return type touches the
+  // Swift↔C++ interop graph, so direct equality from `@testable`
+  // XCTest can't observe it (NOTES.md §6). The pure gain-math matrix
+  // below is the unit surface.
 
   // MARK: - computeLinearGain — strict mode + selection
 

package/ios/Tests/CarPlayBridgeTests.swift

@@ -2,9 +2,7 @@ import XCTest
 @testable import QueuePlayer
 
 /// `CarPlayBridge` tests cover only the registration/dispose/clear
-/// state machine. Promise-await dispatch is exercised by the
-/// production scene delegate + browse builder via integration paths;
-/// the unit suite stays focused on the slot semantics. The
+/// state machine — the slot semantics. The
 /// Android-side `BrowseCallbackRegistry` exposes suspending
 /// `await*Callback()` helpers because its dispatch sites coroutine-
 /// poll for cold-start race recovery; iOS uses NotificationCenter
@@ -18,9 +16,7 @@ final class CarPlayBridgeTests: XCTestCase {
     // The browse / playFromId slot reads return a Promise of a
     // Nitrogen-bridged type, which Swift cxx-interop excludes from
     // `@testable import`. Their slots use the identical `Slot<>`
-    // machinery asserted here for connect/disconnect, and their
-    // dispatch is covered at the integration layer (scene delegate +
-    // browse builder).
+    // machinery asserted here for connect/disconnect.
     XCTAssertNil(bridge.carConnectCallback())
     XCTAssertNil(bridge.carDisconnectCallback())
   }

package/ios/Tests/CarPlayBrowseBuilderTests.swift

@@ -5,8 +5,7 @@ import XCTest
 /// Coverage for [CarPlayBrowseBuilder] — snapshot → template
 /// conversion, item count + accessory mapping, pagination against
 /// `CPListTemplate.maximumItemCount`. Direct method calls on the
-/// builder; the scene delegate's full lifecycle is covered by the
-/// CarPlay Sim manual playbook.
+/// builder; the scene delegate's full lifecycle is out of scope here.
 final class CarPlayBrowseBuilderTests: XCTestCase {
 
   private func item(

package/ios/Tests/CarPlayCoordinatorTests.swift

@@ -0,0 +1,35 @@
+import XCTest
+@testable import QueuePlayer
+
+/// `CarPlayCoordinator` connection-flag tests. The flag is written by the
+/// CarPlay scene delegate at scene attach / detach; this suite locks the
+/// get/set contract the `isCarConnected()` getter reads back.
+final class CarPlayCoordinatorTests: XCTestCase {
+
+  override func setUp() {
+    super.setUp()
+    // Shared process-wide singleton — start from a known-disconnected state
+    // regardless of test order.
+    CarPlayCoordinator.shared.setCarConnected(false)
+  }
+
+  override func tearDown() {
+    // Shared process-wide singleton — leave it disconnected so it can't
+    // leak a connected state into another suite.
+    CarPlayCoordinator.shared.setCarConnected(false)
+    super.tearDown()
+  }
+
+  func testCarConnectedFlagReflectsSetter() {
+    let coordinator = CarPlayCoordinator.shared
+
+    coordinator.setCarConnected(false)
+    XCTAssertFalse(coordinator.isCarConnected, "disconnected after setCarConnected(false)")
+
+    coordinator.setCarConnected(true)
+    XCTAssertTrue(coordinator.isCarConnected, "connected after setCarConnected(true)")
+
+    coordinator.setCarConnected(false)
+    XCTAssertFalse(coordinator.isCarConnected, "disconnected again after setCarConnected(false)")
+  }
+}

package/ios/Tests/CarPlayQueueBuilderTests.swift

@@ -0,0 +1,145 @@
+import CarPlay
+import XCTest
+@testable import QueuePlayer
+
+/// Coverage for [CarPlayQueueBuilder] — snapshot → Up Next template
+/// conversion, row count + title/detail mapping, truncation at
+/// `CPListTemplate.maximumItemCount`, current-index marking, and the
+/// row-tap skip closure — plus a [CarPlayQueueProvider] round-trip.
+final class CarPlayQueueBuilderTests: XCTestCase {
+
+  private func entry(
+    _ title: String,
+    subtitle: String? = nil,
+    artworkUrl: String? = nil
+  ) -> CarPlayQueueEntry {
+    CarPlayQueueEntry(title: title, subtitle: subtitle, artworkUrl: artworkUrl)
+  }
+
+  private func snapshot(
+    _ entries: [CarPlayQueueEntry],
+    currentIndex: Int
+  ) -> CarPlayQueueSnapshot {
+    CarPlayQueueSnapshot(entries: entries, currentIndex: currentIndex)
+  }
+
+  // MARK: - Template construction
+
+  func testBuildQueueTemplateMapsEntriesToRows() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot(
+        [
+          entry("Everlong", subtitle: "Foo Fighters"),
+          entry("Monkey Wrench", subtitle: "Foo Fighters"),
+        ],
+        currentIndex: 0
+      ),
+      loader: loader,
+      skip: { _ in }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    XCTAssertEqual(items.count, 2)
+    XCTAssertEqual(items[0].text, "Everlong")
+    XCTAssertEqual(items[0].detailText, "Foo Fighters")
+    XCTAssertEqual(items[1].text, "Monkey Wrench")
+  }
+
+  func testBuildQueueTemplateCapsRowsAtMaximumItemCount() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let cap = 5
+    let entries = (0..<cap + 4).map { entry("T-\($0)") }
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot(entries, currentIndex: 0),
+      loader: loader,
+      maximumItemCount: cap,
+      skip: { _ in }
+    )
+    let items = template.sections.first?.items ?? []
+    XCTAssertEqual(items.count, cap)
+  }
+
+  func testBuildQueueTemplateMarksCurrentIndex() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot(
+        [entry("A"), entry("B"), entry("C")],
+        currentIndex: 1
+      ),
+      loader: loader,
+      skip: { _ in }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    XCTAssertFalse(items[0].isPlaying)
+    XCTAssertTrue(items[1].isPlaying)
+    XCTAssertFalse(items[2].isPlaying)
+  }
+
+  func testBuildQueueTemplateMarksNothingWhenIndexOutOfRange() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot([entry("A"), entry("B")], currentIndex: -1),
+      loader: loader,
+      skip: { _ in }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    XCTAssertTrue(items.allSatisfy { !$0.isPlaying })
+  }
+
+  // MARK: - Row-tap skip
+
+  func testRowTapInvokesSkipWithRowIndex() {
+    let builder = CarPlayQueueBuilder()
+    let loader = ArtworkLoader()
+    var skippedTo: Int?
+    let template = builder.buildQueueTemplate(
+      snapshot: snapshot([entry("A"), entry("B"), entry("C")], currentIndex: 0),
+      loader: loader,
+      skip: { skippedTo = $0 }
+    )
+    let items = (template.sections.first?.items ?? []).compactMap { $0 as? CPListItem }
+    let exp = expectation(description: "row handler completes")
+    items[2].handler?(items[2]) { exp.fulfill() }
+    wait(for: [exp], timeout: 2)
+    XCTAssertEqual(skippedTo, 2)
+  }
+
+  // MARK: - Provider round-trip
+
+  func testProviderSetSnapshotMakesSnapshotReadable() {
+    let provider = CarPlayQueueProvider()
+    XCTAssertNil(provider.getSnapshot())
+    provider.setSnapshot(
+      snapshot([entry("A", subtitle: "sub")], currentIndex: 0)
+    )
+    let read = provider.getSnapshot()
+    XCTAssertEqual(read?.entries.count, 1)
+    XCTAssertEqual(read?.entries.first?.title, "A")
+    XCTAssertEqual(read?.entries.first?.subtitle, "sub")
+    XCTAssertEqual(read?.currentIndex, 0)
+  }
+
+  func testProviderSetSnapshotNilClearsCache() {
+    let provider = CarPlayQueueProvider()
+    provider.setSnapshot(snapshot([entry("A")], currentIndex: 0))
+    provider.setSnapshot(nil)
+    XCTAssertNil(provider.getSnapshot())
+  }
+
+  func testProviderSetSnapshotPostsDidUpdateNotification() {
+    let provider = CarPlayQueueProvider()
+    let exp = expectation(
+      forNotification: CarPlayQueueProvider.didUpdateNotification,
+      object: provider,
+      handler: nil
+    )
+    DispatchQueue.global().async {
+      provider.setSnapshot(self.snapshot([self.entry("A")], currentIndex: 0))
+    }
+    wait(for: [exp], timeout: 2)
+  }
+}

package/ios/Tests/EQProcessorTests.swift

@@ -1,10 +1,7 @@
 import XCTest
 @testable import QueuePlayer
 
-/// Unit coverage for `EQProcessor` cascade. Audible response
-/// (sine-sweep magnitude per band) is verified at the integration
-/// layer via the demo Maestro EQ suite once the AVPlayerItem mix
-/// attach path is wired.
+/// Unit coverage for `EQProcessor` cascade.
 final class EQProcessorTests: XCTestCase {
 
   func testIsNotReadyBeforeChannelCountSet() {

package/ios/Tests/EQTapTests.swift

@@ -4,8 +4,7 @@ import XCTest
 
 /// Skeleton coverage for `EQTap` — tap creation, HLS detection,
 /// pass-through process body. The actual tap firing is on the
-/// audio render thread and verified at the integration layer via
-/// the demo Maestro EQ suite once the DSP body lands.
+/// audio render thread.
 final class EQTapTests: XCTestCase {
 
   func testPassThroughCopiesInputToOutput() {

package/ios/Tests/EqualizerAudioMixProviderTests.swift

@@ -2,10 +2,9 @@ import AVFoundation
 import XCTest
 @testable import QueuePlayer
 
-/// Provider-layer coverage for the shared `AudioTapProvider`. Real
-/// audio routing is verified at the integration layer via the demo
-/// Maestro EQ + visualizer suites; these tests cover the
-/// configuration + bypass + consumer-registration surface.
+/// Provider-layer coverage for the shared `AudioTapProvider`. These
+/// tests cover the configuration + bypass + consumer-registration
+/// surface.
 ///
 /// Filename note: kept at `EqualizerAudioMixProviderTests.swift`
 /// even though the class is `AudioTapProviderTests`. Renaming the

package/ios/Tests/EqualizerHybridTests.swift

@@ -3,9 +3,7 @@ import XCTest
 @testable import QueuePlayer
 
 /// Wiring coverage for the iOS `Equalizer` HybridObject.
-/// Targets the synchronous internal core; the async Promise-
-/// returning surface is exercised at integration via the demo
-/// Maestro EQ suite.
+/// Targets the synchronous internal core.
 final class EqualizerHybridTests: XCTestCase {
 
   private var defaults: UserDefaults!

package/ios/Tests/FFTProcessorTests.swift

@@ -33,7 +33,7 @@ final class FFTProcessorTests: XCTestCase {
     samples.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: n, sampleRate: 48000)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     XCTAssertEqual(capturedSampleRate, 48000, accuracy: 0.001)
   }
 
@@ -57,7 +57,7 @@ final class FFTProcessorTests: XCTestCase {
     rest.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 256, sampleRate: 44100)
     }
-    wait(for: [emitted], timeout: 1.0)
+    wait(for: [emitted], timeout: 5.0)
     XCTAssertEqual(calls, 1)
   }
 
@@ -74,7 +74,7 @@ final class FFTProcessorTests: XCTestCase {
     buffer.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 128, sampleRate: 44100)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     let samples = try XCTUnwrap(capturedSamples)
     XCTAssertEqual(samples.size, 128 * MemoryLayout<Float>.size)
   }
@@ -94,7 +94,7 @@ final class FFTProcessorTests: XCTestCase {
     buffer.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 128, sampleRate: 44100)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     XCTAssertTrue(captured)
     XCTAssertNil(capturedSamples)
   }
@@ -117,7 +117,7 @@ final class FFTProcessorTests: XCTestCase {
     samples.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: n, sampleRate: 48000)
     }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     let fft = try XCTUnwrap(capturedFft)
     let mags = arrayBufferToFloats(fft)
     let peakBin = mags.indices.max(by: { mags[$0] < mags[$1] }) ?? -1
@@ -205,7 +205,7 @@ final class FFTProcessorTests: XCTestCase {
     closure(leftIn, leftOut, n, 1, 0, 2)
     closure(rightIn, rightOut, n, 1, 1, 2)
 
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [exp], timeout: 5.0)
     let samples = try XCTUnwrap(capturedSamples)
     XCTAssertEqual(samples.size, n * MemoryLayout<Float>.size)
 
@@ -233,7 +233,9 @@ final class FFTProcessorTests: XCTestCase {
     }
     let exp = expectation(description: "drained")
     DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { exp.fulfill() }
-    wait(for: [exp], timeout: 1.0)
+    // Generous timeout: the 0.1s drain only needs to outlast the 1000ms
+    // throttle window; the ceiling is headroom for a loaded CI main queue.
+    wait(for: [exp], timeout: 10.0)
     XCTAssertEqual(calls, 1, "second back-to-back call must be throttled")
   }
 
@@ -243,9 +245,7 @@ final class FFTProcessorTests: XCTestCase {
     // `ingest` resumes, `onFrame` fires again at the documented
     // intervalMs cadence. Live audio chains express "pause" by
     // ceasing tap callbacks; the unit-test analogue is a sleep
-    // window. End-to-end pause/play coverage lives in the
-    // `visualizer:*` integration suite's `pause-stops-resume-restarts`
-    // step.
+    // window.
     let n = 256
     let intervalMs = 1
     let lock = NSLock()

package/ios/Tests/GaplessEngineLifecycleTests.swift

@@ -4,8 +4,6 @@ import XCTest
 
 /// Lifecycle smoke coverage for `GaplessEngine` — empty-queue
 /// sentinels + idempotent / delegate-clearing release contract.
-/// Behavioural coverage of transport + seek runs through the
-/// existing TrackPlayer integration suites + Maestro flows.
 final class GaplessEngineLifecycleTests: XCTestCase {
 
   func testEmptyQueueReturnsDocumentedSentinelState() {

package/ios/Tests/LookaheadCacheEvictionTests.swift

@@ -4,10 +4,7 @@ import XCTest
 
 /// `LookaheadCacheEviction.computeEvictions` unit tests.
 ///
-/// Pure-logic LRU policy. Plain JUnit-equivalent — no FS access, no
-/// URLSession. File + index mutation is tested through the
-/// LookaheadCacheTests integration path that drives `download` past
-/// the budget.
+/// Pure-logic LRU policy. No FS access, no URLSession.
 final class LookaheadCacheEvictionTests: XCTestCase {
 
   func testNoEvictionWhenUnderBudget() {

package/ios/Tests/MetadataReaderTests.swift

@@ -4,8 +4,6 @@ import XCTest
 /// Byte-level unit tests for `MetadataReader`'s container parsers.
 /// Builds synthetic ID3v2 / FLAC / MP4 byte sequences in-memory and
 /// verifies tag extraction surfaces the expected `[key: value]` map.
-/// End-to-end "extract from a real media file" coverage lives in
-/// the auto-suite `replaygain.ts`.
 final class MetadataReaderTests: XCTestCase {
 
   // MARK: - ID3v2 TXXX

package/ios/Tests/MilestoneTrackerTests.swift

@@ -2,9 +2,7 @@ import XCTest
 @testable import QueuePlayer
 
 /// Unit tests for `MilestoneTracker` — the pure 25/50/75/90% crossing
-/// logic behind `onPlaybackMilestone`. Native wiring (progress tick,
-/// seek, track-change reset) is covered by the `playback-milestones`
-/// demo suite.
+/// logic behind `onPlaybackMilestone`.
 final class MilestoneTrackerTests: XCTestCase {
 
   /// 200s track, ticks every ~10s of media time.

package/ios/Tests/NowPlayingFormatExtractorTests.swift

@@ -3,10 +3,9 @@ import CoreMedia
 import XCTest
 @testable import QueuePlayer
 
-/// Pure-mapping coverage for `NowPlayingFormatExtractor`. The async
-/// `extract(item:)` path is exercised end-to-end through the demo
-/// suites; these tests pin the codec / container / MIME tables so a
-/// future contributor can't drift the JS-visible enum without a test
+/// Pure-mapping coverage for `NowPlayingFormatExtractor`. These
+/// tests pin the codec / container / MIME tables so a future
+/// contributor can't drift the JS-visible enum without a test
 /// failure.
 final class NowPlayingFormatExtractorTests: XCTestCase {
 

package/ios/Tests/PlaybackErrorMappingTests.swift

@@ -5,9 +5,6 @@ import AVFoundation
 
 /// Unit tests for the iOS half of the cross-platform error-code
 /// mapping in `PlaybackErrorMapping.swift`.
-/// Mirrors the Android-side coverage in
-/// `TrackPlayerEventsTest.kt#error mapping classifies Media3 codes`
-/// + `error mapping strips query strings`.
 ///
 /// **Why string-keyed assertions?** NOTES.md §6 — Swift's
 /// `-cxx-interoperability-mode=default` hides members of functions

package/ios/Tests/PlaybackModeStateMachineTests.swift

@@ -3,15 +3,11 @@ import XCTest
 
 /// Coverage for the pure-Swift `CrossfadeDurationBounds` helper that
 /// powers `PlaybackModeStateMachine.requireValid`. Full state-machine
-/// validation coverage (constructing `PlaybackMode` instances + driving
-/// `setRequested`) lives in the Android Robolectric suite — `PlaybackMode`
-/// is bridged via Nitro `@_spi` and can't be constructed from a Swift
-/// XCTest target, so the throws path is exercised end-to-end via the
-/// in-app TS test runner's `playback-mode` suite (the
-/// `crossfade-duration-out-of-range-rejected` and
-/// `crossfade-duration-non-quantised-rejected` steps in
-/// `RNQP-Demo/src/tests/suites/playback-mode.ts`). Mirrors the
-/// cxx-interop carve-out already documented in AGENTS.md §2.
+/// validation (constructing `PlaybackMode` instances + driving
+/// `setRequested`) is out of scope here — `PlaybackMode` is bridged
+/// via Nitro `@_spi` and can't be constructed from a Swift XCTest
+/// target. Mirrors the cxx-interop carve-out already documented in
+/// AGENTS.md §2.
 final class PlaybackModeStateMachineTests: XCTestCase {
 
   func testCrossfadeBoundsHelperAcceptsEveryValueOnTheStep() {

package/ios/Tests/PlayerStateDerivationTests.swift

@@ -3,8 +3,7 @@ import XCTest
 @testable import QueuePlayer
 
 /// Unit tests for `PlayerStateDerivation` — the pure `PlayerState` mapping
-/// shared by both engines. Native wiring (getState + the two emit paths + the
-/// end-of-queue latch) is covered by the queue-end / crossfade demo suites.
+/// shared by both engines.
 final class PlayerStateDerivationTests: XCTestCase {
 
   private func derive(

package/ios/Tests/ProgressEmissionGateTests.swift

@@ -2,9 +2,7 @@ import XCTest
 @testable import QueuePlayer
 
 /// Unit tests for `ProgressEmissionGate` — the pure throttle behind the
-/// configurable / background-reduced `onProgress` cadence. Native wiring
-/// (the periodic tick, the cast push, and the UIApplication background /
-/// foreground observers) is covered by the progress demo suites.
+/// configurable / background-reduced `onProgress` cadence.
 ///
 /// Most tests pass `samplerPeriodMs: 0` to exercise exact interval semantics;
 /// the jitter + quantization tests pass the production `500` to verify the

package/ios/Tests/QueueMutationArithmeticTests.swift

@@ -3,9 +3,6 @@ import XCTest
 @_spi(QueuePlayerTests) import QueuePlayer
 
 /// Pure-Swift tests for the queue-mutation index-shift arithmetic.
-/// 1:1 mirror of `android/.../QueueMutationArithmeticTest.kt` —
-/// every Kotlin test name has a Swift twin so the cross-platform
-/// matrix stays in lock-step.
 final class QueueMutationArithmeticTests: XCTestCase {
 
   // MARK: - clampInsertBefore

package/ios/Tests/RemoteCommandsTests.swift

@@ -6,11 +6,8 @@ import XCTest
 /// registrations + the per-command `isEnabled` state. Tests pin the
 /// install / uninstall lifecycle and the `setSkipCapability` ->
 /// `nextTrackCommand.isEnabled` / `previousTrackCommand.isEnabled`
-/// mapping. Dispatch into the owner's `onCommand` closure is verified
-/// at the integration layer (Maestro suite + JS-visible reason
-/// classification); attempting to fire `MPRemoteCommandCenter`
-/// handlers from XCTest would require lib-side SPI we deliberately
-/// do not ship.
+/// mapping. Attempting to fire `MPRemoteCommandCenter` handlers from
+/// XCTest would require lib-side SPI we deliberately do not ship.
 ///
 /// The shared command center is process-global. `setUp` resets all
 /// seven commands the lib touches, `tearDown` calls `uninstall()` to

package/ios/Tests/ReplayGainExtractorTests.swift

@@ -4,11 +4,6 @@ import XCTest
 /// Unit tests for `ReplayGainExtractor`'s pure string parsers
 /// (`parseGainDb`, `parsePeak`) and the `selectGain(mode:)` matrix
 /// on `ReplayGainData`.
-///
-/// Container-level extraction (ID3v2 TXXX, FLAC Vorbis, MP4
-/// freeform) is covered by `MetadataReaderTests`. End-to-end
-/// extraction-on-load is covered by the auto-suite `replaygain.ts`
-/// step.
 final class ReplayGainExtractorTests: XCTestCase {
 
   // Helper: `XCTAssertEqual` with the `accuracy:` overload requires

package/ios/Tests/SkipCapabilityTests.swift

@@ -2,15 +2,12 @@ import XCTest
 @testable import QueuePlayer
 @_spi(QueuePlayerTests) import QueuePlayer
 
-/// Integration tests for the canSkip surface + `onSkipCapabilityChange`
-/// listener emission. Pairs with the pure-helper coverage in
-/// `SkipIndexTests` (`canSkipNext` / `canSkipPrevious`).
+/// Tests for the canSkip surface + `onSkipCapabilityChange`
+/// listener emission.
 ///
-/// XCTest can cover only the cases where `configure(...)` has not yet
+/// Covers the cases where `configure(...)` has not yet
 /// stood up an AVQueuePlayer — initial cached-getter state, listener
-/// registration + auto-fire, dispose closure correctness. Behavioural
-/// coverage of every `recomputeCapabilities()` hook point lives in
-/// the Robolectric sibling and the end-to-end demo suite.
+/// registration + auto-fire, dispose closure correctness.
 final class SkipCapabilityTests: XCTestCase {
 
   func testGetCanSkipNextReturnsFalseInitially() throws {

package/ios/Tests/VoiceDonationTests.swift

@@ -4,10 +4,10 @@ import XCTest
 @_spi(QueuePlayerTests) import QueuePlayer
 
 /// Smoke coverage for `VoiceDonation.donateVoiceVocabulary`. Live
-/// `INVocabulary` delivery is verified via the manual siri-cold-start
-/// playbook; this test pins the in-process contract that the method
-/// early-returns when `NSSiriUsageDescription` is absent from the
-/// host bundle (the XCTest bundle's plist).
+/// `INVocabulary` delivery isn't exercised here; this test pins the
+/// in-process contract that the method early-returns when
+/// `NSSiriUsageDescription` is absent from the host bundle (the XCTest
+/// bundle's plist).
 @available(iOS 13.0, *)
 final class VoiceDonationTests: XCTestCase {
   func testDonateVoiceVocabularyEarlyReturnsWithoutUsageDescription() {