react-native-audio-browser 0.2.0-next.75 → 0.2.0-next.77

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (68) hide show
  1. package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +20 -27
  2. package/android/src/main/java/com/audiobrowser/Service.kt +3 -0
  3. package/android/src/main/java/com/audiobrowser/browser/BrowserManager.kt +16 -8
  4. package/android/src/main/java/com/audiobrowser/browser/TrackLoadHandler.kt +5 -3
  5. package/android/src/main/java/com/audiobrowser/http/RequestConfigBuilder.kt +10 -2
  6. package/android/src/main/java/com/audiobrowser/player/EnginePlayback.kt +9 -5
  7. package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt +71 -39
  8. package/android/src/main/java/com/audiobrowser/player/LiveStreamExtractor.kt +65 -0
  9. package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt +12 -3
  10. package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt +8 -0
  11. package/android/src/main/java/com/audiobrowser/player/Player.kt +85 -37
  12. package/android/src/main/java/com/audiobrowser/player/PlayerListener.kt +38 -11
  13. package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt +1 -1
  14. package/android/src/main/java/com/audiobrowser/remote/RemoteSwitchingPlayer.kt +21 -0
  15. package/android/src/main/java/com/audiobrowser/util/AwaitCancellable.kt +45 -0
  16. package/android/src/test/java/androidx/media3/session/SessionViews.kt +10 -0
  17. package/android/src/test/java/com/audiobrowser/GateDecisionTest.kt +128 -0
  18. package/android/src/test/java/com/audiobrowser/ResolveFormattedErrorTest.kt +93 -0
  19. package/android/src/test/java/com/audiobrowser/ServiceTaskRemovedTest.kt +35 -0
  20. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerLayerResolutionTest.kt +75 -5
  21. package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt +42 -0
  22. package/android/src/test/java/com/audiobrowser/browser/TrackLoadHandlerTest.kt +43 -0
  23. package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt +62 -0
  24. package/android/src/test/java/com/audiobrowser/player/BrowseTilesTest.kt +31 -32
  25. package/android/src/test/java/com/audiobrowser/player/LiveStreamEndTest.kt +372 -0
  26. package/android/src/test/java/com/audiobrowser/player/NowPlayingFormatterTest.kt +75 -0
  27. package/android/src/test/java/com/audiobrowser/player/NowPlayingUpdaterTest.kt +25 -0
  28. package/android/src/test/java/com/audiobrowser/player/PlayFromSearchTest.kt +108 -0
  29. package/android/src/test/java/com/audiobrowser/player/PlayerSetupEndedTest.kt +221 -0
  30. package/android/src/test/java/com/audiobrowser/player/PlayerSetupTest.kt +17 -7
  31. package/android/src/test/java/com/audiobrowser/player/PlayerSuppressionTest.kt +183 -7
  32. package/android/src/test/java/com/audiobrowser/player/PlayerTrackChangeTest.kt +153 -0
  33. package/android/src/test/java/com/audiobrowser/player/SessionPlayTest.kt +236 -0
  34. package/android/src/test/java/com/audiobrowser/player/SessionViewRulesTest.kt +62 -0
  35. package/android/src/test/java/com/audiobrowser/player/SessionViewTest.kt +188 -0
  36. package/android/src/test/java/com/audiobrowser/remote/FakeRemote.kt +11 -0
  37. package/android/src/test/java/com/audiobrowser/remote/RemoteSwitchingPlayerTest.kt +58 -0
  38. package/android/src/test/java/com/audiobrowser/util/AwaitCancellableTest.kt +136 -0
  39. package/android/src/test/java/com/audiobrowser/util/JsPromise.kt +44 -0
  40. package/ios/AVPlayerEngine.swift +5 -1
  41. package/ios/Browser/BrowserManager.swift +2 -2
  42. package/ios/Browser/PageResolver.swift +14 -19
  43. package/ios/Browser/RequestPipeline.swift +6 -4
  44. package/ios/CarPlay/CarPlayNowPlayingManager.swift +1 -1
  45. package/ios/CarPlay/CarPlaySession+PageLoader.swift +1 -0
  46. package/ios/CarPlay/CarPlaySession+TabBar.swift +2 -0
  47. package/ios/Extension/Promise+AwaitCallback.swift +33 -0
  48. package/ios/HybridAudioBrowser+Player.swift +1 -1
  49. package/ios/HybridAudioBrowser.swift +1 -1
  50. package/ios/Player/MediaLoader.swift +1 -1
  51. package/ios/Player/PlaybackFailure.swift +3 -3
  52. package/ios/Player/Player.swift +67 -49
  53. package/ios/Player/PlayerEngine.swift +2 -0
  54. package/ios/Player/RetryLoop.swift +72 -12
  55. package/ios/Tests/AwaitCallbackTests.swift +210 -0
  56. package/ios/Tests/GenerationMemoTests.swift +57 -0
  57. package/ios/Tests/PlaybackFailureTests.swift +7 -0
  58. package/ios/Tests/PlayerPolicyTests.swift +346 -6
  59. package/ios/Tests/PlayerTests.swift +79 -1
  60. package/ios/Tests/RetryLoopTests.swift +30 -5
  61. package/ios/Tests/Support/TestTypes.swift +15 -7
  62. package/ios/Tests/Support/TimeLimit.swift +43 -0
  63. package/ios/Util/AwaitCallback.swift +80 -0
  64. package/ios/Util/GenerationMemo.swift +11 -4
  65. package/package.json +2 -1
  66. package/android/src/test/java/com/audiobrowser/player/SessionErrorMaskTest.kt +0 -63
  67. package/ios/Player/EndOfTrackJudgement.swift +0 -25
  68. package/ios/Tests/EndOfTrackJudgementTests.swift +0 -30
@@ -18,11 +18,17 @@ public enum PlaybackErrorContext {
18
18
  case playback
19
19
  /// A MediaLoader key-value load failure: retries start from the beginning.
20
20
  case mediaLoad
21
+ /// Playback that stopped receiving data without AVFoundation failing it: retries resume from
22
+ /// the current time.
23
+ case stall
24
+ /// A live stream that reported played-to-end, as a cleanly closed connection does: retries
25
+ /// reconnect, since AVPlayer will not play on from an item it has ended.
26
+ case liveEnd
21
27
 
22
28
  var startFromCurrentTime: Bool {
23
29
  switch self {
24
- case .playback: true
25
- case .mediaLoad: false
30
+ case .playback, .stall: true
31
+ case .mediaLoad, .liveEnd: false
26
32
  }
27
33
  }
28
34
 
@@ -30,6 +36,7 @@ public enum PlaybackErrorContext {
30
36
  switch self {
31
37
  case .playback: .playbackFailed
32
38
  case .mediaLoad: .failedToLoadKeyValue
39
+ case .stall, .liveEnd: .playbackStalled
33
40
  }
34
41
  }
35
42
  }
@@ -73,6 +80,8 @@ final class RetryLoop {
73
80
  /// A failure a retry is now scheduled for, reported before the backoff while the state stays
74
81
  /// non-terminal.
75
82
  var onRetryingError: ((TrackPlayerError.PlaybackError) -> Void)?
83
+ /// A retryable failure with no play intent: nothing retries it and nothing reports it.
84
+ var onFailedWithoutIntent: (() -> Void)?
76
85
 
77
86
  weak var networkMonitor: (any NetworkStatusProviding)?
78
87
 
@@ -84,6 +93,13 @@ final class RetryLoop {
84
93
  var healthyPlaybackDuration: Duration = .seconds(20)
85
94
  private(set) var healthyPlaybackTask: Task<Void, Never>?
86
95
 
96
+ /// How long a stall may go without new data before it counts as a failure; longer than AVPlayer
97
+ /// takes to fail a stalled item itself, so its error, which says more, is the one usually retried.
98
+ var stallTimeout: Duration = .seconds(30)
99
+ /// The end of the loaded range; the stall watch reads progress off it.
100
+ var bufferedPosition: () -> Double = { 0 }
101
+ private(set) var stallTask: Task<Void, Never>?
102
+
87
103
  private var policy: Policy = .disabled
88
104
  private var firstRetryTime: Date?
89
105
  // The first-connect budget's clock: never set while offline and wiped by any offline
@@ -126,9 +142,9 @@ final class RetryLoop {
126
142
 
127
143
  // MARK: - Failures
128
144
 
129
- /// Reports a non-retryable failure through `onError` at once; otherwise reports it through
130
- /// `onRetryingError`, replaces any retry in flight, and calls `onError` only if that retry gives
131
- /// up.
145
+ /// Reports a non-retryable failure through `onError` at once, and one with no play intent
146
+ /// through `onFailedWithoutIntent`; otherwise reports it through `onRetryingError`, replaces any
147
+ /// retry in flight, and calls `onError` only if that retry gives up.
132
148
  func handleError(_ error: Error?, context: PlaybackErrorContext, httpStatusCode: Int? = nil) {
133
149
  if let error {
134
150
  let nsError = error as NSError
@@ -137,17 +153,36 @@ final class RetryLoop {
137
153
  logger.error("[\(String(describing: context))] failure with nil error")
138
154
  }
139
155
 
140
- let failure = PlaybackFailure.classify(error, httpStatusCode: httpStatusCode, fallback: context.fallbackError)
156
+ handle(PlaybackFailure.classify(error, httpStatusCode: httpStatusCode, fallback: context.fallbackError), context: context)
157
+ }
158
+
159
+ /// A failure the Player judges from what playback did, with no error to classify: retryable,
160
+ /// and reported as the context's fallback error. `immediately` skips the backoff, not the budgets.
161
+ func handleFailure(_ context: PlaybackErrorContext, immediately: Bool = false) {
162
+ logger.error("[\(String(describing: context))] failure")
163
+ handle(.init(error: context.fallbackError, retryable: true), context: context, immediately: immediately)
164
+ }
165
+
166
+ private func handle(
167
+ _ failure: PlaybackFailure.Classification, context: PlaybackErrorContext, immediately: Bool = false,
168
+ ) {
169
+ stopStallWatch()
141
170
  guard isEnabled, failure.retryable else {
142
- logger.warning("Error not retryable, surfacing \(String(describing: failure.error))")
171
+ let reason = isEnabled ? "Error not retryable" : "Retry disabled"
172
+ logger.warning("\(reason), surfacing \(String(describing: failure.error))")
143
173
  onError?(failure.error)
144
174
  return
145
175
  }
176
+ guard shouldRetry() else {
177
+ logger.info("No play intent: \(String(describing: failure.error)) is left to the next play")
178
+ onFailedWithoutIntent?()
179
+ return
180
+ }
146
181
  onRetryingError?(failure.error)
147
182
  pendingTask?.cancel()
148
183
  pendingTask = Task { [weak self] in
149
184
  guard let self else { return }
150
- let retried = await attemptRetry(startFromCurrentTime: context.startFromCurrentTime)
185
+ let retried = await attemptRetry(startFromCurrentTime: context.startFromCurrentTime, immediately: immediately)
151
186
  // Cancelled by a track change or stop: stay silent, or the new track or the stop would
152
187
  // flip to .error. The canceller owns `pendingTask`.
153
188
  if Task.isCancelled { return }
@@ -156,10 +191,34 @@ final class RetryLoop {
156
191
  }
157
192
  }
158
193
 
159
- /// Drops the retry in flight without touching the budgets.
194
+ /// Drops the retry in flight and the stall watch without touching the budgets.
160
195
  func cancel() {
161
196
  pendingTask?.cancel()
162
197
  pendingTask = nil
198
+ stopStallWatch()
199
+ }
200
+
201
+ // MARK: - Stalls
202
+
203
+ /// Starts the stall watch: a `stallTimeout` in which `bufferedPosition` does not advance makes
204
+ /// the stall a `.stall` failure, provided the play intent holds and no retry is pending; one in
205
+ /// which it advances starts another. Any failure ends it.
206
+ func startStallWatch() {
207
+ stallTask?.cancel()
208
+ let buffered = bufferedPosition()
209
+ stallTask = Task { [weak self, stallTimeout] in
210
+ try? await Task.sleep(for: stallTimeout)
211
+ guard let self, !Task.isCancelled else { return }
212
+ stallTask = nil
213
+ if bufferedPosition() > buffered { return startStallWatch() }
214
+ guard pendingTask == nil, shouldRetry() else { return }
215
+ handleFailure(.stall)
216
+ }
217
+ }
218
+
219
+ func stopStallWatch() {
220
+ stallTask?.cancel()
221
+ stallTask = nil
163
222
  }
164
223
 
165
224
  /// Drops the retry in flight and refills the budgets.
@@ -212,7 +271,7 @@ final class RetryLoop {
212
271
 
213
272
  /// Waits out the backoff, or connectivity's return, then calls `onRetry`. False when the policy,
214
273
  /// the play intent or a budget says stop, or the wait was cancelled.
215
- func attemptRetry(startFromCurrentTime: Bool) async -> Bool {
274
+ func attemptRetry(startFromCurrentTime: Bool, immediately: Bool = false) async -> Bool {
216
275
  guard isEnabled, shouldRetry() else { return false }
217
276
  if case let .limited(maxRetries) = policy, attempts >= maxRetries {
218
277
  logger.info("Max retries (\(maxRetries)) exceeded, giving up")
@@ -230,8 +289,9 @@ final class RetryLoop {
230
289
  return false
231
290
  }
232
291
 
233
- logger.info("Scheduling retry after \(self.backoff)s")
234
- guard await waitForDelayOrNetworkRestored(delaySeconds: backoff), !Task.isCancelled, shouldRetry() else {
292
+ let delay = immediately ? 0 : backoff
293
+ logger.info("Scheduling retry after \(delay)s")
294
+ guard await waitForDelayOrNetworkRestored(delaySeconds: delay), !Task.isCancelled, shouldRetry() else {
235
295
  return false
236
296
  }
237
297
  // The wait for connectivity may have been long.
@@ -0,0 +1,210 @@
1
+ import Foundation
2
+ import Testing
3
+
4
+ @testable import AudioBrowserTestable
5
+
6
+ @Suite("awaitCallback")
7
+ struct AwaitCallbackTests {
8
+ struct Rejected: Error, Equatable {}
9
+
10
+ /// A JS callback's pending answer: records the subscriber's `deliver`, which the test calls
11
+ /// as JS would, on any thread and as often as it likes.
12
+ final class FakeCallback: @unchecked Sendable {
13
+ private let lock = NSLock()
14
+ private var delivers: [@Sendable (Result<Int, Error>) -> Void] = []
15
+
16
+ var subscribe: CallbackSubscription<Int> {
17
+ { deliver in self.lock.withLock { self.delivers.append(deliver) } }
18
+ }
19
+
20
+ var isSubscribed: Bool {
21
+ lock.withLock { !delivers.isEmpty }
22
+ }
23
+
24
+ func settle(_ result: Result<Int, Error>) {
25
+ for deliver in lock.withLock({ delivers }) {
26
+ deliver(result)
27
+ }
28
+ }
29
+
30
+ func waitForSubscriber() async {
31
+ while !isSubscribed {
32
+ await Task.yield()
33
+ }
34
+ }
35
+ }
36
+
37
+ static let raceRuns = 500
38
+
39
+ // MARK: - Without a timeout
40
+
41
+ @Test func anAnswerResumesWithIt() async throws {
42
+ let callback = FakeCallback()
43
+ let result = try await withinTimeLimit {
44
+ try await awaitCallback { deliver in
45
+ callback.subscribe(deliver)
46
+ callback.settle(.success(7))
47
+ }
48
+ }
49
+ #expect(result == 7)
50
+ }
51
+
52
+ @Test func aRejectionThrowsIt() async throws {
53
+ let callback = FakeCallback()
54
+ await #expect(throws: Rejected.self) {
55
+ try await withinTimeLimit {
56
+ try await awaitCallback { deliver in
57
+ callback.subscribe(deliver)
58
+ callback.settle(.failure(Rejected()))
59
+ }
60
+ }
61
+ }
62
+ }
63
+
64
+ @Test func aCancelledCallerEndsWhileJSIsSilent() async throws {
65
+ let callback = FakeCallback()
66
+ let waiting = Task { try await awaitCallback(callback.subscribe) }
67
+ await callback.waitForSubscriber()
68
+ waiting.cancel()
69
+ await #expect(throws: CancellationError.self) {
70
+ try await withinTimeLimit { try await waiting.value }
71
+ }
72
+ callback.settle(.success(1))
73
+ }
74
+
75
+ @Test func aCallerCancelledBeforeTheAwaitEndsAtOnce() async throws {
76
+ let callback = FakeCallback()
77
+ await #expect(throws: CancellationError.self) {
78
+ try await withinTimeLimit {
79
+ withUnsafeCurrentTask { $0?.cancel() }
80
+ return try await awaitCallback(callback.subscribe)
81
+ }
82
+ }
83
+ }
84
+
85
+ @Test func anAnswerAndACancelTogetherResumeOnce() async throws {
86
+ var answered = 0
87
+ var cancelled = 0
88
+ for _ in 0 ..< Self.raceRuns {
89
+ let callback = FakeCallback()
90
+ let waiting = Task { try await awaitCallback(callback.subscribe) }
91
+ await callback.waitForSubscriber()
92
+ let go = Flag()
93
+ let answer = Task.detached {
94
+ while !go.isSet {}
95
+ callback.settle(.success(3))
96
+ }
97
+ let cancel = Task.detached {
98
+ while !go.isSet {}
99
+ waiting.cancel()
100
+ }
101
+ go.set()
102
+ await answer.value
103
+ await cancel.value
104
+ let outcome = try await withinTimeLimit { await waiting.result }
105
+ switch outcome {
106
+ case let .success(value):
107
+ #expect(value == 3)
108
+ answered += 1
109
+ case let .failure(error):
110
+ #expect(error is CancellationError)
111
+ cancelled += 1
112
+ }
113
+ }
114
+ #expect(answered > 0 && cancelled > 0, "answered \(answered), cancelled \(cancelled)")
115
+ }
116
+
117
+ @Test func aRejectAfterACancelIsIgnored() async throws {
118
+ for _ in 0 ..< Self.raceRuns {
119
+ let callback = FakeCallback()
120
+ let waiting = Task { try await awaitCallback(callback.subscribe) }
121
+ await callback.waitForSubscriber()
122
+ waiting.cancel()
123
+ await Task.detached { callback.settle(.failure(Rejected())) }.value
124
+ await #expect(throws: CancellationError.self) {
125
+ try await withinTimeLimit { try await waiting.value }
126
+ }
127
+ }
128
+ }
129
+
130
+ // MARK: - With a timeout
131
+
132
+ @Test func silentJSTimesOutAndNotBefore() async throws {
133
+ let callback = FakeCallback()
134
+ let waiting = Task { try await awaitCallback(timeout: .milliseconds(600), callback.subscribe) }
135
+ let finished = Flag()
136
+ Task {
137
+ _ = await waiting.result
138
+ finished.set()
139
+ }
140
+ try await Task.sleep(for: .milliseconds(200))
141
+ #expect(!finished.isSet)
142
+ await #expect(throws: CallbackTimeoutError.self) {
143
+ try await withinTimeLimit { try await waiting.value }
144
+ }
145
+ }
146
+
147
+ @Test func anAnswerInsideTheTimeoutIsKept() async throws {
148
+ let callback = FakeCallback()
149
+ let waiting = Task { try await awaitCallback(timeout: .seconds(5), callback.subscribe) }
150
+ await callback.waitForSubscriber()
151
+ callback.settle(.success(4))
152
+ #expect(try await withinTimeLimit { try await waiting.value } == 4)
153
+ }
154
+
155
+ @Test func aCancelledCallerWithATimeoutPendingEndsWithItsCancellation() async throws {
156
+ let callback = FakeCallback()
157
+ let waiting = Task { try await awaitCallback(timeout: .seconds(5), callback.subscribe) }
158
+ await callback.waitForSubscriber()
159
+ waiting.cancel()
160
+ await #expect(throws: CancellationError.self) {
161
+ try await withinTimeLimit { try await waiting.value }
162
+ }
163
+ }
164
+
165
+ /// Spreads each run's settle from before the timeout to after it.
166
+ static func delay(_ run: Int) -> Duration {
167
+ .microseconds(run * 10000 / raceRuns)
168
+ }
169
+
170
+ @Test func anAnswerAroundTheTimeoutResumesOnce() async throws {
171
+ var answered = 0
172
+ var timedOut = 0
173
+ for run in 0 ..< Self.raceRuns {
174
+ let callback = FakeCallback()
175
+ let waiting = Task { try await awaitCallback(timeout: .milliseconds(5), callback.subscribe) }
176
+ await callback.waitForSubscriber()
177
+ try await Task.sleep(for: Self.delay(run))
178
+ await Task.detached { callback.settle(.success(5)) }.value
179
+ let outcome = try await withinTimeLimit { await waiting.result }
180
+ switch outcome {
181
+ case let .success(value):
182
+ #expect(value == 5)
183
+ answered += 1
184
+ case let .failure(error):
185
+ #expect(error is CallbackTimeoutError)
186
+ timedOut += 1
187
+ }
188
+ }
189
+ #expect(answered > 0 && timedOut > 0, "answered \(answered), timed out \(timedOut)")
190
+ }
191
+
192
+ @Test func aCancelAroundTheTimeoutResumesOnce() async throws {
193
+ var cancelled = 0
194
+ var timedOut = 0
195
+ for run in 0 ..< Self.raceRuns {
196
+ let callback = FakeCallback()
197
+ let waiting = Task { try await awaitCallback(timeout: .milliseconds(5), callback.subscribe) }
198
+ await callback.waitForSubscriber()
199
+ try await Task.sleep(for: Self.delay(run))
200
+ waiting.cancel()
201
+ let outcome = try await withinTimeLimit { await waiting.result }
202
+ switch outcome {
203
+ case .failure(is CancellationError): cancelled += 1
204
+ case .failure(is CallbackTimeoutError): timedOut += 1
205
+ default: Issue.record("resumed with \(outcome)")
206
+ }
207
+ }
208
+ #expect(cancelled > 0 && timedOut > 0, "cancelled \(cancelled), timed out \(timedOut)")
209
+ }
210
+ }
@@ -118,4 +118,61 @@ struct GenerationMemoTests {
118
118
  await #expect(throws: CancellationError.self) { try await result.value }
119
119
  #expect(gate.runs == 1)
120
120
  }
121
+
122
+ @Test func aCancelledCallerLeavesWhileTheComputationRunsOn() async throws {
123
+ let memo = GenerationMemo<Int>()
124
+ let gate = Gate()
125
+ gate.input = 5
126
+ let cancelled = Task { try await memo.value { await gate.run() } }
127
+ let other = Task { try await memo.value { await gate.run() } }
128
+ await gate.waitForRuns(1)
129
+ cancelled.cancel()
130
+ await #expect(throws: CancellationError.self) {
131
+ try await withinTimeLimit { try await cancelled.value }
132
+ }
133
+ gate.release()
134
+ #expect(try await withinTimeLimit { try await other.value } == 5)
135
+ #expect(gate.runs == 1)
136
+ }
137
+
138
+ @Test func aCallerAfterACancelledOneJoinsTheRunningComputation() async throws {
139
+ let memo = GenerationMemo<Int>()
140
+ let gate = Gate()
141
+ gate.input = 6
142
+ let cancelled = Task { try await memo.value { await gate.run() } }
143
+ await gate.waitForRuns(1)
144
+ cancelled.cancel()
145
+ _ = try await withinTimeLimit { await cancelled.result }
146
+ let later = Task { try await memo.value { await gate.run() } }
147
+ for _ in 0 ..< 100 {
148
+ await Task.yield()
149
+ }
150
+ gate.release()
151
+ #expect(try await withinTimeLimit { try await later.value } == 6)
152
+ #expect(gate.runs == 1)
153
+ }
154
+
155
+ @Test func aFailureAfterEveryCallerLeftIsNotKept() async throws {
156
+ let memo = GenerationMemo<Int>()
157
+ let gate = Gate()
158
+ let cancelled = Task {
159
+ try await memo.value {
160
+ let input = await gate.run()
161
+ if input == 0 { throw Failure() }
162
+ return input
163
+ }
164
+ }
165
+ await gate.waitForRuns(1)
166
+ cancelled.cancel()
167
+ _ = try await withinTimeLimit { await cancelled.result }
168
+ gate.release()
169
+ for _ in 0 ..< 100 {
170
+ await Task.yield()
171
+ }
172
+ gate.input = 7
173
+ let later = Task { try await memo.value { await gate.run() } }
174
+ await gate.waitForRuns(2)
175
+ gate.release()
176
+ #expect(try await withinTimeLimit { try await later.value } == 7)
177
+ }
121
178
  }
@@ -90,6 +90,13 @@ struct PlaybackFailureRetryTests {
90
90
  #expect(!retryable(URLError(.timedOut), status: status))
91
91
  }
92
92
 
93
+ /// A live stream's error log keeps the 200 of the connection that played.
94
+ @Test func aSuccessStatusLeavesItToTheErrorChain() {
95
+ #expect(retryable(URLError(.networkConnectionLost), status: 200))
96
+ #expect(retryable(NSError(domain: "CoreMediaErrorDomain", code: -16830), status: 206))
97
+ #expect(!retryable(URLError(.badURL), status: 200))
98
+ }
99
+
93
100
  @Test func aTransientURLErrorRetries() {
94
101
  #expect(retryable(URLError(.networkConnectionLost)))
95
102
  }