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

package/ios/Tests/TopTemplateReplacerTests.swift

@@ -0,0 +1,172 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+private final class Page {
+  let name: String
+  init(_ name: String) { self.name = name }
+}
+
+/// A template stack whose mutations complete only when the test steps them,
+/// the way CarPlay's complete on a later run-loop turn.
+@MainActor
+private final class FakeStack: TemplateStack {
+  private(set) var templates: [Page]
+  private(set) var calls: [String] = []
+  var failingPushes: Set<String> = []
+  var failsPop = false
+  private var pending: [() -> Void] = []
+
+  init(_ names: String...) {
+    templates = names.map(Page.init)
+  }
+
+  var names: [String] {
+    templates.map(\.name)
+  }
+
+  func popTop(completion: @escaping (Bool, Error?) -> Void) {
+    calls.append("pop")
+    pending.append { [self] in
+      guard !failsPop else {
+        completion(false, nil)
+        return
+      }
+      templates.removeLast()
+      completion(true, nil)
+    }
+  }
+
+  func push(_ template: Page, animated: Bool, completion: @escaping (Bool, Error?) -> Void) {
+    calls.append("push \(template.name)\(animated ? " animated" : "")")
+    pending.append { [self] in
+      guard !failingPushes.contains(template.name) else {
+        completion(false, nil)
+        return
+      }
+      templates.append(template)
+      completion(true, nil)
+    }
+  }
+
+  func step() {
+    pending.removeFirst()()
+  }
+
+  func run() {
+    while !pending.isEmpty {
+      step()
+    }
+  }
+}
+
+@Suite("TopTemplateReplacer")
+@MainActor
+struct TopTemplateReplacerTests {
+  private let replacer = TopTemplateReplacer()
+  private let stack = FakeStack("tabs", "A", "B", "C", "D")
+
+  @Test func replacesTheTopPageAndKeepsTheRest() {
+    var result: Bool?
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true) { pushed, _ in result = pushed }
+    stack.run()
+
+    #expect(stack.names == ["tabs", "A", "B", "C", "E"])
+    #expect(stack.calls == ["pop", "push E animated"])
+    #expect(result == true)
+    #expect(!replacer.isReplacing)
+  }
+
+  @Test func thePushWaitsForThePopToComplete() {
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true)
+    #expect(stack.calls == ["pop"])
+    stack.step()
+    #expect(stack.calls == ["pop", "push E animated"])
+  }
+
+  @Test func aMutationArrivingMidReplacementRunsOnceItHasSettled() {
+    var seen: [[String]] = []
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true)
+    stack.step()
+    replacer.whenSettled { seen.append(stack.names) }
+    #expect(seen.isEmpty)
+    stack.run()
+
+    #expect(seen == [["tabs", "A", "B", "C", "E"]])
+  }
+
+  @Test func deferredMutationsRunInArrivalOrderBehindASecondReplacement() {
+    var order: [String] = []
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true)
+    replacer.whenSettled { [replacer, stack] in
+      order.append("F")
+      replacer.push(Page("F"), replacingTopOf: stack, animated: true)
+    }
+    replacer.whenSettled { order.append("after F: \(stack.names.last ?? "")") }
+    stack.run()
+
+    #expect(stack.names == ["tabs", "A", "B", "C", "F"])
+    #expect(order == ["F", "after F: F"])
+  }
+
+  @Test func aMutationIssuedByTheCompletionQueuesBehindEarlierArrivals() {
+    var order: [String] = []
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true) { [replacer] _, _ in
+      replacer.whenSettled { order.append("from completion") }
+    }
+    replacer.whenSettled { order.append("arrived mid-replacement") }
+    stack.run()
+
+    #expect(order == ["arrived mid-replacement", "from completion"])
+  }
+
+  @Test func aFailedPopLeavesTheStackAsItWas() {
+    stack.failsPop = true
+    var result: Bool?
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true) { pushed, _ in result = pushed }
+    stack.run()
+
+    #expect(stack.names == ["tabs", "A", "B", "C", "D"])
+    #expect(stack.calls == ["pop"])
+    #expect(result == false)
+    #expect(!replacer.isReplacing)
+  }
+
+  @Test func aFailedPushRestoresThePoppedPage() {
+    stack.failingPushes = ["E"]
+    let top = stack.templates[4]
+    var result: Bool?
+    var ranAfter = false
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true) { pushed, _ in result = pushed }
+    replacer.whenSettled { ranAfter = true }
+    stack.run()
+
+    #expect(stack.names == ["tabs", "A", "B", "C", "D"])
+    #expect(stack.templates[4] === top)
+    #expect(stack.calls == ["pop", "push E animated", "push D"])
+    #expect(result == false)
+    #expect(ranAfter)
+  }
+
+  @Test func aFailedRestoreStillSettles() {
+    stack.failingPushes = ["E", "D"]
+    var result: Bool?
+    replacer.push(Page("E"), replacingTopOf: stack, animated: true) { pushed, _ in result = pushed }
+    stack.run()
+
+    #expect(stack.names == ["tabs", "A", "B", "C"])
+    #expect(result == false)
+    #expect(!replacer.isReplacing)
+  }
+
+  @Test func refusesAStackWithNothingAboveTheRoot() {
+    let rootOnly = FakeStack("tabs")
+    var result: Bool?
+    replacer.push(Page("E"), replacingTopOf: rootOnly, animated: true) { pushed, _ in result = pushed }
+
+    #expect(rootOnly.calls.isEmpty)
+    #expect(result == false)
+    #expect(!replacer.isReplacing)
+  }
+}

package/ios/Tests/TrackIdTemplateTests.swift

@@ -0,0 +1,67 @@
+@testable import AudioBrowserTestable
+import Testing
+
+/// `{id}` template substitution used by artwork URL resolution
+/// (RequestPipeline.substituteTrackId). A track without a non-blank id must leave
+/// the token LITERALLY in place — never substitute an empty string, never skip — so the
+/// resulting request 404s with a self-describing URL (the resolver logs a warning keyed off
+/// `containsToken`). Mirrors Android's `substituteTrackId` / `configContainsIdToken`.
+struct TrackIdTemplateTests {
+  // MARK: substitution with an id
+
+  @Test func substitutesTokenInString() {
+    #expect(TrackIdTemplate.substitute("/artwork/{id}", id: "abc") == "/artwork/abc")
+  }
+
+  @Test func substitutesEveryOccurrence() {
+    #expect(TrackIdTemplate.substitute("/{id}/art/{id}.png", id: "x") == "/x/art/x.png")
+  }
+
+  @Test func substitutesTokenInDictionaryValues() {
+    let subbed = TrackIdTemplate.substitute(["x-track": "{id}", "plain": "v"], id: "abc")
+    #expect(subbed == ["x-track": "abc", "plain": "v"])
+  }
+
+  @Test func valueWithoutTokenIsUnchanged() {
+    #expect(TrackIdTemplate.substitute("/artwork/static.png", id: "abc") == "/artwork/static.png")
+  }
+
+  // MARK: token left literal without an id
+
+  @Test func nilIdLeavesTokenLiteral() {
+    #expect(TrackIdTemplate.substitute("/artwork/{id}", id: nil) == "/artwork/{id}")
+  }
+
+  @Test func blankIdLeavesTokenLiteral() {
+    #expect(TrackIdTemplate.substitute("/artwork/{id}", id: "") == "/artwork/{id}")
+  }
+
+  @Test func nilIdLeavesDictionaryValuesLiteral() {
+    #expect(TrackIdTemplate.substitute(["x-track": "{id}"], id: nil) == ["x-track": "{id}"])
+  }
+
+  @Test func nilValuePassesThrough() {
+    #expect(TrackIdTemplate.substitute(String?.none, id: "abc") == nil)
+    #expect(TrackIdTemplate.substitute([String: String]?.none, id: nil) == nil)
+  }
+
+  // MARK: unfilled-token detection (drives the single warning)
+
+  @Test func detectsUnfilledTokenInString() {
+    #expect(TrackIdTemplate.containsToken("/artwork/{id}"))
+    #expect(!TrackIdTemplate.containsToken("/artwork/abc"))
+    #expect(!TrackIdTemplate.containsToken(String?.none))
+  }
+
+  @Test func detectsUnfilledTokenInDictionaryValues() {
+    #expect(TrackIdTemplate.containsToken(["x-track": "{id}"]))
+    #expect(!TrackIdTemplate.containsToken(["x-track": "abc"]))
+    #expect(!TrackIdTemplate.containsToken([String: String]?.none))
+  }
+
+  @Test func substitutionThenDetectionNeverBothMatch() {
+    // With an id, substitution clears the token, so no warning fires.
+    let subbed = TrackIdTemplate.substitute("/artwork/{id}", id: "abc")
+    #expect(!TrackIdTemplate.containsToken(subbed))
+  }
+}

package/ios/Tests/TrackIdentityTests.swift

@@ -0,0 +1,20 @@
+@testable import AudioBrowserTestable
+import Testing
+
+struct TrackIdentityTests {
+  @Test func idWinsOverSrc() {
+    #expect(Track(id: "stable", src: "https://cdn.example/stream").identity == "stable")
+  }
+
+  @Test func blankIdFallsBackToSrc() {
+    #expect(Track(id: "", src: "https://cdn.example/stream").identity == "https://cdn.example/stream")
+  }
+
+  @Test func nilIdFallsBackToSrc() {
+    #expect(Track(src: "https://cdn.example/stream").identity == "https://cdn.example/stream")
+  }
+
+  @Test func neitherIdNorSrcHasNoIdentity() {
+    #expect(Track(path: "/browse/only").identity == nil)
+  }
+}

package/ios/Tests/TrackSelectorTests.swift

@@ -12,15 +12,15 @@ private final class BrowserMock: TrackSelectionBrowser {
 
   // Record calls for verification
   var trackLoadEvents: [TrackLoadEvent] = []
-  var expandedUrls: [String] = []
+  var expandedPaths: [String] = []
 
   func awaitTrackLoadHandler(event: TrackLoadEvent) async -> Bool {
     trackLoadEvents.append(event)
     return trackLoadHandlerResult
   }
 
-  func expandQueueFromContextualUrl(_ url: String) async throws -> (tracks: [Track], selectedIndex: Int)? {
-    expandedUrls.append(url)
+  func expandQueueFromContextualPath(_ path: String) async throws -> (tracks: [Track], selectedIndex: Int)? {
+    expandedPaths.append(path)
     if let error = expandQueueError {
       throw error
     }
@@ -53,23 +53,23 @@ private func makeSelector() -> (TrackSelector, BrowserMock, PlayerMock) {
 @Suite("browsable track")
 @MainActor
 struct BrowsableTrackTests {
-  @Test func urlOnly_returnsBrowse() async {
+  @Test func pathOnly_returnsBrowse() async {
     let (selector, _, player) = makeSelector()
-    let track = Track(id: "t1", url: "/some/path")
+    let track = Track(id: "t1", path: "/some/path")
     let result = await selector.select(track: track, player: player)
-    guard case let .browse(url) = result else {
+    guard case let .browse(path) = result else {
       Issue.record("expected .browse, got \(result)")
       return
     }
-    #expect(url == "/some/path")
+    #expect(path == "/some/path")
   }
 }
 
-// MARK: - No src or url
+// MARK: - No src or path
 
-@Suite("no src or url")
+@Suite("no src or path")
 @MainActor
-struct NoSrcOrUrlTests {
+struct NoSrcOrPathTests {
   @Test func returnsNone() async {
     let (selector, _, player) = makeSelector()
     let track = Track(id: "t1")
@@ -115,25 +115,56 @@ struct PlayableTrackTests {
   }
 }
 
-// MARK: - Contextual URL Queue Reuse
+// MARK: - Contextual path Queue Reuse
 
-@Suite("contextual URL queue reuse")
+@Suite("contextual path queue reuse")
 @MainActor
-struct ContextualUrlQueueReuseTests {
+struct ContextualPathQueueReuseTests {
   @Test func matchingQueueSourcePath_returnsSkipTo() async {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+
+    // Id-less queue tracks: identity falls back to src.
+    player.queueSourcePath = parentPath
+    player.tracks = [
+      Track(src: "other.mp3"),
+      Track(src: "song.mp3"),
+      Track(src: "another.mp3"),
+    ]
+
+    let track = Track(path: contextualPath, src: trackSrc)
+    let result = await selector.select(track: track, player: player)
+    guard case let .play(intent) = result else {
+      Issue.record("expected .play, got \(result)")
+      return
+    }
+    guard case let .skipTo(index) = intent else {
+      Issue.record("expected .skipTo, got \(intent)")
+      return
+    }
+    #expect(index == 1)
+    #expect(browser.trackLoadEvents.count == 1)
+    #expect(browser.expandedPaths.isEmpty)
+  }
+
+  // Skip-in-place matches by id when queue tracks carry ids: the contextual
+  // trackId is the row's identity (its id), and the queue row is found even
+  // though its src differs textually from the tapped track's.
+  @Test func matchingQueueSourcePath_skipsToTrackByIdWhenSrcDiffers() async {
+    let (selector, browser, player) = makeSelector()
+    let parentPath = "/library/radio"
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: "b")
 
     player.queueSourcePath = parentPath
     player.tracks = [
       Track(id: "a", src: "other.mp3"),
-      Track(id: "b", src: "song.mp3"),
+      Track(id: "b", src: "https://cdn.example/song.mp3?token=queue"),
       Track(id: "c", src: "another.mp3"),
     ]
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "b", path: contextualPath, src: "song.mp3")
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -144,8 +175,7 @@ struct ContextualUrlQueueReuseTests {
       return
     }
     #expect(index == 1)
-    #expect(browser.trackLoadEvents.count == 1)
-    #expect(browser.expandedUrls.isEmpty)
+    #expect(browser.expandedPaths.isEmpty)
   }
 
   @Test func handlerIntercepts_returnsIntercepted() async {
@@ -153,32 +183,93 @@ struct ContextualUrlQueueReuseTests {
     browser.trackLoadHandlerResult = true
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     player.queueSourcePath = parentPath
     player.tracks = [
-      Track(id: "a", src: "song.mp3"),
+      Track(src: "song.mp3"),
     ]
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case .intercepted = result else {
       Issue.record("expected .intercepted, got \(result)")
       return
     }
+    #expect(browser.expandedPaths.isEmpty)
+  }
+
+  // A queue holding the same identity twice (normal for music playlists):
+  // exact contextual-path equality — which carries the stamped page index —
+  // pins the tapped copy instead of the first one.
+  @Test func duplicateIdentityInQueue_pathMatchPinsTheTappedCopy() async {
+    let (selector, browser, player) = makeSelector()
+    let parentPath = "/playlist"
+    func stamped(_ id: String, _ index: Int) -> String {
+      BrowserPathHelper.build(parentPath: parentPath, trackId: id, index: index)
+    }
+
+    player.queueSourcePath = parentPath
+    player.tracks = [
+      Track(path: stamped("a", 0), src: "a"),
+      Track(path: stamped("b", 1), src: "b"),
+      Track(path: stamped("a", 2), src: "a"),
+    ]
+
+    let track = Track(path: stamped("a", 2), src: "a")
+    let result = await selector.select(track: track, player: player)
+    guard case let .play(.skipTo(index)) = result else {
+      Issue.record("expected .play(.skipTo), got \(result)")
+      return
+    }
+    #expect(index == 2)
+    #expect(browser.expandedPaths.isEmpty)
+  }
+
+  // A tap in section B whose identity also sits in the active section-A
+  // queue: the exact surface is not in the queue, so the selection
+  // re-expands (re-scoping to the tapped section) instead of silently
+  // skipping inside the old section's queue.
+  @Test func indexStampedPathNotInQueue_reExpandsInsteadOfIdentitySkip() async {
+    let (selector, browser, player) = makeSelector()
+    let parentPath = "/city"
+    func stamped(_ id: String, _ index: Int) -> String {
+      BrowserPathHelper.build(parentPath: parentPath, trackId: id, index: index)
+    }
+
+    player.queueSourcePath = parentPath
+    player.tracks = [
+      Track(path: stamped("dup", 0), src: "dup"),
+      Track(path: stamped("x", 1), src: "x"),
+    ]
+    browser.expandQueueResult = (
+      tracks: [Track(path: stamped("y", 4), src: "y"), Track(path: stamped("dup", 5), src: "dup")],
+      selectedIndex: 1,
+    )
+
+    let track = Track(path: stamped("dup", 5), src: "dup")
+    let result = await selector.select(track: track, player: player)
+    guard case let .play(.setQueue(tracks, startIndex, sourcePath)) = result else {
+      Issue.record("expected .play(.setQueue), got \(result)")
+      return
+    }
+    #expect(tracks.count == 2)
+    #expect(startIndex == 1)
+    #expect(sourcePath == parentPath)
+    #expect(browser.expandedPaths == [stamped("dup", 5)])
   }
 }
 
-// MARK: - Contextual URL Expansion
+// MARK: - Contextual path Expansion
 
-@Suite("contextual URL expansion")
+@Suite("contextual path expansion")
 @MainActor
-struct ContextualUrlExpansionTests {
+struct ContextualPathExpansionTests {
   @Test func expands_returnsSetQueue() async {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     let expandedTracks = [
       Track(id: "a", src: "first.mp3"),
@@ -187,7 +278,7 @@ struct ContextualUrlExpansionTests {
     ]
     browser.expandQueueResult = (tracks: expandedTracks, selectedIndex: 1)
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -200,7 +291,7 @@ struct ContextualUrlExpansionTests {
     #expect(tracks.count == 3)
     #expect(startIndex == 1)
     #expect(sourcePath == parentPath)
-    #expect(browser.expandedUrls == [contextualUrl])
+    #expect(browser.expandedPaths == [contextualPath])
     #expect(browser.trackLoadEvents.count == 1)
   }
 
@@ -209,14 +300,14 @@ struct ContextualUrlExpansionTests {
     browser.trackLoadHandlerResult = true
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     browser.expandQueueResult = (
       tracks: [Track(id: "a", src: "song.mp3")],
       selectedIndex: 0,
     )
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case .intercepted = result else {
       Issue.record("expected .intercepted, got \(result)")
@@ -228,11 +319,11 @@ struct ContextualUrlExpansionTests {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     browser.expandQueueResult = nil
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -249,11 +340,11 @@ struct ContextualUrlExpansionTests {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     browser.expandQueueError = MockError.expansion
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -266,3 +357,47 @@ struct ContextualUrlExpansionTests {
     #expect(loaded.src == trackSrc)
   }
 }
+
+// MARK: - Disabled Track
+
+@Suite("disabled track")
+@MainActor
+struct DisabledTrackTests {
+  @Test func disabledPlayable_returnsNone() async {
+    let (selector, browser, player) = makeSelector()
+    let track = Track(id: "t1", src: "https://example.com/a.mp3", disabled: true)
+    let result = await selector.select(track: track, player: player)
+    guard case .none = result else {
+      Issue.record("Expected .none for a disabled track, got \(result)")
+      return
+    }
+    // Refused outright: not even the JS load handler hears about it.
+    #expect(browser.trackLoadEvents.isEmpty)
+  }
+
+  @Test func disabledBrowsable_returnsNone() async {
+    // Unavailable means unavailable — a disabled browsable doesn't navigate
+    // either (the ladder grays or hides it; a delivered tap stays inert).
+    let (selector, _, player) = makeSelector()
+    let track = Track(id: "t1", path: "/gone", disabled: true)
+    let result = await selector.select(track: track, player: player)
+    guard case .none = result else {
+      Issue.record("Expected .none for a disabled browsable, got \(result)")
+      return
+    }
+  }
+
+  @Test func disabledContextual_neverExpands() async {
+    let (selector, browser, player) = makeSelector()
+    browser.expandQueueResult = (tracks: [Track(id: "a", src: "a")], selectedIndex: 0)
+    let track = Track(
+      id: "t1", path: "/home?__trackId=t1", src: "https://example.com/a.mp3", disabled: true,
+    )
+    let result = await selector.select(track: track, player: player)
+    guard case .none = result else {
+      Issue.record("Expected .none, got \(result)")
+      return
+    }
+    #expect(browser.expandedPaths.isEmpty)
+  }
+}

package/ios/Tests/URLErrorConnectivityTests.swift

@@ -0,0 +1,20 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("URLError.isConnectivity")
+struct URLErrorConnectivityTests {
+  @Test(arguments: [
+    URLError.Code.timedOut, .networkConnectionLost, .notConnectedToInternet, .cannotConnectToHost,
+    .cannotFindHost, .dnsLookupFailed,
+  ])
+  func aMissingConnectionIsWorthRepeating(_ code: URLError.Code) {
+    #expect(URLError(code).isConnectivity)
+  }
+
+  @Test(arguments: [URLError.Code.badServerResponse, .fileDoesNotExist, .badURL, .cancelled, .userAuthenticationRequired])
+  func anyOtherFailureIsNot(_ code: URLError.Code) {
+    #expect(!URLError(code).isConnectivity)
+  }
+}