SPB Git

Repository Public License

AppTests.swift 24.0 KB 366 lines swift

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
Files main
Menu

Theme