From 530af087849bd31e4b15577b729ea52e03038aac Mon Sep 17 00:00:00 2001 From: Ceyhun Ozgoc Date: Fri, 20 Nov 2026 03:01:22 -0800 Subject: [PATCH 1/2] SideloadedSubtitle: cover timestamp, transformation, and playlist behavior Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Co-Authored-By: Ceyhun Ozgoc --- .../SourceTimestampTests.swift | 44 +++ .../SubtitlePlaylistTests.swift | 257 ++++++++++++++++++ .../SubtitlesTransformerTests.swift | 39 +++ .../TimestampStringUtilsTests.swift | 33 +++ 4 files changed, 373 insertions(+) create mode 100644 Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SourceTimestampTests.swift create mode 100644 Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaylistTests.swift create mode 100644 Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/TimestampStringUtilsTests.swift diff --git a/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SourceTimestampTests.swift b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SourceTimestampTests.swift new file mode 100644 index 00000000..8c17dee7 --- /dev/null +++ b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SourceTimestampTests.swift @@ -0,0 +1,44 @@ +import Swifter +import XCTest +import THEOplayerConnectorSideloadedSubtitle + +@MainActor +final class SourceTimestampTests: XCTestCase { + func testExtractSourceTimestampReturnsValuesWithoutSettingOverride() async throws { + let origin = HttpServer() + origin["/mapped.vtt"] = { _ in .ok(.text("WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:90000,LOCAL:01:02:03.456\n\n")) } + try origin.start(0, forceIPv4: true, priority: .userInitiated) + defer { origin.stop() } + let track = SSTextTrackDescription(src: "http://127.0.0.1:\(try origin.port())/mapped.vtt", srclang: "en") + let extracted = expectation(description: "Timestamp extracted") + + track.extractSourceTimestamp { timestamp, error in + XCTAssertNil(error) + XCTAssertEqual(timestamp.pts, "90000") + XCTAssertEqual(timestamp.localTime, "01:02:03.456") + extracted.fulfill() + } + + await fulfillment(of: [extracted], timeout: 5) + XCTAssertNil(track.vttTimestamp.pts) + XCTAssertNil(track.vttTimestamp.localTime) + } + + func testExtractSourceTimestampReportsMissingTag() async throws { + let origin = HttpServer() + origin["/unmapped.vtt"] = { _ in .ok(.text("WEBVTT\n\n00:00:01.000 --> 00:00:02.000\nHello\n")) } + try origin.start(0, forceIPv4: true, priority: .userInitiated) + defer { origin.stop() } + let track = SSTextTrackDescription(src: "http://127.0.0.1:\(try origin.port())/unmapped.vtt", srclang: "en") + let extracted = expectation(description: "Missing timestamp reported") + + track.extractSourceTimestamp { timestamp, error in + XCTAssertNil(timestamp.pts) + XCTAssertNil(timestamp.localTime) + XCTAssertEqual(error.map { String(describing: $0) }, "Could not find a timestamp in the WebVTT file.") + extracted.fulfill() + } + + await fulfillment(of: [extracted], timeout: 5) + } +} diff --git a/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaylistTests.swift b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaylistTests.swift new file mode 100644 index 00000000..a6c8fe76 --- /dev/null +++ b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaylistTests.swift @@ -0,0 +1,257 @@ +import Foundation +import Swifter +import XCTest +@testable import THEOplayerConnectorSideloadedSubtitle +import THEOplayerSDK + +@MainActor +final class SubtitlePlaylistTests: XCTestCase { + private let cue = "\n00:00:01.000 --> 00:00:02.000\nHello\n" + + func testTimestampOverrideReplacesOrInsertsMapThroughRoute() async throws { + let origin = HttpServer() + let cue = self.cue + origin["/mapped.vtt"] = { _ in + .ok(.text("WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:90000,LOCAL:00:00:00.000\n" + cue)) + } + origin["/unmapped.vtt"] = { _ in .ok(.text("WEBVTT\n" + cue)) } + let master = try startOrigin(origin) + defer { origin.stop() } + let tracks = ["mapped.vtt", "unmapped.vtt"].map { filename in + let track = subtitle(on: master, filename) + track.vttTimestamp = .init(pts: "180000", localTime: "00:00:01.000") + return track + } + let loader = AVSubtitlesLoader(subtitles: tracks, id: #function, player: nil) + _ = try await intercept(master, type: .master, with: loader) + + for track in tracks { + let transformedURL = try subtitleSegmentURL(for: track, with: loader) + XCTAssertNotEqual(transformedURL, track.src) + let (data, response) = try await URLSession.shared.data(from: transformedURL) + + XCTAssertEqual((response as? HTTPURLResponse)?.statusCode, 200) + XCTAssertEqual( + String(decoding: data, as: UTF8.self), + "WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:180000,LOCAL:00:00:01.000\n" + cue, + track.src.lastPathComponent + ) + } + } + + func testSubtitlePlaylistUsesOriginOnlyForUnmodifiedWebVTT() async throws { + let origin = HttpServer() + origin["/plain.vtt"] = { _ in .ok(.text("WEBVTT\n\n")) } + origin["/timestamp.vtt"] = { _ in .ok(.text("WEBVTT\n\n")) } + origin["/autosync.vtt"] = { _ in .ok(.text("WEBVTT\n\n")) } + origin["/subtitle.srt"] = { _ in .ok(.text("1\n00:00:01,000 --> 00:00:02,000\nHello\n")) } + let master = try startOrigin(origin) + defer { origin.stop() } + + let plain = subtitle(on: master, "plain.vtt") + let timestamped = subtitle(on: master, "timestamp.vtt") + timestamped.vttTimestamp = .init(pts: "90000", localTime: "00:00:00.000") + let autosync = subtitle(on: master, "autosync.vtt") + autosync.automaticTimestampSyncEnabled = true + let srt = subtitle(on: master, "subtitle.srt") + srt.format = .SRT + let loader = AVSubtitlesLoader(subtitles: [plain, timestamped, autosync, srt], id: #function, player: nil) + _ = try await intercept(master, type: .master, with: loader) + + XCTAssertEqual(try subtitleSegmentURL(for: plain, with: loader), plain.src) + for track in [timestamped, autosync, srt] { + let url = try subtitleSegmentURL(for: track, with: loader) + let items = URLComponents(url: url, resolvingAgainstBaseURL: false)?.queryItems + XCTAssertEqual(url.host, "localhost") + XCTAssertEqual(url.path, "/transformSubtitle") + XCTAssertEqual(items?.first { $0.name == "url" }?.value, track.src.absoluteString) + XCTAssertNotNil(items?.first { $0.name == "t" }?.value) + } + } + + func testSourceValidatorFiltersNonSubtitlesAndIncompleteURLs() { + let master = URL(string: "https://example.com/master.m3u8")! + let valid = subtitle(on: master, "valid.vtt") + let captions = subtitle(on: master, "captions.vtt") + captions.kind = .captions + let relative = SSTextTrackDescription(src: "relative.vtt", srclang: "en", kind: .subtitles) + let hostless = SSTextTrackDescription(src: "file:///subtitle.vtt", srclang: "en", kind: .subtitles) + let video = TypedSource(src: master.absoluteString, type: "application/x-mpegurl") + + let mixed = SourceDescription(source: video, textTracks: [captions, relative, valid, hostless]) + XCTAssertEqual(SourceValidator.getValidTextTracks(mixed)?.map(\.src), [valid.src]) + + let invalid = SourceDescription(source: video, textTracks: [captions, relative, hostless]) + XCTAssertNil(SourceValidator.getValidTextTracks(invalid)) + } + + func testMasterDropsSubtitleWithNonSuccessStatus() async throws { + let origin = HttpServer() + let vtt = "WEBVTT\n" + cue + origin["/valid.vtt"] = { _ in .ok(.text(vtt)) } + origin["/missing.vtt"] = { _ in + .raw(404, "Not Found", ["Content-Type": "text/vtt"], { try $0.write([UInt8](vtt.utf8)) }) + } + let master = try startOrigin(origin) + defer { origin.stop() } + let valid = subtitle(on: master, "valid.vtt") + let missing = subtitle(on: master, "missing.vtt") + let loader = AVSubtitlesLoader(subtitles: [valid, missing], id: #function, player: nil) + + let rewritten = try await intercept(master, type: .master, with: loader) + + XCTAssertTrue(rewritten.contains(valid.src.absoluteString)) + XCTAssertFalse(rewritten.contains(missing.src.absoluteString)) + XCTAssertNil(loader.handleSubtitles(missing.src)) + } + + func testMasterRewritesExistingSubtitleGroupAndAddsRenditions() async throws { + let origin = HttpServer() + let master = try startOrigin(origin, master: """ + #EXTM3U + #EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="original",NAME="In-band",URI="subs/original%20track.m3u8",LANGUAGE="es",DEFAULT=NO,AUTOSELECT=YES + #EXT-X-STREAM-INF:BANDWIDTH=1000,SUBTITLES="original" + video.m3u8 + """) + defer { origin.stop() } + let english = subtitle(on: master, "english.vtt", language: "en", isDefault: true) + let french = subtitle(on: master, "french track.vtt", language: "fr", isDefault: false) + let parser = MasterPlaylistParser(url: master, request: nil) + let data = await parser.sideLoadSubtitles(subtitles: [english, french]) + let lines = String(decoding: try XCTUnwrap(data), as: UTF8.self).components(separatedBy: "\n") + let renditions = lines.filter { $0.hasPrefix("#EXT-X-MEDIA:") } + + XCTAssertEqual(renditions.count, 3) + for rendition in renditions { + XCTAssertTrue(rendition.contains("TYPE=SUBTITLES")) + XCTAssertTrue(rendition.contains("GROUP-ID=\"THEOsubs\"")) + } + XCTAssertEqual(renditions.filter { $0.contains("DEFAULT=YES") }.count, 1) + + XCTAssertTrue(renditions.contains { $0.contains("NAME=\"In-band\"") }) + let en = try XCTUnwrap(renditions.first { $0.contains("LANGUAGE=\"en\"") }) + XCTAssertTrue(en.contains("DEFAULT=YES")) + XCTAssertTrue(en.contains("URI=\"\(english.src.absoluteString)\"")) + let fr = try XCTUnwrap(renditions.first { $0.contains("LANGUAGE=\"fr\"") }) + XCTAssertTrue(fr.contains("DEFAULT=NO")) + let variant = try XCTUnwrap(lines.first { $0.hasPrefix("#EXT-X-STREAM-INF:") }) + XCTAssertTrue(variant.contains("SUBTITLES=\"THEOsubs\"")) + + let expectedURI = "URI=\"\(french.src.absoluteString)\"" + let options = XCTExpectedFailure.Options() + options.isStrict = false + options.issueMatcher = { _ in + fr.contains(expectedURI.replacingOccurrences(of: "%20", with: "%2520")) + } + XCTExpectFailure("Injected subtitle URIs double-encode existing escapes, independently of playlist URI resolution.", options: options) { + XCTAssertTrue(fr.contains(expectedURI), fr) + } + } + + func testSubtitleTargetDurationUsesFallbackThenSumOfVariantSegments() async throws { + let origin = HttpServer() + origin["/subtitle.vtt"] = { _ in .ok(.text("WEBVTT\n\n")) } + origin["/video.m3u8"] = { _ in .ok(.text(""" + #EXTM3U + #EXT-X-TARGETDURATION:6 + #EXT-X-PLAYLIST-TYPE:VOD + #EXTINF:3.250, + first.ts + #EXTINF:5.750, + second.ts + #EXT-X-ENDLIST + """)) } + let master = try startOrigin(origin) + defer { origin.stop() } + let track = subtitle(on: master, "subtitle.vtt") + let loader = AVSubtitlesLoader(subtitles: [track], id: #function, player: nil) + _ = try await intercept(master, type: .master, with: loader) + + XCTAssertTrue(try subtitleLines(for: track, with: loader).contains("#EXT-X-TARGETDURATION:604800")) + + let variant = master.deletingLastPathComponent().appendingPathComponent("video.m3u8") + _ = try await intercept(variant, type: .video, with: loader) + + XCTAssertTrue(try subtitleLines(for: track, with: loader).contains("#EXT-X-TARGETDURATION:9")) + } + + #if os(iOS) + func testCachingTasksKeepDifferentSourcesAndSubtitleLoaders() async throws { + let origin = HttpServer() + origin["/second.m3u8"] = { _ in .ok(.text("#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=1000\nvideo.m3u8")) } + origin["/first.vtt"] = { _ in .ok(.text("WEBVTT\n\n")) } + origin["/second.vtt"] = { _ in .ok(.text("WEBVTT\n\n")) } + let firstMaster = try startOrigin(origin) + defer { origin.stop() } + let secondMaster = firstMaster.deletingLastPathComponent().appendingPathComponent("second.m3u8") + let firstTrack = subtitle(on: firstMaster, "first.vtt") + let secondTrack = subtitle(on: secondMaster, "second.vtt") + let countBefore = AVSubtitlesLoader.instances.count + + func createTask(for master: URL, track: SSTextTrackDescription) throws -> CachingTask { + let video = TypedSource(src: master.absoluteString, type: "application/x-mpegurl") + let source = SourceDescription(source: video, textTracks: [track]) + return try XCTUnwrap(THEOplayer.cache.createTaskWithSubtitles(source: source, parameters: nil)) + } + + let first = try createTask(for: firstMaster, track: firstTrack) + defer { + first.remove() + AVSubtitlesLoader.removeInstance(by: first.id) + } + let firstLoader = try XCTUnwrap(AVSubtitlesLoader.instances.last) + let second = try createTask(for: secondMaster, track: secondTrack) + defer { + second.remove() + AVSubtitlesLoader.removeInstance(by: second.id) + } + let secondLoader = try XCTUnwrap(AVSubtitlesLoader.instances.last) + XCTAssertNotEqual(first.id, second.id) + XCTAssertFalse(firstLoader === secondLoader) + XCTAssertEqual(AVSubtitlesLoader.instances.count, countBefore + 2) + + let firstPlaylist = try await intercept(firstMaster, type: .master, with: firstLoader) + let secondPlaylist = try await intercept(secondMaster, type: .master, with: secondLoader) + XCTAssertTrue(firstPlaylist.contains(firstTrack.src.absoluteString)) + XCTAssertFalse(firstPlaylist.contains(secondTrack.src.absoluteString)) + XCTAssertTrue(secondPlaylist.contains(secondTrack.src.absoluteString)) + XCTAssertFalse(secondPlaylist.contains(firstTrack.src.absoluteString)) + } + #endif + + private func startOrigin( + _ origin: HttpServer, + master: String = "#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=1000\nvideo.m3u8" + ) throws -> URL { + origin["/master.m3u8"] = { _ in .ok(.text(master)) } + try origin.start(0, forceIPv4: true, priority: .userInitiated) + return try XCTUnwrap(URL(string: "http://127.0.0.1:\(try origin.port())/master.m3u8")) + } + + private func subtitle( + on master: URL, _ filename: String, language: String = "en", isDefault: Bool? = nil + ) -> SSTextTrackDescription { + let url = master.deletingLastPathComponent().appendingPathComponent(filename) + return SSTextTrackDescription( + src: url.absoluteString, srclang: language, isDefault: isDefault, + kind: .subtitles, label: filename, format: .WebVTT + ) + } + + private func intercept(_ url: URL, type: HlsPlaylistType, with loader: AVSubtitlesLoader) async throws -> String { + let (data, response) = try await URLSession.shared.data(from: url) + let rewritten = try await loader.didInterceptPlaylistResponse(type: type, url: url, response: response, data: data) + return String(decoding: rewritten, as: UTF8.self) + } + + private func subtitleLines(for track: SSTextTrackDescription, with loader: AVSubtitlesLoader) throws -> [String] { + let data = try XCTUnwrap(loader.handleSubtitles(track.src), "No subtitle playlist for \(track.src)") + return String(decoding: data, as: UTF8.self).components(separatedBy: "\n") + } + + private func subtitleSegmentURL(for track: SSTextTrackDescription, with loader: AVSubtitlesLoader) throws -> URL { + let lines = try subtitleLines(for: track, with: loader) + let uri = try XCTUnwrap(lines.first { !$0.isEmpty && !$0.hasPrefix("#") }) + return try XCTUnwrap(URL(string: uri)) + } +} diff --git a/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlesTransformerTests.swift b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlesTransformerTests.swift index 1cef0a66..18afa187 100644 --- a/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlesTransformerTests.swift +++ b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlesTransformerTests.swift @@ -7,6 +7,45 @@ import THEOplayerSDK @MainActor final class SubtitlesTransformerTests: XCTestCase { + func testSRTRouteConvertsCueTimingsAndText() async throws { + let origin = HttpServer() + origin["/subtitle.srt"] = { _ in + .ok(.text("1\r\n00:00:01,234 --> 00:00:03,456\r\nHello from SRT\r\n\r\n")) + } + try origin.start(0, forceIPv4: true, priority: .userInitiated) + defer { origin.stop() } + let source = "http://127.0.0.1:\(try origin.port())/subtitle.srt" + let transformer = SubtitlesTransformer() + let url = try XCTUnwrap(URL(string: transformer.composeTranformationUrl( + with: source, format: .SRT, timestamp: nil + ))) + + let (data, response) = try await URLSession.shared.data(from: url) + let vtt = String(decoding: data, as: UTF8.self) + + XCTAssertEqual((response as? HTTPURLResponse)?.statusCode, 200) + XCTAssertTrue(vtt.hasPrefix("WEBVTT\n\n")) + XCTAssertTrue(vtt.contains("\n00:00:01.234 --> 00:00:03.456\nHello from SRT\n")) + } + + func testRecomposingTransformationURLChangesCacheBusterEveryCall() throws { + let transformer = SubtitlesTransformer() + let source = "https://example.com/subtitle.srt" + let urls = (0..<100).map { _ in + transformer.composeTranformationUrl(with: source, format: .SRT, timestamp: nil) + } + let cacheBusters = try urls.map { url in + let items = URLComponents(string: url)?.queryItems + return try XCTUnwrap(items?.first { $0.name == "t" }?.value) + } + + let options = XCTExpectedFailure.Options() + options.isStrict = false + XCTExpectFailure("Calls within the same millisecond can reuse t=.", options: options) { + XCTAssertEqual(Set(cacheBusters).count, cacheBusters.count) + } + } + func testForegroundRestartsStoppedServerOnSamePort() async throws { let origin = HttpServer() origin["/subtitle.srt"] = { _ in .ok(.text("1\n00:00:00,000 --> 00:00:01,000\nHello\n")) } diff --git a/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/TimestampStringUtilsTests.swift b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/TimestampStringUtilsTests.swift new file mode 100644 index 00000000..0f186625 --- /dev/null +++ b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/TimestampStringUtilsTests.swift @@ -0,0 +1,33 @@ +import XCTest +@testable import THEOplayerConnectorSideloadedSubtitle + +final class TimestampStringUtilsTests: XCTestCase { + private let cue = "\n00:00:01.000 --> 00:00:02.000\nHello\n" + + func testReadsTimestampWithColonsInLocalTime() throws { + let vtt = "WEBVTT\nX-TIMESTAMP-MAP=LOCAL:01:02:03.456,MPEGTS:90000\n" + cue + let (pts, localTime) = try XCTUnwrap(TimestampStringUtils.getTimestampValues(from: vtt)) + + XCTAssertEqual(pts, "90000") + XCTAssertEqual(localTime, "01:02:03.456") + } + + func testOverridesTimestampWithoutChangingCue() { + let vtt = "WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:90000,LOCAL:00:00:00.000\n" + cue + let overridden = TimestampStringUtils.overrideTimestamp(in: vtt, with: ("180000", "00:00:01.000")) + + XCTAssertEqual(overridden, "WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:180000,LOCAL:00:00:01.000\n" + cue) + } + + func testInsertsTimestampWhenTagIsMissing() { + let vtt = "WEBVTT\n" + cue + let values = ("180000", "00:00:01.000") + + XCTAssertNil(TimestampStringUtils.getTimestampValues(from: vtt)) + XCTAssertNil(TimestampStringUtils.overrideTimestamp(in: vtt, with: values)) + XCTAssertEqual( + TimestampStringUtils.insertTimestamp(in: vtt, with: values), + "WEBVTT\nX-TIMESTAMP-MAP=MPEGTS:180000,LOCAL:00:00:01.000\n" + cue + ) + } +} From 88cb9e73f26dba534db30f648f13688f24f3d083 Mon Sep 17 00:00:00 2001 From: Ceyhun Ozgoc Date: Fri, 20 Nov 2026 03:01:22 -0800 Subject: [PATCH 2/2] SideloadedSubtitle: verify subtitle cue entry during playback Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Co-Authored-By: Ceyhun Ozgoc --- .../SubtitlePlaybackTests.swift | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaybackTests.swift diff --git a/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaybackTests.swift b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaybackTests.swift new file mode 100644 index 00000000..1baacb15 --- /dev/null +++ b/Code/Sideloaded-TextTracks/Tests/THEOplayerConnectorSideloadedSubtitleTests/SubtitlePlaybackTests.swift @@ -0,0 +1,47 @@ +import XCTest +import THEOplayerConnectorSideloadedSubtitle +import THEOplayerSDK + +@MainActor +final class SubtitlePlaybackTests: XCTestCase { + func testSideloadedWebVTTAddsTrackAndEntersCueDuringPlayback() async { + let base = "https://cdn.theoplayer.com/video/elephants-dream" + let video = TypedSource(src: "\(base)/playlist-no-subtitles.m3u8", type: "application/x-mpegurl") + let subtitle = SSTextTrackDescription( + src: "\(base)/captions.en.vtt", srclang: "en", isDefault: false, + kind: .subtitles, label: "English", format: .WebVTT + ) + let player = THEOplayer(with: nil) + let added = expectation(description: "English sideloaded subtitle track added") + let entered = expectation(description: "First English subtitle cue entered") + var foundTrack = false + let addListener = player.textTracks.addEventListener(type: TextTrackListEventTypes.ADD_TRACK) { event in + guard !foundTrack, let track = event.track as? TextTrack, track.language == "en" else { return } + foundTrack = true + var observedCue = false + _ = track.addEventListener(type: TextTrackEventTypes.ADD_CUE) { event in + guard !observedCue else { return } + observedCue = true + XCTAssertTrue(event.cue.contentString?.contains("At the left we can see") == true) + _ = event.cue.addEventListener(type: TextTrackCueEventTypes.ENTER) { _ in + entered.fulfill() + } + } + added.fulfill() + track.mode = .showing + } + let errorListener = player.addEventListener(type: PlayerEventTypes.ERROR) { event in + XCTFail("Playback error: \(event.errorObject?.message ?? "unknown")") + } + defer { + player.textTracks.removeEventListener(type: TextTrackListEventTypes.ADD_TRACK, listener: addListener) + player.removeEventListener(type: PlayerEventTypes.ERROR, listener: errorListener) + player.setSourceWithSubtitles(source: nil) + } + + player.setSourceWithSubtitles(source: SourceDescription(source: video, textTracks: [subtitle])) + player.play() + + await fulfillment(of: [added, entered], timeout: 45, enforceOrder: true) + } +}