react-native-audio-browser 0.2.0-next.31 → 0.2.0-next.33

package/ios/Player/RetryLoop.swift

@@ -84,6 +84,13 @@ final class RetryLoop {
   /// Retries executed since the budgets last reset.
   private(set) var attempts = 0
 
+  /// Continuous audible playback that proves the stream recovered, so the budgets refill
+  /// (Android's HEALTHY_PLAYBACK_MS); without it a long-lived stream keeps its spent budget until
+  /// the track changes.
+  var healthyPlaybackDuration: Duration = .seconds(20)
+  /// The pending refill. Readable so tests can await the window instead of sleeping past it.
+  private(set) var healthyPlaybackTask: Task<Void, Never>?
+
   private var policy: Policy = .disabled
   private var firstRetryTime: Date?
   /// First failure observed while online for the current load: the first-connect budget's
@@ -167,6 +174,25 @@ final class RetryLoop {
     isWaitingForNetwork = false
   }
 
+  // MARK: - Healthy Playback
+
+  /// Starts the healthy-playback window; when it elapses between failures, the budgets refill.
+  func playbackBecameAudible() {
+    healthyPlaybackTask?.cancel()
+    healthyPlaybackTask = Task { [weak self, healthyPlaybackDuration] in
+      try? await Task.sleep(for: healthyPlaybackDuration)
+      guard let self, !Task.isCancelled else { return }
+      // reset() cancels a pending retry, which would silently kill an in-flight reconnect.
+      guard pendingTask == nil else { return }
+      reset()
+    }
+  }
+
+  func playbackStoppedBeingAudible() {
+    healthyPlaybackTask?.cancel()
+    healthyPlaybackTask = nil
+  }
+
   // MARK: - Budgets
 
   private var isOnline: Bool { networkMonitor?.isOnline ?? true }

package/ios/Player/SleepTimerManager.swift

@@ -44,15 +44,21 @@ final class SleepTimerManager {
   // MARK: - Properties
 
   private let scheduler: any SleepTimerScheduling
+  /// Fades the volume out before a time-based timer's deadline.
+  private let fader: VolumeFader
 
   // nonisolated(unsafe) for deinit cleanup — deinit is always nonisolated in Swift 6.
   private nonisolated(unsafe) var sleepTimerJob: (any SleepTimerJob)?
   private nonisolated(unsafe) var fadeJob: (any SleepTimerJob)?
 
-  init(scheduler: any SleepTimerScheduling = MainQueueSleepTimerScheduler()) {
+  init(fader: VolumeFader, scheduler: any SleepTimerScheduling = MainQueueSleepTimerScheduler()) {
+    self.fader = fader
     self.scheduler = scheduler
   }
 
+  /// Whether the fade before the deadline is running.
+  var isFading: Bool { fader.isActive }
+
   /// The time when playback should stop (seconds since epoch), or -1 if inactive
   private(set) var sleepTimerTime: TimeInterval = -1 {
     didSet {
@@ -73,17 +79,9 @@ final class SleepTimerManager {
     }
   }
 
-  /// Callback invoked when the sleep timer fires
+  /// Halts playback when the timer fires; the pre-fade volume is restored after it returns.
   var onComplete: (() -> Void)?
 
-  /// Callback invoked when the fade-out window of a time-based timer begins
-  var onFadeStart: ((_ duration: TimeInterval) -> Void)?
-
-  /// Callback invoked when a timer is cancelled/replaced while its fade may be
-  /// running — the listener restores the pre-fade volume. Not invoked on
-  /// completion: there the pause lands first, then the volume is restored.
-  var onFadeCancel: (() -> Void)?
-
   /// Callback invoked when the sleep timer state changes
   var onChanged: ((SleepTimerState) -> Void)?
 
@@ -97,7 +95,7 @@ final class SleepTimerManager {
     if !hasSleepTimer { return false }
     sleepTimerTime = -1
     willSleepWhenCurrentItemReachesEnd = false
-    onFadeCancel?()
+    fader.cancel(restoringVolume: true)
     onChanged?(.first(NullType.null))
     return true
   }
@@ -129,7 +127,7 @@ final class SleepTimerManager {
   ///     deadline (clamped to `seconds`); silence lands exactly at the deadline
   func set(seconds: TimeInterval, fadeDuration: TimeInterval? = nil) {
     cancelSleepTimerJob()
-    onFadeCancel?()
+    fader.cancel(restoringVolume: true)
     sleepTimerTime = Date().timeIntervalSince1970 + seconds
     sleepTimerJob = scheduler.schedule(after: seconds) { [weak self] in
       self?.complete()
@@ -137,7 +135,7 @@ final class SleepTimerManager {
     if let fadeDuration, fadeDuration > 0 {
       let fade = min(fadeDuration, seconds)
       fadeJob = scheduler.schedule(after: seconds - fade) { [weak self] in
-        self?.onFadeStart?(fade)
+        self?.fader.start(duration: fade)
       }
     }
     if let state = get() { onChanged?(state) }
@@ -148,7 +146,7 @@ final class SleepTimerManager {
     let changed = !willSleepWhenCurrentItemReachesEnd
     willSleepWhenCurrentItemReachesEnd = true
     if changed {
-      onFadeCancel?()
+      fader.cancel(restoringVolume: true)
       if let state = get() { onChanged?(state) }
     }
   }
@@ -182,7 +180,7 @@ final class SleepTimerManager {
     sleepTimerTime = -1
     willSleepWhenCurrentItemReachesEnd = false
     onChanged?(.first(NullType.null))
-    onComplete?()
+    fader.resolve { onComplete?() }
   }
 
   deinit {

package/ios/Player/VolumeFader.swift

@@ -19,6 +19,9 @@ final class VolumeFader {
 
   var isActive: Bool { originalVolume != nil }
 
+  /// The length of the running fade.
+  private(set) var duration: TimeInterval?
+
   init(getVolume: @escaping () -> Float, setVolume: @escaping (Float) -> Void) {
     self.getVolume = getVolume
     self.setVolume = setVolume
@@ -30,6 +33,7 @@ final class VolumeFader {
     let baseVolume = originalVolume ?? getVolume()
     cancel(restoringVolume: false)
     originalVolume = baseVolume
+    self.duration = duration
     guard duration > 0 else { return }
 
     let startDate = Date()
@@ -57,6 +61,7 @@ final class VolumeFader {
     timer = nil
     guard let originalVolume else { return }
     self.originalVolume = nil
+    duration = nil
     if restoringVolume { setVolume(originalVolume) }
   }
 

package/ios/Tests/BrowserPathHelperTests.swift

@@ -177,3 +177,36 @@ import Testing
   #expect(BrowserPathHelper.isSearchPath("/search?q=jazz") == false)
   #expect(BrowserPathHelper.isSearchPath("/__searchable") == false)
 }
+
+// MARK: - stampingContextualPaths
+
+@Test func stampsPlayableOnlyTracksWithTheirFlatPagePosition() throws {
+  let sections = [
+    Section(children: [Track(path: "/a", title: "A"), Track(src: "one.mp3", title: "One")]),
+    Section(children: [Track(id: "two", src: "two.mp3", title: "Two")]),
+  ]
+  let stamped = try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/page")
+  #expect(stamped.map { $0.children.map(\.path) } == [
+    ["/a", "/page?__trackId=one.mp3&__index=1"],
+    ["/page?__trackId=two&__index=2"],
+  ])
+}
+
+@Test func keepsTheSectionsAndATrackThatHasAPath() throws {
+  let track = Track(path: "/a", src: "a.mp3", title: "A")
+  let sections = [Section(title: "Top", path: "/top", children: [track])]
+  #expect(try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/page") == sections)
+}
+
+@Test func stampsBesideAnExistingQuery() throws {
+  let sections = [Section(children: [Track(src: "s.mp3", title: "S")])]
+  let stamped = try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/search?q=jazz")
+  #expect(stamped[0].children[0].path == "/search?q=jazz&__trackId=s.mp3&__index=0")
+}
+
+@Test func rejectsATrackWithNeitherPathNorSrc() {
+  let sections = [Section(children: [Track(id: "only-id", title: "Nowhere")])]
+  #expect(throws: BrowserError.self) {
+    try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/page")
+  }
+}

package/ios/Tests/ErrorStatusTests.swift

@@ -0,0 +1,50 @@
+@testable import AudioBrowserTestable
+import Testing
+
+@Suite("ErrorStatus.after(event:from:to:)")
+struct ErrorStatusTests {
+  private let retrying = ErrorStatus.retrying(.hostUnreachable)
+
+  @Test func anErrorEventIsATerminalReport() {
+    let status = ErrorStatus.none.after(event: .errorOccurred(.playbackFailed), from: .playing, to: .error)
+    #expect(status.error == .playbackFailed)
+    #expect(!status.isRetrying)
+  }
+
+  @Test func aRepeatedTerminalReportDiffersFromTheLast() {
+    let first = ErrorStatus.none.after(event: .errorOccurred(.playbackFailed), from: .playing, to: .error)
+    let repeated = first.after(event: .errorOccurred(.playbackFailed), from: .error, to: .error)
+    #expect(repeated.error == .playbackFailed)
+    #expect(repeated != first)
+  }
+
+  @Test func anErrorEventReplacesARetryingError() {
+    let status = retrying.after(event: .errorOccurred(.playbackFailed), from: .loading, to: .error)
+    #expect(status.error == .playbackFailed)
+    #expect(!status.isRetrying)
+  }
+
+  @Test func leavingErrorClearsIt() {
+    let terminal = ErrorStatus.none.after(event: .errorOccurred(.playbackFailed), from: .playing, to: .error)
+    #expect(terminal.after(event: .trackLoading, from: .error, to: .loading) == .none)
+  }
+
+  @Test(arguments: [PlaybackState.loading, .buffering, .paused])
+  func aRetryingErrorRidesAlongWhereItShows(_ state: PlaybackState) {
+    #expect(retrying.after(event: .trackLoading, from: .loading, to: state) == retrying)
+  }
+
+  @Test(arguments: [PlaybackState.ready, .playing, .stopped, .none, .ended])
+  func aRetryingErrorClearsWhereItDoesNotShow(_ state: PlaybackState) {
+    #expect(retrying.after(event: .avPlayerPlaying, from: .loading, to: state) == .none)
+  }
+
+  @Test func otherwiseTheStatusHolds() {
+    #expect(ErrorStatus.none.after(event: .avPlayerPlaying, from: .ready, to: .playing) == .none)
+  }
+
+  @Test(arguments: [PlaybackState.none, .loading, .ready, .buffering, .playing, .paused, .stopped, .ended, .error])
+  func onlyLoadingBufferingAndPausedCarryAnAdvisoryError(_ state: PlaybackState) {
+    #expect(state.carriesAdvisoryError == [.loading, .buffering, .paused].contains(state))
+  }
+}

package/ios/Tests/FavoriteSetTests.swift

@@ -0,0 +1,60 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+struct FavoriteSetTests {
+  private func favorites(_ identities: [String], enabled: Bool = true) -> FavoriteSet {
+    var set = FavoriteSet()
+    set.enabled = enabled
+    _ = set.replace(with: identities)
+    return set
+  }
+
+  @Test func replaceReportsWhetherTheIdentitiesChanged() {
+    var set = FavoriteSet()
+    let changes = [["a", "b"], ["b", "a"], ["a", "b", "a"], []].map { set.replace(with: $0) }
+    #expect(changes == [true, false, false, true])
+  }
+
+  @Test func hydratesTrueOrFalseByIdentity() {
+    let set = favorites(["a", "stable"])
+    #expect(set.hydrate(Track(src: "a")).favorited == true)
+    #expect(set.hydrate(Track(src: "b")).favorited == false)
+    #expect(set.hydrate(Track(id: "stable", src: "x")).favorited == true)
+    #expect(set.hydrate(Track(id: "other", src: "a")).favorited == false)
+  }
+
+  @Test func leavesATrackAloneWhenDisabled() {
+    #expect(favorites(["a"], enabled: false).hydrate(Track(src: "a")).favorited == nil)
+  }
+
+  @Test func leavesATrackWithoutIdentityAlone() {
+    #expect(favorites(["a"]).hydrate(Track(path: "/browse")).favorited == nil)
+  }
+
+  @Test func aFavoritedTheTrackCarriesWins() {
+    let set = favorites(["a"])
+    #expect(set.hydrate(Track(src: "a", favorited: false)).favorited == false)
+    #expect(set.hydrate(Track(src: "b", favorited: true)).favorited == true)
+  }
+
+  @Test func aLocalToggleHoldsUntilTheNextReplace() {
+    var set = favorites(["a"])
+    set.set("b", favorited: true)
+    set.set("a", favorited: false)
+    #expect(set.hydrate(Track(src: "a")).favorited == false)
+    #expect(set.hydrate(Track(src: "b")).favorited == true)
+    _ = set.replace(with: ["a"])
+    #expect(set.hydrate(Track(src: "b")).favorited == false)
+  }
+
+  @Test func hydratesEverySectionOfAPage() {
+    let page = ResolvedTrack(
+      path: "/p",
+      sections: [Section(children: [Track(src: "a")]), Section(children: [Track(src: "b")])],
+      title: "P",
+    )
+    let hydrated = favorites(["b"]).hydrate(page)
+    #expect(hydrated.sections?.map { $0.children.map(\.favorited) } == [[false], [true]])
+  }
+}

package/ios/Tests/JsonModelsTests.swift

@@ -219,3 +219,33 @@ struct JsonStyleTests {
     #expect(snapshot?.cardImage == "background")
   }
 }
+
+@Suite("JsonTrack persistence")
+struct JsonTrackPersistenceTests {
+  /// The snapshot a resume restores keeps every field a track persists.
+  @Test func aTrackSurvivesTheRoundTripThroughItsSnapshot() throws {
+    let track = Track(
+      id: "t1", path: "/station/1", src: "https://example.com/a.mp3",
+      artwork: .first("https://example.com/a.jpg"),
+      request: TrackRequest(userAgent: "Agent", headers: ["X": "1"], query: ["q": "2"]),
+      title: "Title", subtitle: "Subtitle", artist: "Artist", albumPath: "/album/1", album: "Album",
+      description: "Description", genre: "Genre", duration: 123,
+      disabled: false, live: true, icyCharset: "windows-1251",
+    )
+    let data = try JSONEncoder().encode(JsonTrack(from: track))
+    let restored = try JSONDecoder().decode(JsonTrack.self, from: data).toNitro()
+    #expect(restored == track)
+  }
+
+  /// A favorite is the app's state, never persisted with the track; neither is the resolved artwork.
+  @Test func favoritedAndTheResolvedArtworkAreNotPersisted() throws {
+    let track = Track(
+      id: "t1", src: "https://example.com/a.mp3",
+      artworkSource: ImageSource(uri: "https://example.com/r.jpg", method: nil, headers: nil, body: nil),
+      title: "Title", favorited: true,
+    )
+    let restored = JsonTrack(from: track).toNitro()
+    #expect(restored.favorited == nil)
+    #expect(restored.artworkSource == nil)
+  }
+}

package/ios/Tests/MediaLoaderTests.swift

@@ -23,9 +23,20 @@ private final class MediaLoaderSpy {
   }
 }
 
+/// Resolves and loads `src`, returning once the resolved URL is handed to the asset load.
 @MainActor
-private func makeLoader() -> (MediaLoader, MediaLoaderSpy) {
-  let loader = MediaLoader()
+private func load(_ loader: MediaLoader, _ src: String) async {
+  loader.resolveAndLoad(src: src)
+  await loader.mediaResolverTask?.value
+}
+
+@MainActor
+private func makeLoader(
+  resolveUrl: @escaping (String, Track?) async -> MediaResolvedUrl = { src, _ in
+    MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
+  },
+) -> (MediaLoader, MediaLoaderSpy) {
+  let loader = MediaLoader(resolveUrl: resolveUrl)
   let spy = MediaLoaderSpy()
   loader.onEvent = { spy.record($0) }
   return (loader, spy)
@@ -52,9 +63,9 @@ struct MediaLoaderInitialStateTests {
 @Suite("resolveAndLoad")
 @MainActor
 struct ResolveAndLoadTests {
-  @Test func invalidUrl_callsDelegateWithError() {
+  @Test func invalidUrl_callsDelegateWithError() async {
     let (loader, spy) = makeLoader()
-    loader.resolveAndLoad(src: "")
+    await load(loader, "")
     #expect(spy.playbackErrors.count == 1)
     if case let .invalidSourceUrl(url) = spy.playbackErrors.first {
       #expect(url == "")
@@ -63,25 +74,24 @@ struct ResolveAndLoadTests {
     }
   }
 
-  @Test func validHttpUrl_createsAsset() {
+  @Test func validHttpUrl_createsAsset() async {
     let (loader, _) = makeLoader()
-    loader.resolveAndLoad(src: "https://example.com/audio.mp3")
+    await load(loader, "https://example.com/audio.mp3")
     #expect(loader.asset != nil)
     #expect(loader.asset?.url.absoluteString == "https://example.com/audio.mp3")
   }
 
-  @Test func fileUrl_convertsCorrectly() {
+  @Test func fileUrl_convertsCorrectly() async {
     let (loader, _) = makeLoader()
-    loader.resolveAndLoad(src: "file:///tmp/audio.mp3")
+    await load(loader, "file:///tmp/audio.mp3")
     #expect(loader.asset != nil)
     #expect(loader.asset?.url.isFileURL == true)
     #expect(loader.asset?.url.path == "/tmp/audio.mp3")
   }
 
   @Test func withResolver_callsResolver() async {
-    let (loader, _) = makeLoader()
     var resolverCalled = false
-    loader.mediaUrlResolver = { src, _ in
+    let (loader, _) = makeLoader { src, _ in
       resolverCalled = true
       return MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
     }
@@ -93,14 +103,11 @@ struct ResolveAndLoadTests {
   }
 
   @Test func withResolver_returningInvalidUrl_callsErrorDelegate() async {
-    let (loader, spy) = makeLoader()
-    loader.mediaUrlResolver = { _, _ in
+    let (loader, spy) = makeLoader { _, _ in
       MediaResolvedUrl(url: "", headers: nil, userAgent: nil)
     }
     loader.resolveAndLoad(src: "https://example.com/audio.mp3")
 
-    // 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)
@@ -112,9 +119,8 @@ struct ResolveAndLoadTests {
   }
 
   @Test func cancelsPreviousResolverTask() async {
-    let (loader, _) = makeLoader()
     var callCount = 0
-    loader.mediaUrlResolver = { src, _ in
+    let (loader, _) = makeLoader { src, _ in
       callCount += 1
       // Simulate slow resolution
       try? await Task.sleep(for: .milliseconds(100))
@@ -142,8 +148,7 @@ struct ResolveAndLoadTests {
 @MainActor
 struct CancelAllTests {
   @Test func preventsDelegateCallbacksAfterResolveAndLoad() async {
-    let (loader, spy) = makeLoader()
-    loader.mediaUrlResolver = { src, _ in
+    let (loader, spy) = makeLoader { src, _ in
       try? await Task.sleep(for: .milliseconds(50))
       return MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
     }
@@ -164,9 +169,9 @@ struct CancelAllTests {
 @Suite("clearAsset")
 @MainActor
 struct ClearAssetTests {
-  @Test func nilsOutAsset() {
+  @Test func nilsOutAsset() async {
     let (loader, _) = makeLoader()
-    loader.resolveAndLoad(src: "https://example.com/audio.mp3")
+    await load(loader, "https://example.com/audio.mp3")
     #expect(loader.asset != nil)
     loader.clearAsset()
     #expect(loader.asset == nil)
@@ -187,7 +192,7 @@ struct ClearAssetTests {
 struct AsyncLoadingTests {
   @Test func nonExistentLocalFile_eventuallyCallsRetryableError() async {
     let (loader, spy) = makeLoader()
-    loader.resolveAndLoad(src: "file:///nonexistent/path.mp3")
+    await load(loader, "file:///nonexistent/path.mp3")
 
     // Poll for delegate callback — asset loading is async
     for _ in 0 ..< 50 {

package/ios/Tests/NowPlayingLinesTests.swift

@@ -0,0 +1,43 @@
+@testable import AudioBrowserTestable
+import Testing
+
+@Suite("NowPlayingLines.resolve")
+struct NowPlayingLinesTests {
+  private let track = Track(title: "Station", artist: "City", album: "Country")
+
+  @Test func withoutLayersTheTrackShows() {
+    #expect(NowPlayingLines.resolve(track: track) == NowPlayingLines(title: "Station", artist: "City", album: "Country"))
+  }
+
+  @Test func theOverrideOutranksTheTrack() {
+    let lines = NowPlayingLines.resolve(track: track, override: NowPlayingUpdate(title: "Show", artist: nil, album: nil))
+    #expect(lines == NowPlayingLines(title: "Show", artist: "City", album: "Country"))
+  }
+
+  @Test func theFormatterOutranksTheOverride() {
+    let lines = NowPlayingLines.resolve(
+      track: track,
+      formatted: NowPlayingUpdate(title: "Song", artist: nil, album: nil),
+      override: NowPlayingUpdate(title: "Show", artist: "Host", album: nil),
+    )
+    #expect(lines == NowPlayingLines(title: "Song", artist: "Host", album: "Country"))
+  }
+
+  @Test func theFlashOutranksEverything() {
+    let lines = NowPlayingLines.resolve(
+      track: track,
+      flash: NowPlayingUpdate(title: nil, artist: "Can't skip", album: nil),
+      formatted: NowPlayingUpdate(title: "Song", artist: "Artist", album: nil),
+      override: NowPlayingUpdate(title: "Show", artist: "Host", album: "Album"),
+    )
+    #expect(lines == NowPlayingLines(title: "Song", artist: "Can't skip", album: "Album"))
+  }
+
+  @Test func eachLineFallsBackSeparately() {
+    let lines = NowPlayingLines.resolve(
+      track: Track(title: "Station"),
+      flash: NowPlayingUpdate(title: nil, artist: nil, album: nil),
+    )
+    #expect(lines == NowPlayingLines(title: "Station", artist: nil, album: nil))
+  }
+}

package/ios/Tests/PlayerPolicyTests.swift

@@ -119,19 +119,19 @@ struct PlayerEngineEventTests {
     let (player, engine, _) = makeLoading()
     engine.emit(.unplayable)
     #expect(player.state == .error)
-    #expect(player.errorStatus == .terminal(.trackWasUnplayable))
+    #expect(player.errorStatus == .terminal(.trackWasUnplayable, report: 1))
   }
 
   @Test func anInvalidSourceIsTerminal() {
     let (player, engine, _) = makeLoading()
     engine.emit(.invalidSource("::"))
-    #expect(player.errorStatus == .terminal(.invalidSourceUrl("::")))
+    #expect(player.errorStatus == .terminal(.invalidSourceUrl("::"), report: 1))
   }
 
   @Test func aPlayerFailureCarriesItsHTTPStatus() {
     let (player, engine, _) = makePlaying()
     engine.emit(.failed(nil, httpStatusCode: 404))
-    #expect(player.errorStatus == .terminal(.httpStatus(404)))
+    #expect(player.errorStatus == .terminal(.httpStatus(404), report: 1))
   }
 
   @Test func aGenuineEndAdvances_aLiveEndReconnects() {
@@ -406,6 +406,22 @@ struct PlayerReviewRegressionTests {
     #expect(makePlayer(retries: false).persistedSession() == nil)
   }
 
+  /// A track change while the old track loads with a retrying error publishes the new track's
+  /// loading state without that error.
+  @Test func aTrackChangeClearsTheRetryingErrorOfTheTrackItLeaves() async {
+    let (player, engine, callbacks) = makeLoading()
+    player.retry.shouldRetry = { true }
+    player.setPlayWhenReady(true)
+    engine.emit(.loadFailed(URLError(.timedOut)))
+    #expect(callbacks.playbackChanges.last?.error != nil)
+
+    player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
+
+    #expect(callbacks.playbackChanges.last?.state == .loading)
+    #expect(callbacks.playbackChanges.last?.error == nil)
+    player.retry.cancel()
+  }
+
   /// Leaving an errored track publishes the new track's loading state once, never an error
   /// state without its error.
   @Test func skippingAwayFromAnErrorNeverPublishesAnErrorlessError() {