Sync source edition with VCC Plus 3.7.0 build 63
This commit is contained in:
1 parent
c652a5276d
commit
b2ecec4d87
86 files changed
+10519
-472
No files matched your search
@@ -0,0 +1,779 @@
|
||||
// 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")
|
||||
}
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user