Files
VCCPlusOSS/platforms/macos/Tests/CoCoCaptureTests.swift
T

780 lines
53 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import AVFoundation
import AppKit
final class CoCoCaptureTests: XCTestCase {
private final class HeldPullController: VCCMachineController, @unchecked Sendable {
private let lock = NSLock()
private var reply: (() -> Void)?
private var holdNextPull = true
private var finals = 0
var heldReply: (() -> Void)? { lock.withLock { reply } }
var finalPulls: Int { lock.withLock { finals } }
override func takeVideoCapture(finish: Bool, replyQueue: DispatchQueue, completion: @escaping ([VCCVideoPacket], String?) -> Void) {
if finish { lock.withLock { finals += 1 } }
super.takeVideoCapture(finish: finish, replyQueue: replyQueue) { [self] packets, error in
let held = lock.withLock {
if !finish && holdNextPull {
holdNextPull = false; reply = { completion(packets, error) }; return true
}
return false
}
if !held { completion(packets, error) }
}
}
func releasePull() { let value = lock.withLock { let value = reply; reply = nil; return value }; value?() }
}
private final class InvalidCapturePacket: VCCVideoPacket {
private let original: VCCVideoPacket
init(_ original: VCCVideoPacket) { self.original = original; super.init() }
override var pixels: Data { Data() }
override var samples: Data { original.samples }
override var activeArea: CGRect { original.activeArea }
override var sampleOffset: UInt64 { original.sampleOffset }
}
private final class FailingPullController: VCCMachineController, @unchecked Sendable {
private let lock = NSLock()
private var failPull = false
private var invalidPull = false
private var finals = 0
var finalPulls: Int { lock.withLock { finals } }
var failNextPull: Bool { get { lock.withLock { failPull } } set { lock.withLock { failPull = newValue } } }
var invalidateNextPull: Bool { get { lock.withLock { invalidPull } } set { lock.withLock { invalidPull = newValue } } }
override func takeVideoCapture(finish: Bool, replyQueue: DispatchQueue, completion: @escaping ([VCCVideoPacket], String?) -> Void) {
if finish { lock.withLock { finals += 1 } }
super.takeVideoCapture(finish: finish, replyQueue: replyQueue) { [self] packets, error in
let fail = lock.withLock { let fail = !finish && failPull; if fail { failPull = false }; return fail }
if fail {
completion(packets, "Authored capture-consumer interruption")
} else {
let invalid = lock.withLock { let invalid = !finish && invalidPull && !packets.isEmpty; if invalid { invalidPull = false }; return invalid }
if invalid { completion([InvalidCapturePacket(packets[0])] + Array(packets.dropFirst()), error) }
else { completion(packets, error) }
}
}
}
}
/// Deliberately occupies the UI executor longer than the bridge's eight
/// packets can buffer. This is test-only starvation, never a product wait.
private func holdMainActor() { Thread.sleep(forTimeInterval: 0.8) }
private final class BookmarkGate: @unchecked Sendable {
private let lock = NSLock()
private let release = DispatchSemaphore(value: 0)
private var began = false
let blocked: URL
let fails: Bool
init(blocked: URL, fails: Bool = false) { self.blocked = blocked; self.fails = fails }
var started: Bool { lock.withLock { began } }
func unblock() { release.signal() }
func prepare(_ url: URL) throws -> Data {
XCTAssertFalse(Thread.isMainThread, "Bookmark creation must not occupy the UI thread")
if url == blocked {
lock.withLock { began = true }
guard release.wait(timeout: .now() + 5) == .success else { throw CoCoRecordingError.message("The authored bookmark gate timed out") }
if fails { throw CocoaError(.fileReadNoSuchFile) }
}
return try url.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil)
}
}
/// Each lifecycle case owns its controller, defaults and media directory.
/// Feedback is injected by the caller; these tests never play host cues.
@MainActor private func guest(controller: VCCMachineController = VCCMachineController(), use6309: Bool = false) async throws -> (URL, UserDefaults, MachineModel) {
let root = try folder(), suite = "CoCoCaptureLifecycle-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
addTeardownBlock { defaults.removePersistentDomain(forName: suite) }
// Never ask the native test runner to bookmark the person's Desktop.
// Seed the owned location before preferences initialize, on both hosts.
defaults.set(try root.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil), forKey: "capture.folder.shared")
let model = MachineModel(diskStore: .init(url: root.appendingPathComponent("Disks.json")), controller: controller,
displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("Input.json")), restoreMediaOnLaunch: false)
addTeardownBlock { await withCheckedContinuation { c in controller.shutdown { _ in c.resume() } } }
await withCheckedContinuation { c in controller.loadDiagnostic(use6309: use6309) { _ in c.resume() } }
await withCheckedContinuation { c in controller.resume { _ in c.resume() } }
for _ in 0..<200 where model.pixels == nil { model.poll(); try await Task.sleep(for: .milliseconds(10)) }
_ = try XCTUnwrap(model.pixels, "The owned authored diagnostic must publish a frame")
return (root, defaults, model)
}
private func folder() throws -> URL {
let url = FileManager.default.temporaryDirectory.appendingPathComponent("CoCoCapture-" + UUID().uuidString)
try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
addTeardownBlock { try? FileManager.default.removeItem(at: url) }
return url
}
private func picture() -> Data {
var data = Data(count: 640 * 480 * 4)
data.withUnsafeMutableBytes { raw in
let p = raw.bindMemory(to: UInt8.self)
for y in 0..<480 { for x in 0..<640 {
let n = (y * 640 + x) * 4
// Green outside the crop, red above blue inside: catches both
// unwanted border content and an upside-down encoded picture.
if x < 64 || x >= 576 || y < 48 || y >= 432 { p[n+1] = 255 }
else if y < 240 { p[n+2] = 255 } else { p[n] = 255 }
} }
}
return data
}
func testQuickSaveCollisionIsAtomicAndRetainsOriginal() throws {
let dir = try folder()
let first = dir.appendingPathComponent("Example.png")
try Data([1,2,3]).write(to: first)
let temporary = dir.appendingPathComponent("temporary")
try Data([4,5,6]).write(to: temporary)
let second = try CoCoCaptureFiles.promote(temporary, folder: dir, name: "Example", extension: "png")
XCTAssertEqual(second.lastPathComponent, "Example-1.png")
XCTAssertEqual(try Data(contentsOf: first), Data([1,2,3]))
XCTAssertEqual(try Data(contentsOf: second), Data([4,5,6]))
let capture = try ScreenCapture(pixels: picture(), area: CGRect(x: 64, y: 48, width: 512, height: 384))
let png = try CoCoCaptureFiles.save(capture, folder: dir)
let image = try XCTUnwrap(NSImage(contentsOf: png))
XCTAssertEqual(image.size, NSSize(width: 512, height: 384))
}
func testNativeMovieCompletesMP4WithGuestOnlyCropAndStereo() async throws {
let dir = try folder(), movie = dir.appendingPathComponent("Working.mov"), final = dir.appendingPathComponent("Final.mp4")
let encoder = try CoCoVideoEncoder(workingURL: movie)
let bytes = picture()
for n in 0..<60 {
var samples = Data(count: 735 * 8)
samples.withUnsafeMutableBytes { raw in
let values = raw.bindMemory(to: Float.self)
for i in 0..<735 { values[2*i] = Float(sin(Double(n*735+i)*2 * .pi * 440 / 44100)) * 0.2; values[2*i+1] = -values[2*i] }
}
encoder.append([CoCoVideoFrame(pixels: bytes, area: CGRect(x: 64, y: 48, width: 512, height: 384), audio: samples, sampleOffset: Int64(n*735))])
try await Task.sleep(for: .milliseconds(17))
}
let working: URL = try await withCheckedThrowingContinuation { c in encoder.finish { c.resume(with: $0) } }
try await CoCoVideoEncoder.exportMP4(from: working, to: final)
let asset = AVURLAsset(url: final)
let duration = try await asset.load(.duration).seconds
XCTAssertEqual(duration, 1, accuracy: 0.03)
let video = try await asset.loadTracks(withMediaType: .video), audio = try await asset.loadTracks(withMediaType: .audio)
XCTAssertEqual(video.count, 1); XCTAssertEqual(audio.count, 1)
let dimensions = try await video[0].load(.naturalSize)
XCTAssertEqual(dimensions, CGSize(width: 1280, height: 960))
let generator = AVAssetImageGenerator(asset: asset)
let frame = try await generator.image(at: .zero).image
var rgba = Data(count: 1280 * 960 * 4)
rgba.withUnsafeMutableBytes { p in
let context = CGContext(data: p.baseAddress, width: 1280, height: 960, bitsPerComponent: 8,
bytesPerRow: 1280 * 4, space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue)!
context.draw(frame, in: CGRect(x: 0, y: 0, width: 1280, height: 960))
}
let top = (240 * 1280 + 640) * 4, bottom = (720 * 1280 + 640) * 4
XCTAssertGreaterThan(rgba[top], 200); XCTAssertLessThan(rgba[top+1], 40); XCTAssertLessThan(rgba[top+2], 40)
XCTAssertGreaterThan(rgba[bottom+2], 200); XCTAssertLessThan(rgba[bottom+1], 40); XCTAssertLessThan(rgba[bottom], 40)
// Passthrough refuses overwrite, leaving an already delivered movie intact.
let hash = try Data(contentsOf: final)
do { try await CoCoVideoEncoder.exportMP4(from: working, to: final); XCTFail("Must not overwrite") } catch { }
XCTAssertEqual(try Data(contentsOf: final), hash)
}
@MainActor func testBridgeCaptureBothProcessorsDoesNotAdvancePausedGuest() async throws {
for hd in [false, true] {
let controller = VCCMachineController()
func command(_ op: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
await withCheckedContinuation { c in op { c.resume(returning: $0) } }
}
func packets(_ finish: Bool) async -> ([VCCVideoPacket], String?) {
await withCheckedContinuation { c in controller.takeVideoCapture(finish: finish) { c.resume(returning: ($0,$1)) } }
}
_ = await command { controller.loadDiagnostic(use6309: hd, completion: $0) }
_ = await command(controller.resume)
var available = await command(controller.snapshot)
for _ in 0..<50 where available.presentedFrame == 0 {
try await Task.sleep(for: .milliseconds(10))
available = await command(controller.snapshot)
}
XCTAssertGreaterThan(available.presentedFrame, 0)
let before = await command(controller.pause)
let started = await command(controller.beginVideoCapture)
XCTAssertNil(started.errorMessage)
try await Task.sleep(for: .milliseconds(65))
let capture = await packets(true)
XCTAssertNil(capture.1); XCTAssertFalse(capture.0.isEmpty)
for p in capture.0 {
XCTAssertEqual(p.pixels.count, 640 * 480 * 4)
XCTAssertTrue(p.samples.allSatisfy { $0 == 0 })
XCTAssertGreaterThan(p.activeArea.width, 0)
}
let after = await command(controller.snapshot)
XCTAssertEqual(after.generation, before.generation)
XCTAssertEqual(after.cycles, before.cycles)
XCTAssertEqual(after.presentedFrame, before.presentedFrame)
XCTAssertEqual(after.audioStarts, before.audioStarts)
XCTAssertEqual(after.use6309, hd)
_ = await command(controller.shutdown)
}
}
@MainActor func testStopWaitsForAnInFlightDrainedPacketBeforeFinalizing() async throws {
let root = try folder(), controller = HeldPullController()
let suite = "CoCoCaptureStop-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
defaults.set(try root.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil), forKey: "capture.folder.recordings")
let model = MachineModel(diskStore: .init(url: root.appendingPathComponent("Disks.json")), controller: controller,
displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("Input.json")), restoreMediaOnLaunch: false)
func command(_ op: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async {
_ = await withCheckedContinuation { c in op { c.resume(returning: $0) } }
}
await command { controller.loadDiagnostic(use6309: false, completion: $0) }
await command(controller.resume)
// This fixture owns its guest setup. An asynchronous remembered-media
// restore must not race that load or supply the frame incidentally.
for _ in 0..<100 where model.pixels == nil {
model.poll(); try await Task.sleep(for: .milliseconds(10))
}
guard model.pixels != nil else {
await withCheckedContinuation { c in model.shutdown { c.resume() } }
XCTFail("The authored diagnostic guest did not produce its first frame")
return
}
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
capture.startRecording()
capture.startRecording() // Repeated Start while starting cannot add another cue.
for _ in 0..<100 where controller.heldReply == nil { try await Task.sleep(for: .milliseconds(5)) }
XCTAssertNotNil(controller.heldReply)
XCTAssertEqual(cues, [.recordingStarted])
let stopping = Task { await capture.stopRecording() }
try await Task.sleep(for: .milliseconds(30))
XCTAssertEqual(capture.state, .finishing)
XCTAssertEqual(controller.finalPulls, 0, "Stop must not overtake the pull that already owns drained samples")
await capture.stopRecording()
XCTAssertEqual(capture.state, .finishing, "Duplicate Stop must leave the first finalization in control")
XCTAssertEqual(controller.finalPulls, 0)
controller.releasePull()
await stopping.value
XCTAssertEqual(controller.finalPulls, 1)
XCTAssertEqual(capture.state, .idle); XCTAssertNil(capture.error)
let saved = capture.saved
XCTAssertTrue(capture.recoveries.isEmpty)
XCTAssertEqual(cues, [.recordingStarted], "Stop/finalization must not replay the start cue")
await withCheckedContinuation { c in model.shutdown { c.resume() } }
let movie = try XCTUnwrap(saved)
XCTAssertTrue(FileManager.default.fileExists(atPath: movie.path))
}
@MainActor func testFailedQuickSaveRetainsImageAndRejectsReplacementUntilExplicitDiscard() async throws {
let controller = VCCMachineController(), (root, defaults, model) = try await guest(controller: controller)
let blocked = root.appendingPathComponent("Not a folder")
let original = Data("existing user file".utf8)
try original.write(to: blocked)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
// A regular file is a deterministic inaccessible-directory fixture,
// independent of the account's administrator/write permissions.
try await capture.preferences.setFolder(blocked)
capture.captureNow()
for _ in 0..<200 where capture.saving { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertFalse(capture.saving); XCTAssertNotNil(capture.error)
XCTAssertTrue(capture.hasPendingImage); XCTAssertNil(capture.saved)
XCTAssertEqual(cues, [.screenshot])
try await capture.preferences.setFolder(root)
capture.captureNow(); capture.delay(5)
XCTAssertTrue(capture.hasPendingImage); XCTAssertNil(capture.countdown)
XCTAssertEqual(cues, [.screenshot], "A failed image cannot be silently replaced or cue again")
XCTAssertEqual(try Data(contentsOf: blocked), original)
capture.discardImage()
XCTAssertFalse(capture.hasPendingImage); XCTAssertNil(capture.error)
capture.captureNow()
for _ in 0..<200 where capture.saving { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertNotNil(capture.saved); XCTAssertFalse(capture.hasPendingImage)
XCTAssertEqual(cues, [.screenshot, .screenshot])
XCTAssertEqual(try Data(contentsOf: blocked), original)
}
@MainActor func testFastForwardStartRefusesWithoutChangingMachineOrCreatingRecovery() async throws {
let controller = VCCMachineController(), (root, defaults, model) = try await guest(controller: controller)
await withCheckedContinuation { c in
controller.configureMachine(use6309: false, ram: model.settings.ram, overclock: 1, frameInterval: 1, fastForward: true) { _ in c.resume() }
}
for _ in 0..<200 where !model.settings.fastForward { model.poll(); try await Task.sleep(for: .milliseconds(5)) }
XCTAssertTrue(model.settings.fastForward)
let before = await withCheckedContinuation { c in controller.snapshot { c.resume(returning: $0) } }
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
try await capture.preferences.setFolder(root)
capture.startRecording(); capture.startRecording()
XCTAssertEqual(capture.state, .idle)
XCTAssertTrue(capture.error?.contains("fast-forward") == true)
XCTAssertTrue(capture.recoveries.isEmpty); XCTAssertTrue(cues.isEmpty)
let after = await withCheckedContinuation { c in controller.snapshot { c.resume(returning: $0) } }
XCTAssertTrue(after.fastForward); XCTAssertEqual(after.generation, before.generation)
XCTAssertFalse(FileManager.default.fileExists(atPath: root.appendingPathComponent("CaptureRecovery.json").path))
}
@MainActor func testTenSecondCaptureExpiresWhilePausedWithoutAdvancingGuest() async throws {
let controller = VCCMachineController(), (root, defaults, model) = try await guest(controller: controller)
let before = await withCheckedContinuation { c in controller.pause { c.resume(returning: $0) } }
model.poll()
try await Task.sleep(for: .milliseconds(20))
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
try await capture.preferences.setFolder(root)
capture.preferences.setTimerSeconds(10)
capture.capture()
XCTAssertEqual(capture.countdown, 10); XCTAssertTrue(cues.isEmpty)
for _ in 0..<1_200 where capture.countdown != nil || capture.saving { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertNil(capture.countdown); XCTAssertFalse(capture.saving)
XCTAssertEqual(cues, [.screenshot]); XCTAssertNil(capture.error)
let image = try XCTUnwrap(NSImage(contentsOf: try XCTUnwrap(capture.saved)))
XCTAssertEqual(image.size, NSSize(width: model.activeVideoRect.width, height: model.activeVideoRect.height))
let after = await withCheckedContinuation { c in controller.snapshot { c.resume(returning: $0) } }
XCTAssertEqual(after.generation, before.generation)
XCTAssertEqual(after.cycles, before.cycles)
XCTAssertEqual(after.presentedFrame, before.presentedFrame)
XCTAssertEqual(after.audioStarts, before.audioStarts)
}
@MainActor func testResetsCancelScreenshotTimersButContinueTheSameRecording() async throws {
let controller = VCCMachineController(), (root, defaults, model) = try await guest(controller: controller)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
model.captures = capture
try await capture.preferences.setFolder(root)
capture.startRecording()
for _ in 0..<200 where capture.state == .starting { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .recording)
let record = try XCTUnwrap(capture.recoveries.first)
for cold in [false, true] {
capture.delay(10)
XCTAssertEqual(capture.countdown, 10)
if cold { model.reset() } else { model.softReset() }
XCTAssertNil(capture.countdown)
for _ in 0..<200 where model.busy { try await Task.sleep(for: .milliseconds(5)) }
XCTAssertFalse(model.busy)
XCTAssertEqual(capture.state, .recording)
XCTAssertEqual(capture.recoveries.map(\.id), [record.id])
try await Task.sleep(for: .milliseconds(80))
}
XCTAssertEqual(cues, [.recordingStarted], "A reset neither restarts recording nor takes a delayed screenshot")
await capture.stopRecording()
XCTAssertNil(capture.error); XCTAssertEqual(capture.state, .idle)
let asset = AVURLAsset(url: try XCTUnwrap(capture.saved))
let duration = try await asset.load(.duration).seconds
XCTAssertGreaterThan(duration, 0.12)
XCTAssertTrue(capture.recoveries.isEmpty)
}
@MainActor func testCaptureInterruptionRetainsOwnedMovieAndRecoveryAcrossRelaunch() async throws {
let controller = FailingPullController(), (root, defaults, model) = try await guest(controller: controller)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
try await capture.preferences.setFolder(root)
capture.startRecording()
for _ in 0..<200 where capture.state == .starting { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .recording)
let record = try XCTUnwrap(capture.recoveries.first)
let unrelated = record.directory.appendingPathComponent("User note.txt"), original = Data("preserve".utf8)
try original.write(to: unrelated)
try await Task.sleep(for: .milliseconds(250))
controller.failNextPull = true
for _ in 0..<300 where capture.state != .idle { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .idle); XCTAssertNil(capture.saved)
XCTAssertEqual(capture.error, "Authored capture-consumer interruption")
XCTAssertEqual(capture.recoveries.map(\.id), [record.id])
XCTAssertTrue(FileManager.default.fileExists(atPath: record.working.path))
XCTAssertGreaterThan(try Data(contentsOf: record.working).count, 0)
XCTAssertEqual(cues, [.recordingStarted])
let reopened = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
XCTAssertEqual(reopened.recoveries.map(\.id), [record.id])
let recoveredFolder = root.appendingPathComponent("Recovered", isDirectory: true)
try FileManager.default.createDirectory(at: recoveredFolder, withIntermediateDirectories: true)
try await reopened.preferences.setFolder(recoveredFolder)
reopened.recover(record)
for _ in 0..<400 where reopened.state != .idle { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertNil(reopened.error); XCTAssertTrue(reopened.recoveries.isEmpty)
let final = try XCTUnwrap(reopened.saved)
XCTAssertEqual(final.deletingLastPathComponent().standardizedFileURL, recoveredFolder.standardizedFileURL)
let duration = try await AVURLAsset(url: final).load(.duration).seconds
XCTAssertGreaterThan(duration, 0.2, "Recovery must deliver preceding recorded content")
XCTAssertEqual(try Data(contentsOf: unrelated), original, "Completion cleans only its working movie, never unexpected files")
XCTAssertFalse(FileManager.default.fileExists(atPath: record.working.path))
XCTAssertEqual(cues, [.recordingStarted], "Recovery must not emit a new recording-start cue")
}
@MainActor func testRecordingTransportSurvivesAnOccupiedMainActorOnBothProcessors() async throws {
for hd in [false, true] {
let controller = VCCMachineController(), (root, defaults, model) = try await guest(controller: controller, use6309: hd)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
capture.startRecording()
for _ in 0..<200 where capture.state == .starting { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .recording)
let before = await withCheckedContinuation { c in controller.snapshot { c.resume(returning: $0) } }
holdMainActor()
let after = await withCheckedContinuation { c in controller.snapshot { c.resume(returning: $0) } }
// Allow any delayed failure notification to run before assertions;
// merely observing the old published Recording state proves little.
try await Task.sleep(for: .milliseconds(100))
XCTAssertEqual(capture.state, .recording); XCTAssertNil(capture.error)
XCTAssertEqual(after.generation, before.generation)
XCTAssertEqual(after.audioStarts, before.audioStarts)
XCTAssertGreaterThan(after.cycles, before.cycles)
XCTAssertGreaterThan(after.presentedFrame, before.presentedFrame)
XCTAssertEqual(after.use6309, hd)
await capture.stopRecording()
XCTAssertEqual(capture.state, .idle); XCTAssertNil(capture.error)
XCTAssertTrue(capture.recoveries.isEmpty)
let asset = AVURLAsset(url: try XCTUnwrap(capture.saved))
let duration = try await asset.load(.duration).seconds
XCTAssertGreaterThan(duration, 0.75, "The movie must span the occupied UI interval")
XCTAssertEqual(cues, [.recordingStarted])
await withCheckedContinuation { c in model.shutdown { c.resume() } }
}
}
@MainActor func testCaptureFailureQuiescesAndFinalizesWhileMainActorIsOccupied() async throws {
let controller = FailingPullController(), (root, defaults, model) = try await guest(controller: controller)
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { _ in })
capture.startRecording()
for _ in 0..<200 where capture.state == .starting { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .recording)
let record = try XCTUnwrap(capture.recoveries.first)
DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + .milliseconds(200)) { controller.failNextPull = true }
holdMainActor()
XCTAssertEqual(controller.finalPulls, 1, "Failure must stop the source without waiting for the UI notification")
for _ in 0..<300 where capture.state != .idle { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .idle); XCTAssertNil(capture.saved)
XCTAssertEqual(capture.error, "Authored capture-consumer interruption")
XCTAssertEqual(capture.recoveries.map(\.id), [record.id])
let duration = try await AVURLAsset(url: record.working).load(.duration).seconds
XCTAssertGreaterThan(duration, 0.1)
XCTAssertEqual(controller.finalPulls, 1, "The later UI stop shares the same backend finalization")
}
@MainActor func testEncoderFailureQuiescesSourceBeforeItsMainActorNotification() async throws {
let controller = FailingPullController(), (root, defaults, model) = try await guest(controller: controller)
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { _ in })
capture.startRecording()
for _ in 0..<200 where capture.state == .starting { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .recording)
let record = try XCTUnwrap(capture.recoveries.first)
// A malformed authored transport frame exercises the real encoder's
// validation/failure callback; no guest memory or registers are changed.
DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + .milliseconds(200)) { controller.invalidateNextPull = true }
holdMainActor()
XCTAssertEqual(controller.finalPulls, 1)
// User Stop can arrive before the queued UI failure notification. Both
// paths must share the already-started backend finalization.
await capture.stopRecording()
XCTAssertEqual(capture.state, .idle); XCTAssertNil(capture.saved)
XCTAssertTrue(capture.error?.contains("ordering") == true)
XCTAssertEqual(capture.recoveries.map(\.id), [record.id])
XCTAssertEqual(controller.finalPulls, 1)
let duration = try await AVURLAsset(url: record.working).load(.duration).seconds
XCTAssertGreaterThan(duration, 0.1)
}
@MainActor func testImmediateFailureDoesNotLatchRecordingOrStopItsSuccessor() async throws {
let controller = FailingPullController(), (root, defaults, model) = try await guest(controller: controller)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
for _ in 0..<4 {
controller.failNextPull = true
capture.startRecording()
for _ in 0..<300 where capture.state != .idle { try await Task.sleep(for: .milliseconds(5)) }
XCTAssertEqual(capture.state, .idle, "An immediate background failure must not leave a stale Recording state")
XCTAssertEqual(capture.error, "Authored capture-consumer interruption")
}
let retained = capture.recoveries.map(\.id), oldCues = cues.count
XCTAssertEqual(retained.count, 4)
capture.startRecording()
for _ in 0..<200 where capture.state == .starting { try await Task.sleep(for: .milliseconds(10)) }
try await Task.sleep(for: .milliseconds(150))
XCTAssertEqual(capture.state, .recording); XCTAssertNil(capture.error)
XCTAssertEqual(cues.count, oldCues + 1)
await capture.stopRecording()
XCTAssertEqual(capture.state, .idle); XCTAssertNil(capture.error)
XCTAssertNotNil(capture.saved)
XCTAssertEqual(capture.recoveries.map(\.id), retained)
}
@MainActor func testCaptureStartOwnsFreshErrorStateAndBridgeRefusalNeverCuesOnBothProcessors() async throws {
for hd in [false, true] {
let controller = VCCMachineController(), (root, defaults, model) = try await guest(controller: controller, use6309: hd)
let rejected = await withCheckedContinuation { c in
controller.configureMachine(use6309: hd, ram: 99, overclock: 1, frameInterval: 1, fastForward: false) { c.resume(returning: $0) }
}
XCTAssertNotNil(rejected.errorMessage)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
capture.startRecording()
for _ in 0..<200 where capture.state == .starting { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .recording); XCTAssertNil(capture.error)
try await Task.sleep(for: .milliseconds(100))
await capture.stopRecording()
XCTAssertEqual(capture.state, .idle); XCTAssertNil(capture.error)
XCTAssertNotNil(capture.saved); XCTAssertTrue(capture.recoveries.isEmpty)
XCTAssertEqual(cues, [.recordingStarted])
// The model deliberately retains its last normal-speed snapshot;
// the owner queue independently refuses the actual fast-forward run.
_ = await withCheckedContinuation { c in
controller.configureMachine(use6309: hd, ram: model.settings.ram, overclock: 1, frameInterval: 1, fastForward: true) { c.resume(returning: $0) }
}
XCTAssertFalse(model.settings.fastForward)
capture.startRecording()
for _ in 0..<200 where capture.state != .idle { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertEqual(capture.state, .idle)
XCTAssertTrue(capture.error?.contains("fast-forward") == true)
XCTAssertEqual(cues, [.recordingStarted], "A refused bridge start must not emit a success cue")
_ = await withCheckedContinuation { c in
controller.configureMachine(use6309: hd, ram: model.settings.ram, overclock: 1, frameInterval: 1, fastForward: false) { c.resume(returning: $0) }
}
let probe = await withCheckedContinuation { c in controller.beginVideoCapture(replyQueue: .global(qos: .userInitiated)) { c.resume(returning: $0) } }
XCTAssertNil(probe.errorMessage, "The rejected start must not leave an unowned capture producer active")
let stopped: String? = await withCheckedContinuation { c in controller.takeVideoCapture(finish: true, replyQueue: .global(qos: .userInitiated)) { _, error in c.resume(returning: error) } }
XCTAssertNil(stopped)
await withCheckedContinuation { c in model.shutdown { c.resume() } }
}
}
@MainActor func testNewerRecoveryManifestIsPreservedAndBlocksAnotherWriter() async throws {
let controller = VCCMachineController(), (root, defaults, model) = try await guest(controller: controller)
let manifest = root.appendingPathComponent("CaptureRecovery.json")
let original = Data(#"{"version":2,"recordings":[],"futureMetadata":"preserve exactly"}"#.utf8)
try original.write(to: manifest)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
try await capture.preferences.setFolder(root)
XCTAssertNotNil(capture.error)
capture.startRecording()
XCTAssertEqual(capture.state, .idle); XCTAssertTrue(capture.recoveries.isEmpty)
XCTAssertTrue(capture.error?.contains("preserved recording recovery") == true)
XCTAssertTrue(cues.isEmpty)
XCTAssertEqual(try Data(contentsOf: manifest), original)
let contents = try FileManager.default.contentsOfDirectory(at: root, includingPropertiesForKeys: nil)
XCTAssertFalse(contents.contains { $0.lastPathComponent.hasPrefix(".vcc-recording-") })
}
@MainActor func testSharedDestinationDefaultsTimerAndAudioPersistWithoutMovingFiles() async throws {
let root = try folder(), suite = "CoCoCapturePreferences-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let first = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root)
XCTAssertEqual(first.destination, .desktop)
XCTAssertEqual(first.folder, root)
XCTAssertEqual(first.screenshots, first.recordings)
XCTAssertEqual(first.timerSeconds, 0); XCTAssertTrue(first.includeVideoAudio)
XCTAssertNil(defaults.data(forKey: "capture.folder.shared"), "A logical default must not create a security bookmark before the user chooses a folder")
let custom = root.appendingPathComponent("My Captures", isDirectory: true)
try FileManager.default.createDirectory(at: custom, withIntermediateDirectories: true)
let original = custom.appendingPathComponent("Existing.txt")
try Data("keep me".utf8).write(to: original)
try await first.setFolder(custom); first.setTimerSeconds(10); first.includeVideoAudio = false
let chosenBookmark = try XCTUnwrap(defaults.data(forKey: "capture.folder.shared"))
let reopened = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root)
XCTAssertEqual(reopened.folder.standardizedFileURL, custom.standardizedFileURL)
XCTAssertEqual(reopened.screenshots, reopened.recordings)
XCTAssertEqual(reopened.destination, .other)
XCTAssertEqual(reopened.timerSeconds, 10); XCTAssertFalse(reopened.includeVideoAudio)
XCTAssertEqual(defaults.data(forKey: "capture.folder.shared"), chosenBookmark, "Reopening preferences preserves an explicit selected-folder grant")
reopened.setTimerSeconds(3)
XCTAssertEqual(reopened.timerSeconds, 10, "Only None, 5 and 10 are valid timer choices")
reopened.setDestination(.documents)
XCTAssertEqual(reopened.folder, root.appendingPathComponent("Documents", isDirectory: true))
XCTAssertEqual(try Data(contentsOf: original), Data("keep me".utf8))
reopened.setDestination(.desktop)
XCTAssertEqual(reopened.folder, root)
defaults.set(999, forKey: "capture.timer.seconds")
XCTAssertEqual(CoCoCapturePreferences(defaults: defaults, fallbackRoot: root).timerSeconds, 0)
}
@MainActor func testLegacyCaptureFoldersMigrateWithExplicitScreenshotChoiceFirst() throws {
let root = try folder(), screenshot = root.appendingPathComponent("Pictures"), video = root.appendingPathComponent("Movies")
for path in [screenshot, video] { try FileManager.default.createDirectory(at: path, withIntermediateDirectories: true) }
for screenshotChosen in [false, true] {
let suite = "CoCoCaptureMigration-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let videoBookmark = try video.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil)
defaults.set(videoBookmark, forKey: "capture.folder.recordings")
if screenshotChosen {
defaults.set(try screenshot.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil), forKey: "capture.folder.screenshots")
}
let migrated = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root)
let expected = screenshotChosen ? screenshot : video
XCTAssertEqual(migrated.folder.standardizedFileURL, expected.standardizedFileURL)
XCTAssertEqual(migrated.screenshots, migrated.recordings)
XCTAssertEqual(defaults.data(forKey: "capture.folder.recordings"), videoBookmark)
XCTAssertEqual(defaults.data(forKey: "capture.folder.shared"),
defaults.data(forKey: screenshotChosen ? "capture.folder.screenshots" : "capture.folder.recordings"),
"Migration reuses the existing security bookmark bytes instead of requesting a new grant")
let reopened = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root)
XCTAssertEqual(reopened.folder.standardizedFileURL, expected.standardizedFileURL)
}
}
@MainActor func testBuiltInDestinationsPersistWithoutBookmarkOrDirectoryWorkAndOverrideOther() async throws {
let root = try folder(), custom = root.appendingPathComponent("Chosen Other", isDirectory: true)
try FileManager.default.createDirectory(at: custom, withIntermediateDirectories: true)
let suite = "CoCoLogicalDestination-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let preferences = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root)
try await preferences.setFolder(custom)
let bookmark = try XCTUnwrap(defaults.data(forKey: "capture.folder.shared"))
let documents = root.appendingPathComponent("Documents", isDirectory: true)
XCTAssertFalse(FileManager.default.fileExists(atPath: documents.path))
preferences.setDestination(.documents)
XCTAssertEqual(preferences.destination, .documents); XCTAssertEqual(preferences.folder, documents)
XCTAssertEqual(defaults.string(forKey: "capture.destination"), "documents")
XCTAssertEqual(defaults.data(forKey: "capture.folder.shared"), bookmark, "Keep the previous explicit grant for in-flight writers")
XCTAssertFalse(FileManager.default.fileExists(atPath: documents.path), "Selecting a logical folder must not create it on the UI thread")
let reopened = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root, makeBookmark: { _ in
XCTFail("Logical destination restore must not make a bookmark"); return Data()
})
XCTAssertEqual(reopened.destination, .documents); XCTAssertEqual(reopened.folder, documents)
reopened.setDestination(.desktop)
XCTAssertEqual(CoCoCapturePreferences(defaults: defaults, fallbackRoot: root).folder, root)
XCTAssertEqual(defaults.string(forKey: "capture.destination"), "desktop")
XCTAssertEqual(defaults.data(forKey: "capture.folder.shared"), bookmark)
XCTAssertFalse(FileManager.default.fileExists(atPath: documents.path))
}
@MainActor func testLateOtherGrantCannotReplaceNewerBuiltInOrOtherChoice() async throws {
for newerOther in [false, true] {
let root = try folder(), first = root.appendingPathComponent("First"), second = root.appendingPathComponent("Second")
for url in [first, second] { try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true) }
let suite = "CoCoDestinationOrder-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let gate = BookmarkGate(blocked: first)
let preferences = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root, makeBookmark: { try gate.prepare($0) })
let stale = Task { try await preferences.setFolder(first) }
for _ in 0..<200 where !gate.started { try await Task.sleep(for: .milliseconds(5)) }
XCTAssertTrue(gate.started); XCTAssertTrue(preferences.preparingDestination)
if newerOther { try await preferences.setFolder(second) } else { preferences.setDestination(.documents) }
gate.unblock()
do { try await stale.value; XCTFail("A superseded grant must not become the selected folder") }
catch is CancellationError { }
let expected = newerOther ? second : root.appendingPathComponent("Documents", isDirectory: true)
XCTAssertEqual(preferences.folder, expected); XCTAssertFalse(preferences.preparingDestination)
XCTAssertEqual(CoCoCapturePreferences(defaults: defaults, fallbackRoot: root).folder.standardizedFileURL, expected.standardizedFileURL)
}
}
@MainActor func testLateOtherFailureIsCancellationAndLegacyFallbackStillMigrates() async throws {
let root = try folder(), first = root.appendingPathComponent("First"), legacy = root.appendingPathComponent("Legacy")
for url in [first, legacy] { try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true) }
let suite = "CoCoDestinationFailure-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let legacyBookmark = try legacy.bookmarkData(options: .withSecurityScope, includingResourceValuesForKeys: nil, relativeTo: nil)
defaults.set(Data("invalid shared bookmark".utf8), forKey: "capture.folder.shared")
defaults.set(legacyBookmark, forKey: "capture.folder.recordings")
let gate = BookmarkGate(blocked: first, fails: true)
let preferences = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root, makeBookmark: { try gate.prepare($0) })
XCTAssertEqual(preferences.folder.standardizedFileURL, legacy.standardizedFileURL)
XCTAssertEqual(defaults.data(forKey: "capture.folder.shared"), legacyBookmark)
let stale = Task { try await preferences.setFolder(first) }
for _ in 0..<200 where !gate.started { try await Task.sleep(for: .milliseconds(5)) }
XCTAssertTrue(gate.started)
preferences.setDestination(.desktop); gate.unblock()
do { try await stale.value; XCTFail("A superseded failed grant must be ignored") }
catch is CancellationError { }
XCTAssertEqual(preferences.folder, root); XCTAssertFalse(preferences.preparingDestination)
XCTAssertEqual(defaults.data(forKey: "capture.folder.shared"), legacyBookmark)
XCTAssertEqual(CoCoCapturePreferences(defaults: defaults, fallbackRoot: root).destination, .desktop)
let later = root.appendingPathComponent("Later Other")
try FileManager.default.createDirectory(at: later, withIntermediateDirectories: true)
let nextGate = BookmarkGate(blocked: first, fails: true)
let next = CoCoCapturePreferences(defaults: defaults, fallbackRoot: root, makeBookmark: { try nextGate.prepare($0) })
let superseded = Task { try await next.setFolder(first) }
for _ in 0..<200 where !nextGate.started { try await Task.sleep(for: .milliseconds(5)) }
XCTAssertTrue(nextGate.started)
try await next.setFolder(later); nextGate.unblock()
do { try await superseded.value; XCTFail("An old failure must not replace a newer accepted Other folder") }
catch is CancellationError { }
XCTAssertEqual(next.folder, later); XCTAssertFalse(next.preparingDestination)
XCTAssertEqual(CoCoCapturePreferences(defaults: defaults, fallbackRoot: root).folder.standardizedFileURL, later.standardizedFileURL)
}
@MainActor func testTimerSelectionCancellationAndRealCaptureEmitOnlyActualCaptureCues() async throws {
let root = try folder(), suite = "CoCoCaptureCues-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let controller = VCCMachineController()
let model = MachineModel(diskStore: .init(url: root.appendingPathComponent("Disks.json")), controller: controller,
displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("Input.json")), restoreMediaOnLaunch: false)
var cues: [CoCoCaptureFeedback.Cue] = []
let capture = CoCoCaptureCoordinator(machine: model, controller: controller, defaults: defaults, directory: root, feedback: { cues.append($0) })
try await capture.preferences.setFolder(root)
capture.captureNow(); capture.startRecording()
XCTAssertTrue(cues.isEmpty, "A missing framebuffer cannot emit a success cue")
XCTAssertEqual(capture.state, .idle)
await withCheckedContinuation { c in controller.loadDiagnostic(use6309: false) { _ in c.resume() } }
await withCheckedContinuation { c in controller.resume { _ in c.resume() } }
for _ in 0..<100 where model.pixels == nil { model.poll(); try await Task.sleep(for: .milliseconds(10)) }
guard model.pixels != nil else {
await withCheckedContinuation { c in model.shutdown { c.resume() } }
return XCTFail("The diagnostic guest did not provide a picture")
}
capture.preferences.setTimerSeconds(10); capture.preferences.includeVideoAudio = false
XCTAssertNil(capture.countdown); XCTAssertNil(capture.saved); XCTAssertTrue(cues.isEmpty)
capture.capture()
XCTAssertEqual(capture.countdown, 10); XCTAssertTrue(cues.isEmpty)
capture.cancelCountdown()
try await Task.sleep(for: .milliseconds(50))
XCTAssertNil(capture.countdown); XCTAssertNil(capture.saved); XCTAssertTrue(cues.isEmpty)
capture.preferences.setTimerSeconds(0); capture.capture(); capture.capture()
XCTAssertEqual(cues, [.screenshot], "A duplicate click during saving must not capture or cue twice")
for _ in 0..<100 where capture.saving { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertNotNil(capture.saved); XCTAssertFalse(capture.hasPendingImage)
capture.preferences.setTimerSeconds(5); capture.capture()
XCTAssertEqual(capture.countdown, 5); XCTAssertEqual(cues.count, 1)
for _ in 0..<650 where capture.countdown != nil || capture.saving { try await Task.sleep(for: .milliseconds(10)) }
XCTAssertNil(capture.countdown); XCTAssertFalse(capture.saving)
XCTAssertEqual(cues, [.screenshot, .screenshot], "Only timer expiry emits the delayed capture cue")
let pngs = try FileManager.default.contentsOfDirectory(at: root, includingPropertiesForKeys: nil).filter { $0.pathExtension == "png" }
XCTAssertEqual(pngs.count, 2)
await withCheckedContinuation { c in model.shutdown { c.resume() } }
}
func testSilentVideoDecodesToSilenceWithUnchangedPictureAndTimeline() async throws {
let root = try folder(), movie = root.appendingPathComponent("Silent.mov"), final = root.appendingPathComponent("Silent.mp4")
let encoder = try CoCoVideoEncoder(workingURL: movie), bytes = picture()
var source = Data(count: 735 * 8)
source.withUnsafeMutableBytes { raw in
let floats = raw.bindMemory(to: Float.self)
for i in 0..<735 { floats[2*i] = 0.25; floats[2*i+1] = -0.25 }
}
let live = CoCoCaptureCoordinator.videoFrame(pixels: bytes, area: CGRect(x: 64, y: 48, width: 512, height: 384), audio: source, sampleOffset: 735, includeAudio: true)
XCTAssertEqual(live.audio, source)
for n in 0..<60 {
let silent = CoCoCaptureCoordinator.videoFrame(pixels: bytes, area: live.area, audio: source, sampleOffset: Int64(n*735), includeAudio: false)
XCTAssertEqual(silent.pixels, bytes); XCTAssertEqual(silent.area, live.area)
XCTAssertEqual(silent.sampleOffset, Int64(n*735)); XCTAssertEqual(silent.audio.count, source.count)
XCTAssertTrue(silent.audio.allSatisfy { $0 == 0 })
encoder.append([silent]); try await Task.sleep(for: .milliseconds(17))
}
let working: URL = try await withCheckedThrowingContinuation { c in encoder.finish { c.resume(with: $0) } }
try await CoCoVideoEncoder.exportMP4(from: working, to: final)
let asset = AVURLAsset(url: final)
let duration = try await asset.load(.duration).seconds
XCTAssertEqual(duration, 1, accuracy: 0.03)
let audio = try await asset.loadTracks(withMediaType: .audio), video = try await asset.loadTracks(withMediaType: .video)
XCTAssertEqual(video.count, 1)
let track = try XCTUnwrap(audio.first)
let reader = try AVAssetReader(asset: asset)
let output = AVAssetReaderTrackOutput(track: track, outputSettings: [AVFormatIDKey: kAudioFormatLinearPCM,
AVLinearPCMIsFloatKey: true, AVLinearPCMBitDepthKey: 32, AVLinearPCMIsNonInterleaved: false])
reader.add(output); XCTAssertTrue(reader.startReading())
var peak: Float = 0, count = 0
while let sample = output.copyNextSampleBuffer() {
let buffer = try XCTUnwrap(CMSampleBufferGetDataBuffer(sample))
var data = Data(count: CMBlockBufferGetDataLength(buffer))
let result = data.withUnsafeMutableBytes { CMBlockBufferCopyDataBytes(buffer, atOffset: 0, dataLength: $0.count, destination: $0.baseAddress!) }
XCTAssertEqual(result, noErr)
data.withUnsafeBytes { raw in
for value in raw.bindMemory(to: Float.self) { peak = max(peak, abs(value)); count += 1 }
}
}
XCTAssertEqual(reader.status, .completed); XCTAssertGreaterThan(count, 0)
XCTAssertLessThan(peak, 0.00001, "The delivered MP4 must decode to silence, despite nonzero source PCM")
}
}