Repository Public License
1//2// ORIX Audio3// File: Tests/AppTests.swift4// Description: App-level tests: capture pipeline, finalization and recovery, import (audio, video, bad files), library operations, exports, actions.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8//9import AVFoundation10import Foundation11import ORIXAudioCore12import Testing13@testable import ORIXAudio1415func fixture(_ name: String) -> URL { Bundle(for: FixtureToken.self).bundleURL.appendingPathComponent("Fixtures").appendingPathComponent(name) }16final class FixtureToken {}1718func makeTone(seconds: Double, frequency: Double = 1000, rate: Double = 48_000, channels: Int = 1, amplitude: Double = 0.5, gapAt: ClosedRange<Double>? = nil) throws -> URL {19 let url = FileManager.default.temporaryDirectory.appendingPathComponent("orix-test-\(UUID().uuidString).wav")20 var x = SignalGenerator.sine(frequency: frequency, amplitude: amplitude, sampleRate: rate, count: Int(rate * seconds))21 if let gapAt { for i in Int(gapAt.lowerBound * rate)..<Int(gapAt.upperBound * rate) { x[i] = 0 } }22 let w = try AudioFileWriter(url: url, format: .wav24, inputSampleRate: rate, channels: channels)23 try w.write([[Float]](repeating: x, count: channels)); try w.finish()24 return url25}2627@Suite(.serialized) struct CapturePipelineTests {28 @Test func recordPauseResumeStopWritesExactlyWhatWasAccepted() async throws {29 let source = try makeTone(seconds: 10, frequency: 1500, channels: 2)30 AudioCaptureEngine.debugInputFile = source31 defer { AudioCaptureEngine.debugInputFile = nil; try? FileManager.default.removeItem(at: source) }32 let sidecar = CaptureSidecar(id: UUID(), title: "Pipeline", startedAt: .now, preset: .highQuality, markers: [], participants: "")33 let engine = try AudioCaptureEngine(url: sidecar.cafURL, preset: .highQuality)34 #expect(engine.format == CaptureFormat(sampleRate: 48_000, channels: 2, sampleFormat: .int24))35 try engine.start()36 try await Task.sleep(for: .seconds(1.5))37 engine.pause()38 try await Task.sleep(for: .milliseconds(200))39 let atPause = engine.framesAccepted40 try await Task.sleep(for: .milliseconds(600))41 #expect(engine.framesAccepted == atPause) // nothing is captured while paused42 try engine.resume()43 try await Task.sleep(for: .seconds(1))44 // Live visuals come from the audio itself.45 let spectrum = try #require(engine.visuals.read { $0.spectrum })46 #expect(abs((spectrum.dominantFrequency ?? 0) - 1500) < 3)47 #expect(abs(spectrum.dominantLevel - (-6.02)) < 0.5)48 let levels = engine.visuals.read { $0.levels }49 #expect(abs(levels.peakHoldDB - (-6.02)) < 0.5 && !levels.isClipping)50 let buckets = engine.visuals.buckets(after: 0)51 #expect(buckets.new.last?.dominantBand == 3) // 1.5 kHz → "Mid" band52 // The analysis thread must keep up with real time: every captured sample reaches the visuals.53 let expectedBuckets = engine.framesAccepted / 51254 #expect(buckets.total >= expectedBuckets - 12, "analysis produced \(buckets.total) of \(expectedBuckets) buckets")55 #expect(engine.visuals.columns(after: 0).total > 50)56 await Task.detached { engine.stop() }.value57 #expect(engine.droppedSamples == 0)58 #expect(engine.framesWritten == engine.framesAccepted)59 let inspected = try #require(CAFWriter.inspect(url: sidecar.cafURL))60 #expect(inspected.frames == engine.framesAccepted)61 #expect(abs(engine.duration - 2.5) < 0.4)6263 // Finalize to WAV 24-bit and check the audio survived bit-accurately in shape.64 sidecar.save()65 let result = try RecordingFinalizer.finalize(sidecar)66 #expect(result.info.codec == "Linear PCM" && result.info.bitDepth == 24 && result.info.channels == 2 && result.info.isLossless)67 #expect(abs(result.info.duration - engine.duration) < 0.01)68 #expect(!FileManager.default.fileExists(atPath: sidecar.cafURL.path) && !FileManager.default.fileExists(atPath: sidecar.url.path))69 let report = try AudioAnalyzer.analyze(url: LibraryFiles.folder(for: sidecar.id).appendingPathComponent(result.fileName)).report70 #expect(abs((report.spectral.dominantFrequencyHz ?? 0) - 1500) < 2 && abs(report.time.peakDBFS - (-6.02)) < 0.1)71 try? FileManager.default.removeItem(at: LibraryFiles.folder(for: sidecar.id))72 }7374 @Test func analysisKeepsUpAtLowSampleRates() async throws {75 AudioCaptureEngine.debugInputFile = fixture("speech-en.m4a") // 22.05 kHz mono76 defer { AudioCaptureEngine.debugInputFile = nil }77 let sidecar = CaptureSidecar(id: UUID(), title: "Low rate", startedAt: .now, preset: .lossless, markers: [], participants: "")78 let engine = try AudioCaptureEngine(url: sidecar.cafURL, preset: .lossless)79 defer { sidecar.remove() }80 try engine.start()81 try await Task.sleep(for: .seconds(4))82 let total = engine.visuals.buckets(after: 0).total, expected = engine.framesAccepted / 51283 let columns = engine.visuals.columns(after: 0).total84 await Task.detached { engine.stop() }.value85 #expect(total >= expected - 12, "analysis produced \(total) of \(expected) buckets at \(engine.format.sampleRate) Hz")86 #expect(columns >= expected - 12)87 #expect(engine.framesWritten == engine.framesAccepted)88 }8990 @Test(arguments: RecordingPreset.allCases) func everyPresetFinalizesToItsDeclaredFormat(_ preset: RecordingPreset) throws {91 let sidecar = CaptureSidecar(id: UUID(), title: "Preset", startedAt: .now, preset: preset, markers: [Marker(time: 0.5, label: "A")], participants: "")92 let writer = try CAFWriter(url: sidecar.cafURL, format: CaptureFormat(sampleRate: 48_000, channels: preset.prefersStereo ? 2 : 1, sampleFormat: preset.masterFormat))93 let x = SignalGenerator.sine(frequency: 440, amplitude: 0.4, sampleRate: 48_000, count: 96_000 * (preset.prefersStereo ? 2 : 1))94 try x.withUnsafeBufferPointer { try writer.write(interleaved: $0.baseAddress!, frames: 96_000) }95 try writer.close()96 let result = try RecordingFinalizer.finalize(sidecar)97 defer { try? FileManager.default.removeItem(at: LibraryFiles.folder(for: sidecar.id)) }98 #expect(result.info.isLossless == preset.format.isLossless)99 #expect(result.info.codec == preset.format.codecName)100 #expect(result.info.sampleRate == (preset == .voice ? 24_000 : 48_000))101 #expect(result.info.channels == (preset.prefersStereo ? 2 : 1))102 #expect(abs(result.info.duration - 2) < 0.1)103 if preset.format != .aac { #expect(result.info.bitDepth == 24) }104 }105106 @Test func interruptedSessionIsFoundAndRecovered() throws {107 // What a crash leaves behind: a master with no close(), a torn last write, and its sidecar.108 let sidecar = CaptureSidecar(id: UUID(), title: "Crashed meeting", startedAt: .now.addingTimeInterval(-60), preset: .meeting, markers: [Marker(time: 1, label: "Decision")], participants: "A, B")109 sidecar.save()110 do {111 let writer = try CAFWriter(url: sidecar.cafURL, format: CaptureFormat(sampleRate: 44_100, channels: 1, sampleFormat: .int16))112 let x = SignalGenerator.sine(frequency: 300, amplitude: 0.3, sampleRate: 44_100, count: 44_100 * 3)113 try x.withUnsafeBufferPointer { try writer.write(interleaved: $0.baseAddress!, frames: x.count) }114 try writer.synchronize()115 }116 let h = try FileHandle(forWritingTo: sidecar.cafURL); try h.seekToEnd(); try h.write(contentsOf: Data([1])); try h.close()117 let found = try #require(RecordingRecovery.scan(excluding: nil).first { $0.id == sidecar.id })118 #expect(abs(found.duration - 3) < 0.001 && found.sidecar.markers.count == 1 && found.sidecar.title == "Crashed meeting")119 #expect(RecordingRecovery.scan(excluding: sidecar.id).contains { $0.id == sidecar.id } == false) // the active session is never offered120 let result = try RecordingFinalizer.finalize(found.sidecar)121 defer { try? FileManager.default.removeItem(at: LibraryFiles.folder(for: sidecar.id)) }122 #expect(abs(result.info.duration - 3) < 0.1 && result.info.codec == "AAC-LC")123 #expect(RecordingRecovery.scan(excluding: nil).contains { $0.id == sidecar.id } == false)124 }125126 @Test func emptyAndOrphanCapturesAreHandled() throws {127 let empty = CaptureSidecar(id: UUID(), title: "Empty", startedAt: .now, preset: .voice, markers: [], participants: "")128 empty.save()129 try CAFWriter(url: empty.cafURL, format: CaptureFormat(sampleRate: 48_000, channels: 1, sampleFormat: .int16)).close()130 #expect(throws: FinalizeError.self) { try RecordingFinalizer.finalize(empty) }131 _ = RecordingRecovery.scan(excluding: nil) // an empty master is cleaned up, not offered132 #expect(!FileManager.default.fileExists(atPath: empty.cafURL.path))133 // A master whose sidecar is missing is still recoverable.134 let orphan = UUID()135 let url = LibraryFiles.capture.appendingPathComponent("\(orphan.uuidString).caf")136 let w = try CAFWriter(url: url, format: CaptureFormat(sampleRate: 48_000, channels: 1, sampleFormat: .int16))137 try SignalGenerator.sine(frequency: 500, sampleRate: 48_000, count: 48_000).withUnsafeBufferPointer { try w.write(interleaved: $0.baseAddress!, frames: 48_000) }138 try w.close()139 let found = try #require(RecordingRecovery.scan(excluding: nil).first { $0.id == orphan })140 #expect(abs(found.duration - 1) < 0.001)141 found.sidecar.remove()142 }143144 @Test func masterFilesStayWritableWhileLocked() throws {145 let url = LibraryFiles.capture.appendingPathComponent("\(UUID().uuidString).caf")146 _ = try CAFWriter(url: url, format: CaptureFormat(sampleRate: 48_000, channels: 1, sampleFormat: .int16), protection: LibraryFiles.protection)147 defer { try? FileManager.default.removeItem(at: url) }148 // The simulator doesn't enforce data protection, but the attribute request must be the "until first unlock" class.149 #expect(LibraryFiles.protection == .completeUntilFirstUserAuthentication)150 #expect(FileManager.default.fileExists(atPath: url.path))151 }152}153154@Suite struct ImportTests {155 @Test func importsCompressedAudioAndReadsItsMetadata() async throws {156 let media = try await MediaImporter.importFile(at: fixture("speech-en.m4a"))157 defer { try? FileManager.default.removeItem(at: LibraryFiles.folder(for: media.id)) }158 #expect(!media.isVideo && media.info.codec == "AAC-LC" && !media.info.isLossless && media.info.channels == 1)159 #expect(media.info.duration > 5 && media.info.fileSize > 10_000 && media.originalName == "speech-en.m4a")160 #expect(FileManager.default.fileExists(atPath: fixture("speech-en.m4a").path)) // the original is untouched161 }162163 @Test func importsMP3() async throws {164 let media = try await MediaImporter.importFile(at: fixture("tone.mp3"))165 defer { try? FileManager.default.removeItem(at: LibraryFiles.folder(for: media.id)) }166 #expect(media.info.codec == "MP3" && abs(media.info.duration - 3) < 0.2)167 let report = try AudioAnalyzer.analyze(url: LibraryFiles.folder(for: media.id).appendingPathComponent(media.fileName)).report168 #expect(abs((report.spectral.dominantFrequencyHz ?? 0) - 1000) < 3)169 }170171 @Test func extractsTheAudioTrackOfAVideo() async throws {172 let before = try Data(contentsOf: fixture("clip.mp4"))173 let media = try await MediaImporter.importFile(at: fixture("clip.mp4"))174 defer { try? FileManager.default.removeItem(at: LibraryFiles.folder(for: media.id)) }175 #expect(media.isVideo && media.fileName.hasSuffix(".m4a") && media.info.codec == "AAC-LC") // AAC track copied, not re-encoded176 #expect(abs(media.info.duration - 4) < 0.3)177 #expect(try Data(contentsOf: fixture("clip.mp4")) == before) // the video is not modified178 let report = try AudioAnalyzer.analyze(url: LibraryFiles.folder(for: media.id).appendingPathComponent(media.fileName)).report179 #expect(report.time.rmsDBFS > -40) // it really contains the speech180 }181182 @Test func videoWithoutAudioIsRejectedCleanly() async {183 await #expect(throws: ImportError.self) { try await MediaImporter.importFile(at: fixture("clip-noaudio.mp4")) }184 }185186 @Test func corruptedAndUnsupportedFilesFailWithoutLeavingFolders() async throws {187 let before = Set((try? FileManager.default.contentsOfDirectory(atPath: LibraryFiles.recordings.path)) ?? [])188 let junk = FileManager.default.temporaryDirectory.appendingPathComponent("junk-\(UUID().uuidString).wav")189 try Data((0..<4096).map { _ in UInt8.random(in: 0...255) }).write(to: junk)190 defer { try? FileManager.default.removeItem(at: junk) }191 await #expect(throws: (any Error).self) { try await MediaImporter.importFile(at: junk) }192 let truncated = FileManager.default.temporaryDirectory.appendingPathComponent("cut-\(UUID().uuidString).mp4")193 try Data(contentsOf: fixture("clip.mp4")).prefix(700).write(to: truncated)194 defer { try? FileManager.default.removeItem(at: truncated) }195 await #expect(throws: (any Error).self) { try await MediaImporter.importFile(at: truncated) }196 #expect(Set((try? FileManager.default.contentsOfDirectory(atPath: LibraryFiles.recordings.path)) ?? []) == before)197 }198199 @Test(arguments: [(8000.0, 1), (22_050, 2), (44_100, 2), (96_000, 1)]) func importsAnySampleRateAndChannelLayout(_ rate: Double, _ channels: Int) async throws {200 let source = try makeTone(seconds: 1, frequency: 440, rate: rate, channels: channels)201 defer { try? FileManager.default.removeItem(at: source) }202 let media = try await MediaImporter.importFile(at: source)203 defer { try? FileManager.default.removeItem(at: LibraryFiles.folder(for: media.id)) }204 #expect(media.info.sampleRate == rate && media.info.channels == channels && media.info.isLossless && media.info.bitDepth == 24)205 }206}207208@MainActor @Suite(.serialized) struct LibraryAndActionsTests {209 func importTone(_ model: AppModel, seconds: Double = 4, gap: ClosedRange<Double>? = nil) async throws -> Recording {210 let source = try makeTone(seconds: seconds, frequency: 880, amplitude: 0.25, gapAt: gap)211 defer { try? FileManager.default.removeItem(at: source) }212 model.settings.analyzeAutomatically = false213 await model.importFiles([source])214 let id = try #require(model.pendingOpen)215 return try #require(model.recording(id))216 }217218 @Test func libraryLifecycle() async throws {219 let model = AppModel(inMemory: true)220 let recording = try await importTone(model)221 #expect(recording.source == .importedAudio && recording.kind == .imported && abs(recording.duration - 4) < 0.01)222 #expect(recording.formatLine == "Linear PCM · 24-bit · 48 kHz · \(String(localized: "Mono"))")223 model.duplicate(recording)224 let all = try model.context.fetch(.init()) as [Recording]225 #expect(all.count == 2)226 let copy = try #require(all.first { $0.id != recording.id })227 #expect(FileManager.default.fileExists(atPath: copy.audioURL.path))228 model.moveToTrash(recording)229 #expect(recording.deletedAt != nil && FileManager.default.fileExists(atPath: recording.audioURL.path)) // trash keeps the file230 model.restore(recording)231 #expect(recording.deletedAt == nil)232 let folder = LibraryFiles.folder(for: recording.id)233 model.purge(recording); model.purge(copy)234 #expect(!FileManager.default.fileExists(atPath: folder.path))235 #expect((try model.context.fetch(.init()) as [Recording]).isEmpty)236 }237238 @Test func analysisIsStoredAndMarkersPersist() async throws {239 let model = AppModel(inMemory: true)240 let recording = try await importTone(model)241 defer { model.purge(recording) }242 try await model.processing.analyze(recording)243 #expect(recording.analysisStatus == .done && abs((recording.peakDBFS ?? 0) - (-12.04)) < 0.1)244 let report = try #require(LibraryFiles.analysis(recording.id))245 #expect(abs((report.spectral.dominantFrequencyHz ?? 0) - 880) < 2)246 #expect(LibraryFiles.waveform(recording.id)?.totalSamples == 192_000)247 recording.markers = [Marker(time: 3, label: "b"), Marker(time: 1, label: "a")]248 #expect(recording.markers.map(\.label) == ["a", "b"])249 }250251 @Test func workflowProducesANewRecordingAndLeavesTheOriginalAlone() async throws {252 let model = AppModel(inMemory: true)253 let recording = try await importTone(model, seconds: 8, gap: 2.0...5.0)254 let originalBytes = try Data(contentsOf: recording.audioURL)255 let workflow = Workflow(name: "Test", steps: [.analyze, .removeSilence(minimumSeconds: 1.5), .normalize(targetPeakDBFS: -1), .convert(format: .alac), .analyze, .exportReport])256 await model.actions.run(workflow, on: [recording])257 let failures = model.actions.log.filter { if case .failed = $0.outcome { true } else { false } }258 #expect(failures.isEmpty, "\(model.actions.log.map { "\($0.step): \($0.outcome)" })")259 #expect(model.actions.log.count == 6)260 let created = try #require(model.actions.createdRecordings.first.flatMap(model.recording))261 defer { model.purge(created); model.purge(recording) }262 #expect(created.codec == "Apple Lossless (ALAC)" && created.source == .edited)263 #expect(created.duration < 5.9 && created.duration > 5.0) // about 2.7 s of the 3 s gap removed (padding kept)264 #expect(abs((created.peakDBFS ?? -99) - (-1)) < 0.1) // normalized, measured by the second Analyze step265 #expect(try Data(contentsOf: recording.audioURL) == originalBytes) // original untouched266 let pdf = try #require(model.actions.outputs.first)267 #expect(try Data(contentsOf: pdf).prefix(5) == Data("%PDF-".utf8))268 }269270 @Test func aStepThatCannotRunIsReportedNotFaked() async throws {271 let model = AppModel(inMemory: true)272 let recording = try await importTone(model, seconds: 2)273 defer { model.purge(recording) }274 await model.actions.run(Workflow(name: "T", steps: [.exportTranscript(format: .srt)]), on: [recording])275 guard case .failed = try #require(model.actions.log.first).outcome else { Issue.record("expected a failure: there is no transcript"); return }276 #expect(model.actions.outputs.isEmpty)277 }278279 @Test func exportsAreRealFiles() async throws {280 let model = AppModel(inMemory: true)281 let recording = try await importTone(model, seconds: 3)282 defer { model.purge(recording) }283 for format in AudioExportFormat.allCases {284 let url = try await ExportService.audio(sourceURL: recording.audioURL, title: recording.title, duration: recording.duration, format: format, range: 1.0...2.0)285 let info = try AudioFileReader.info(url: url)286 #expect(abs(info.duration - 1) < 0.1 && info.isLossless == format.isLossless, "\(format)")287 }288 let transcript = Transcript(localeIdentifier: "en-US", engine: "test", segments: [.init(start: 0, end: 1, text: "Hello there."), .init(start: 1, end: 2, text: "Second line.", speaker: "Speaker 2")])289 for format in TranscriptFileFormat.allCases {290 let url = try ExportService.transcript(transcript, title: "T/1: x", format: format)291 #expect(url.pathExtension == format.fileExtension && !url.lastPathComponent.contains(":"))292 let data = try Data(contentsOf: url)293 #expect(format == .pdf ? data.prefix(5) == Data("%PDF-".utf8) : String(decoding: data, as: UTF8.self).contains("Hello there."))294 }295 try await model.processing.analyze(recording)296 let report = try #require(LibraryFiles.analysis(recording.id))297 for format in ReportFormat.allCases { #expect(try Data(contentsOf: ExportService.report(report, title: "R", format: format)).count > 200) }298 let summary = try #require(LibraryFiles.waveform(recording.id))299 let image = try #require(WaveformRendering.image(summary: summary, style: .bands, size: CGSize(width: 800, height: 300), title: "W"))300 #expect(image.width == 1600 && image.height == 600)301 let tiles = try #require(SpectrogramTileStore(url: recording.audioURL))302 let tile = try #require(await tiles.overview(width: 800, fftSize: 1024))303 // The 880 Hz tone is the brightest bin in every column.304 let column = tile.columnCount / 2305 let ridge = (0..<tile.binCount).max { tile.value(column: column, bin: $0) < tile.value(column: column, bin: $1) }!306 #expect(abs(tile.frequency(ofBin: ridge) - 880) <= 48_000 / 1024)307 #expect(SpectrogramImage.render(tile: tile, rows: 256, display: SpectrogramDisplay())?.height == 256)308 }309}310311@Suite struct ViewLogicTests {312 @Test func timelineZoomPanAndSelectionStayInRange() {313 var t = TimelineState(duration: 100)314 #expect(!t.isZoomed && t.x(for: 50, width: 200) == 100)315 t.zoom(by: 4, anchorFraction: 0.5)316 #expect(abs(t.visibleDuration - 25) < 1e-9 && abs(t.visibleStart - 37.5) < 1e-9)317 t.pan(bySeconds: 1000)318 #expect(abs(t.visibleEnd - 100) < 1e-9)319 t.pan(bySeconds: -1000)320 #expect(t.visibleStart == 0)321 t.zoom(by: 1e9, anchorFraction: 0)322 #expect(t.visibleDuration == TimelineState.minimumVisible)323 t.reset(); t.selection = 80...95; t.setDuration(90)324 #expect(t.selection == 80...90 && t.visibleDuration == 90)325 t.setDuration(50)326 #expect(t.selection == nil)327 #expect(abs(t.time(forX: 100, width: 200) - 25) < 1e-9)328 #expect(TimelineState(duration: 3600).tickInterval(width: 400) >= 600)329 }330331 @Test func rebinKeepsExtremes() {332 let buckets = (0..<1000).map { WaveformBucket(min: -Float($0) / 1000, max: Float($0) / 1000, rms: 0.1, bands: .init(repeating: 1)) }333 let bars = WaveformRendering.rebin(buckets[...], to: 10)334 #expect(bars.count == 10 && bars.last?.max == 0.999 && bars.first?.min == -0.099)335 #expect(WaveformRendering.rebin(buckets[0..<5], to: 10).count == 5 && WaveformRendering.rebin([], to: 10).isEmpty)336 }337338 @Test func tileLevelsNeverSkipAudio() async throws {339 let source = try makeTone(seconds: 30, frequency: 2000)340 defer { try? FileManager.default.removeItem(at: source) }341 let store = try #require(SpectrogramTileStore(url: source))342 #expect(store.level(forSecondsPerPoint: 0.0001, fftSize: 2048) == 0)343 let coarse = store.level(forSecondsPerPoint: 30.0 / 300, fftSize: 2048)344 #expect(coarse >= 3)345 // A 20 ms click placed between coarse columns must still show up thanks to max-pooling.346 var x = [Float](repeating: 0, count: 48_000 * 10)347 for i in 240_000..<240_960 { x[i] = 0.9 * sin(Float(i) * 2 * .pi * 6000 / 48_000) }348 let click = FileManager.default.temporaryDirectory.appendingPathComponent("click-\(UUID().uuidString).wav")349 let w = try AudioFileWriter(url: click, format: .wav16, inputSampleRate: 48_000, channels: 1); try w.write([x]); try w.finish()350 defer { try? FileManager.default.removeItem(at: click) }351 let clickStore = try #require(SpectrogramTileStore(url: click))352 let tile = try #require(await clickStore.tile(.init(level: 6, index: 0, fftSize: 1024)))353 let bin = 6000 * 1024 / 48_000354 #expect((0..<tile.columnCount).contains { tile.value(column: $0, bin: bin) > -20 })355 }356357 @Test func presetsNeverCallLossyAudioLossless() {358 for preset in RecordingPreset.allCases {359 let text = PresetText.summary(preset) + PresetText.detail(preset)360 if preset.format == .aac { #expect(!text.localizedCaseInsensitiveContains("lossless") && !text.localizedCaseInsensitiveContains("uncompressed")) }361 #expect(preset.format.isLossless == (preset == .highQuality || preset == .lossless))362 }363 #expect(!AudioExportFormat.allCases.contains { $0.fileExtension == "mp3" }) // no MP3 encoder exists on iOS: not offered364 }365}366