Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+472
View File
@@ -0,0 +1,472 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import SwiftUI
import AppKit
import MetalKit
final class InterfaceTests: XCTestCase {
@MainActor func testGuideHistoryIsIndependentForEverySystemProfileAndPersists() throws {
let suite = "VCCGuideTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let first = PresentationSettings(defaults: defaults)
for profile in SystemProfile.allCases { XCTAssertTrue(first.shouldIntroduce(profile)) }
first.didShowGuide(.diskBasic)
let next = PresentationSettings(defaults: defaults)
XCTAssertFalse(next.shouldIntroduce(.diskBasic))
for profile in [SystemProfile.hardDriveBasic, .cocoSDC, .nitros9] {
XCTAssertTrue(next.shouldIntroduce(profile))
next.didShowGuide(profile)
}
next.mode = .display; next.expanded = true
let reopened = PresentationSettings(defaults: defaults)
for profile in SystemProfile.allCases { XCTAssertFalse(reopened.shouldIntroduce(profile)) }
}
@MainActor func testWindowPlacementAndPresentationSurviveNewStore() throws {
let suite = "VCCWindowTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let first = PresentationSettings(defaults: defaults)
XCTAssertEqual(first.mode, .system)
XCTAssertTrue(first.showClickableAreas)
first.mode = .display; first.expanded = true
first.showConnections = true; first.showClickableAreas = false
let frame = CGRect(x: -1300, y: 120, width: 1100, height: 800)
first.windows.save(frame, id: "machine")
let second = PresentationSettings(defaults: defaults)
XCTAssertEqual(second.mode, .display); XCTAssertTrue(second.expanded)
XCTAssertTrue(second.showConnections); XCTAssertFalse(second.showClickableAreas)
XCTAssertEqual(second.windows.saved("machine"), frame)
XCTAssertNil(second.windows.saved("cassette"))
defaults.set([0.0, 0, -900, 600], forKey: "interface.window.cassette")
XCTAssertNil(second.windows.saved("cassette"))
second.windows.save(CGRect(x: 0, y: 0, width: CGFloat.infinity, height: 600), id: "machine")
XCTAssertEqual(second.windows.saved("machine"), frame)
}
@MainActor func testWindowPlacementRecoversMissingAndSmallerScreens() {
let main = CGRect(x: 0, y: 30, width: 1440, height: 845)
let external = CGRect(x: -1920, y: -100, width: 1920, height: 1080)
let saved = CGRect(x: -1800, y: 100, width: 1200, height: 800)
XCTAssertEqual(WindowPlacements.reachable(saved, screens: [main, external]), saved)
let recovered = WindowPlacements.reachable(saved, screens: [main])
XCTAssertTrue(main.contains(recovered)); XCTAssertEqual(recovered.size, saved.size)
let huge = CGRect(x: 1200, y: 800, width: 3000, height: 2000)
XCTAssertEqual(WindowPlacements.reachable(huge, screens: [main]), main)
let tiny = CGRect(x: 0, y: 0, width: 800, height: 600)
let minimum = CGSize(width: 940, height: 640)
let clipped = WindowPlacements.reachable(saved, screens: [tiny], minimum: minimum)
XCTAssertEqual(clipped.size, minimum)
XCTAssertEqual(clipped.minX, tiny.minX); XCTAssertEqual(clipped.maxY, tiny.maxY)
}
@MainActor func testNativeWindowObserverRemembersCloseAndExcludesFullScreenGeometry() throws {
let suite = "VCCWindowTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let store = WindowPlacements(defaults: defaults)
let window = NSWindow(contentRect: CGRect(x: 100, y: 150, width: 600, height: 500),
styleMask: [.titled, .resizable], backing: .buffered, defer: false)
let observer = RememberWindowPlacement.Observer(id: "cassette", placements: store)
observer.attach(window)
window.setFrame(CGRect(x: 120, y: 160, width: 720, height: 570), display: false)
observer.save()
let original = window.frame
NotificationCenter.default.post(name: NSWindow.willEnterFullScreenNotification, object: window)
window.setFrame(CGRect(x: 0, y: 0, width: 1400, height: 900), display: false)
observer.save()
XCTAssertEqual(store.saved("cassette"), original)
window.setFrame(original, display: false)
NotificationCenter.default.post(name: NSWindow.didExitFullScreenNotification, object: window)
observer.detach()
window.setFrame(CGRect(x: 0, y: 0, width: 500, height: 400), display: false)
let next = RememberWindowPlacement.Observer(id: "cassette", placements: WindowPlacements(defaults: defaults))
next.attach(window)
XCTAssertEqual(window.frame.size, original.size)
XCTAssertEqual(window.frame, store.saved("cassette"))
next.detach()
}
func testPrinterTextPreservesRawAndNormalizesBASICLineEndings() {
let raw = Data([0xC8, 0xC9, 0x8D, 0x8A, 0x8D, 0x21, 0x0A])
XCTAssertEqual(PrinterText.decode(raw, sevenBit: true), "HI\n\n!\n")
XCTAssertEqual(PrinterText.export(raw, raw: true, sevenBit: true), raw)
XCTAssertEqual(PrinterText.export(raw, raw: false, sevenBit: true), Data("HI\n\n!\n".utf8))
XCTAssertEqual(PrinterText.decode(Data([9, 27, 12, 0, 255]), sevenBit: false), "\t⟨ESC⟩\n⟨FF⟩\n⟨00⟩⟨FF⟩")
XCTAssertEqual(PrinterText.decode(Data([0xC8, 0xC9]), sevenBit: false), "⟨C8⟩⟨C9⟩")
}
func testActivityUsesEventsNotDirtyMotorOrSelection() {
var a = ActivityTracker()
XCTAssertEqual(a.update(reads:0,writes:0,mounted:false,running:true,now:0), .empty)
XCTAssertEqual(a.update(reads:0,writes:0,mounted:true,running:true,now:1), .loaded)
XCTAssertEqual(a.update(reads:1,writes:0,mounted:true,running:true,now:2), .read)
XCTAssertEqual(a.update(reads:1,writes:1,mounted:true,running:true,now:2.01), .write)
XCTAssertEqual(a.update(reads:2,writes:1,mounted:true,running:true,now:2.02), .write)
XCTAssertEqual(a.update(reads:2,writes:1,mounted:true,running:true,now:2.3), .loaded)
XCTAssertEqual(a.update(reads:3,writes:2,mounted:true,running:false,now:3), .loaded)
XCTAssertEqual(a.update(reads:3,writes:2,mounted:true,running:true,now:3.01), .loaded)
XCTAssertEqual(a.update(reads:0,writes:0,mounted:true,running:true,now:4), .loaded)
}
func testExpansionGeometryIsAbsoluteAndRestoresAfterResize() {
for size in [CGSize(width:900,height:450),CGSize(width:1440,height:900),CGSize(width:980,height:720)] {
let original = SystemGeometry(size:size,system:true,expanded:false)
for _ in 0..<100 {
let expanded = SystemGeometry(size:size,system:true,expanded:true)
XCTAssertGreaterThan(expanded.screen.width,original.screen.width)
XCTAssertEqual(expanded.screen.width/expanded.screen.height,202/151.1,accuracy:0.0001)
let returned = SystemGeometry(size:size,system:true,expanded:false)
XCTAssertEqual(returned.monitor,original.monitor);XCTAssertEqual(returned.screen,original.screen)
XCTAssertEqual(returned.scene,expanded.scene)
}
}
}
@MainActor func testHiddenTowerCentersVisibleHardwareWithoutChangingScale() {
let art = HardwareArtwork.shared
for mpi in ["on", "off"] {
var state = HardwareState().values
state["mpi"] = mpi; state["slot4"] = "sdc"
let bounds = art.layoutBounds(state)
XCTAssertLessThan(bounds.maxX, SystemGeometry.canvas.maxX)
XCTAssertTrue(bounds.contains(SystemTarget.library.rect))
for size in [CGSize(width: 900, height: 450), CGSize(width: 1440, height: 900), CGSize(width: 980, height: 720)] {
let full = SystemGeometry(size: size, system: true, expanded: false)
let centered = SystemGeometry(size: size, system: true, expanded: false, contentBounds: bounds)
XCTAssertEqual(centered.rect(bounds).midX, size.width / 2, accuracy: 0.0001)
XCTAssertEqual(centered.scene.size, full.scene.size)
XCTAssertEqual(centered.screen.size, full.screen.size)
XCTAssertEqual(centered.screen.minY, full.screen.minY)
let shift = centered.screen.minX - full.screen.minX
for target in [SystemTarget.printer, .cassette, .keyboard, .joystick, .slot(4), .library, .manuals] {
XCTAssertEqual(centered.rect(target.rect).minX - full.rect(target.rect).minX, shift, accuracy: 0.0001)
}
let expanded = SystemGeometry(size: size, system: true, expanded: true, contentBounds: bounds)
XCTAssertEqual(expanded.monitor.midX, size.width / 2, accuracy: 0.0001)
XCTAssertEqual(expanded.scene, centered.scene)
XCTAssertEqual(SystemGeometry(size: size, system: true, expanded: false, contentBounds: bounds).screen, centered.screen)
}
for activity in ["empty", "loaded", "read", "write"] {
state["sdcActivity"] = activity
XCTAssertEqual(art.layoutBounds(state), bounds, "Activity must not shift the scene")
}
state["floppyCase"] = "on"
XCTAssertEqual(art.layoutBounds(state), SystemGeometry.canvas)
state["floppyCase"] = "off"; state["hardCase"] = "on"
XCTAssertEqual(art.layoutBounds(state), SystemGeometry.canvas)
}
}
@MainActor func testLibraryShelfIsBundledAndClearsHardware() throws {
let image = try XCTUnwrap(HardwareArtwork.shared.image("software-library-shelf.png"))
let bitmap = try XCTUnwrap(NSBitmapImageRep(data: try XCTUnwrap(image.tiffRepresentation)))
XCTAssertTrue(bitmap.hasAlpha)
XCTAssertEqual(image.size.width / image.size.height, 2, accuracy: 0.01)
XCTAssertTrue(SystemGeometry.libraryArtwork.contains(SystemTarget.library.rect))
XCTAssertFalse(SystemTarget.library.rect.intersects(SystemGeometry.monitor))
// The top of the drive-tower roof is at y=140, above its clickable faces.
XCTAssertLessThan(SystemTarget.library.rect.maxY, 140)
XCTAssertTrue(SystemGeometry.canvas.contains(SystemGeometry.libraryArtwork))
}
@MainActor func testManualHelpArtworkFitsItsTargetBelowTheMultiPak() throws {
let art = try XCTUnwrap(HardwareArtwork.shared.image("manual-help.pdf"))
let target = SystemTarget.manuals.rect
// AppKit rounds the PDF dimensions to whole points.
XCTAssertEqual(art.size.height, art.size.width * target.height / target.width, accuracy: 1)
XCTAssertTrue(SystemGeometry.canvas.contains(target))
XCTAssertGreaterThan(target.minY, SystemTarget.selector.rect.maxY)
}
func testSystemHotspotsCoverDeviceFacesWithoutIntersecting() {
let targets: [SystemTarget] = [.computer, .keyboard, .printer, .cassette, .joystick, .monitor, .selector, .library, .manuals]
+ (1...4).map { .slot($0) } + (0..<4).map { .floppy($0) } + (0..<2).map { .hard($0) }
// Points on the widened panels and numbered MPI shelves, from the artwork.
let points: [(SystemTarget, CGPoint)] = [
(.computer, CGPoint(x: 60, y: 290)), (.computer, CGPoint(x: 325, y: 290)),
(.keyboard, CGPoint(x: 60, y: 335)), (.cassette, CGPoint(x: -105, y: 330)),
(.library, CGPoint(x: 570, y: 85)),
(.printer, CGPoint(x: -100, y: 180)), (.printer, CGPoint(x: 35, y: 115)),
(.joystick, CGPoint(x: -95, y: 440)), (.selector, CGPoint(x: 550, y: 380)),
(.slot(4), CGPoint(x: 495, y: 268)), (.slot(3), CGPoint(x: 505, y: 285)),
(.slot(2), CGPoint(x: 515, y: 302)), (.slot(1), CGPoint(x: 525, y: 321))]
for (target, point) in points { XCTAssertTrue(target.rect.contains(point), target.title) }
for size in [CGSize(width: 860, height: 450), CGSize(width: 1060, height: 604), CGSize(width: 1800, height: 1000)] {
let geometry = SystemGeometry(size: size, system: true, expanded: false)
for (i, target) in targets.enumerated() {
let frame = geometry.rect(target.rect)
XCTAssertFalse(frame.intersects(geometry.screen), "Controls must not intercept CoCo input")
for other in targets.dropFirst(i + 1) {
XCTAssertFalse(frame.intersects(geometry.rect(other.rect)), "\(target.title) overlaps \(other.title)")
}
}
}
// The six black faces share these horizontal artwork edges. Neither
// the clickable rectangle nor its inset stroke may cross either edge.
for target in (0..<4).map({ SystemTarget.floppy($0) }) + (0..<2).map({ SystemTarget.hard($0) }) {
let face = target.rect
XCTAssertGreaterThan(face.minX, 649.35728)
XCTAssertLessThan(face.maxX, 823.49272)
XCTAssertEqual(face.minX - 649.35728, 823.49272 - face.maxX, accuracy: 0.00001)
}
}
func testMonitorBezelFollowsExpansionWithoutCoveringTheLiveScreen() {
for size in [CGSize(width: 860, height: 450), CGSize(width: 1060, height: 604), CGSize(width: 1800, height: 1000)] {
let normal = SystemGeometry(size: size, system: true, expanded: false)
XCTAssertEqual(normal.rect(SystemTarget.monitor.rect).minX,
normal.monitorRect(SystemTarget.monitor.rect).minX, accuracy: 0.00001)
for expanded in [false, true] {
let geometry = SystemGeometry(size: size, system: true, expanded: expanded)
let bezel = geometry.monitorRect(SystemTarget.monitor.rect)
XCTAssertTrue(geometry.monitor.contains(bezel))
XCTAssertGreaterThan(bezel.minY, geometry.screen.maxY)
XCTAssertGreaterThan(bezel.width, geometry.screen.width)
XCTAssertEqual((bezel.midX - geometry.monitor.minX) / geometry.monitor.width,
(SystemTarget.monitor.rect.midX - SystemGeometry.monitor.minX) / SystemGeometry.monitor.width,
accuracy: 0.00001)
}
}
}
@MainActor private func snapshot(_ c: VCCMachineController) async -> VCCMachineSnapshot {
await withCheckedContinuation { done in c.snapshot { done.resume(returning:$0) } }
}
@MainActor private func settled(_ model: MachineModel) async throws {
for _ in 0..<1000 {
if !model.busy && !model.diskSaving { return }
try await Task.sleep(nanoseconds:10_000_000)
}
XCTFail("Machine command did not settle")
}
@MainActor func testAcceptedArtworkMatrixAndNoInventedMedia() async throws {
let c = VCCMachineController()
for cpu in [false,true] {
for ram in 0..<4 {
for startup in 1...4 {
let request = VCCMachineProfile();request.use6309=cpu;request.ram=ram;request.physicalSlot=startup;request.multiPak=true
request.kinds=[0,1,3,0,2];request.cartridgeROMs=[Data(),Data([0x12]),Data(),Data(),Data()]
request.cartridgeNames=["","Authored ROM","","",""];request.diskROM=Data(repeating:0,count:8192)
let (_,s): (Bool,VCCMachineSnapshot) = await withCheckedContinuation { done in c.applyProfile(request) { done.resume(returning:($0,$1)) } }
let hardware = HardwareState(snapshot:s,activities:Array(repeating:.empty,count:7))
XCTAssertEqual(hardware.values["cpu"],cpu ? "6309" : "6809")
XCTAssertEqual(hardware.values["ram"],HardwareState.ramKeys[ram])
XCTAssertEqual(hardware.values["startup"],String(startup));XCTAssertFalse(hardware.custom)
XCTAssertEqual(hardware.values["slot1"],"rom");XCTAssertEqual(hardware.values["slot2"],"hard")
XCTAssertEqual(hardware.values["slot4"],"floppy");XCTAssertEqual(hardware.values["slot3"],"empty")
XCTAssertEqual(hardware.values["tape"],"empty")
XCTAssertEqual(hardware.values["printerPower"],"off")
XCTAssertEqual(hardware.values["printerPaper"],"blank")
for n in 0..<4 { XCTAssertEqual(hardware.values["fd\(n)"],"empty") }
}
}
}
// All twelve two-controller placements, with no invented combined slot.
for floppy in 1...4 {
for hard in 1...4 where hard != floppy {
let request=VCCMachineProfile();request.multiPak=true;request.diskROM=Data(repeating:0,count:8192)
var kinds=[NSNumber](repeating:0,count:5);kinds[floppy]=2;kinds[hard]=3;request.kinds=kinds
let (_,s): (Bool,VCCMachineSnapshot) = await withCheckedContinuation { done in c.applyProfile(request) { done.resume(returning:($0,$1)) } }
let state=HardwareState(snapshot:s,activities:Array(repeating:.empty,count:7))
XCTAssertEqual(state.values["slot\(floppy)"],"floppy");XCTAssertEqual(state.values["slot\(hard)"],"hard")
XCTAssertEqual(state.values.filter { $0.key.hasPrefix("slot") && $0.value != "empty" }.count,2)
}
}
for kind in [1,2,3] {
let request=VCCMachineProfile();request.kinds=[NSNumber(value:kind),0,0,0,0]
request.diskROM=Data(repeating:0,count:8192)
request.cartridgeROMs=[Data([0x12]),Data(),Data(),Data(),Data()]
let (_,s): (Bool,VCCMachineSnapshot) = await withCheckedContinuation { done in c.applyProfile(request) { done.resume(returning:($0,$1)) } }
XCTAssertTrue(HardwareState(snapshot:s,activities:Array(repeating:.empty,count:7)).custom)
}
await withCheckedContinuation { done in c.shutdown { _ in done.resume() } }
}
@MainActor func testSDCSlotArtworkAndOcclusionUseActualTopology() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let c=VCCMachineController()
for slot in 1...4 {
let request=VCCMachineProfile();request.multiPak=true;request.physicalSlot=slot
var kinds=[NSNumber](repeating:0,count:5);kinds[slot]=7;request.kinds=kinds
var roms=[Data](repeating:Data(),count:5);roms[slot]=Data(repeating:0x12,count:8192);request.cartridgeROMs=roms
var folders=[String](repeating:"",count:5);folders[slot]=root.path;request.sdcFolders=folders
let (ok,s): (Bool,VCCMachineSnapshot) = await withCheckedContinuation { done in c.applyProfile(request) { done.resume(returning:($0,$1)) } }
XCTAssertTrue(ok)
let hardware=HardwareState(snapshot:s,activities:Array(repeating:.empty,count:7),sdcActivity:.read)
XCTAssertFalse(hardware.custom);XCTAssertEqual(hardware.values["slot\(slot)"],"sdc")
XCTAssertEqual(hardware.values["sdcActivity"],"read")
XCTAssertEqual(hardware.values["floppyCase"],"off");XCTAssertEqual(hardware.values["hardCase"],"off")
let art=HardwareArtwork.shared
XCTAssertNotNil(art.cartridgeHitRect(slot:slot,values:hardware.values))
XCTAssertFalse(art.layers.contains { $0.when["slot\(slot)"] == "sdc" && $0.when["mpi"] == nil },"SDC must never acquire a disk-stack cable")
if slot > 1 {
var crowded=hardware.values;crowded["slot1"]="orchestra"
if let hit=art.cartridgeHitRect(slot:slot,values:crowded), let front=art.cartridgeHitRect(slot:1,values:crowded) {
XCTAssertFalse(hit.intersects(front),"Covered cartridge pixels must not steal a nearer cartridge's clicks")
}
}
}
await withCheckedContinuation { done in c.shutdown { _ in done.resume() } }
}
@MainActor func testAllRuntimeAlternativesHaveNativeVectorAssetsAndCache() throws {
let art=HardwareArtwork.shared
XCTAssertGreaterThan(art.layers.count,90)
for layer in art.layers { XCTAssertNotNil(art.image(layer.file),layer.file) }
for state in ["on", "off"] { XCTAssertTrue(art.layers.contains { $0.when["printerPower"] == state }) }
XCTAssertTrue(art.layers.contains { $0.when["printerPaper"] == "printed" })
XCTAssertNotNil(art.image("printer.pdf"))
for cpu in ["6809","6309"] { XCTAssertTrue(art.layers.contains { $0.when["cpu"] == cpu }) }
for ram in HardwareState.ramKeys { XCTAssertTrue(art.layers.contains { $0.when["ram"] == ram }) }
for slot in 1...4 {
for kind in ["rom","floppy","hard","orchestra","speech","sdc"] {
XCTAssertTrue(art.layers.contains { $0.when["slot\(slot)"] == kind })
}
XCTAssertTrue(art.layers.contains { $0.when["startup"] == String(slot) })
}
for device in ["fd0","fd1","fd2","fd3","hd0","hd1","tape"] {
for state in ["empty","loaded","read","write"] {
XCTAssertTrue(art.layers.contains { $0.when[device+"Activity"] == state },"\(device) \(state)")
}
}
let view=LayeredHardwareView(part:"scene");view.frame=CGRect(x:0,y:0,width:960,height:457)
var state=HardwareState().values;state["mpi"]="on";state["floppy"]="on";state["floppyCase"]="on"
view.apply(state);view.layoutSubtreeIfNeeded();let before=view.rasterizations
XCTAssertGreaterThan(before,0)
for _ in 0..<60 { view.apply(state);view.layoutSubtreeIfNeeded() }
XCTAssertEqual(before,view.rasterizations)
state["fd0Activity"]="read";view.apply(state);view.layoutSubtreeIfNeeded()
XCTAssertLessThanOrEqual(view.rasterizations-before,1,"An indicator change must not rasterize the whole scene")
state["slot4"]="sdc";state["sdcActivity"]="loaded";view.apply(state);view.layoutSubtreeIfNeeded()
let beforeSDC=view.rasterizations
state["sdcActivity"]="read";view.apply(state);view.layoutSubtreeIfNeeded()
XCTAssertLessThanOrEqual(view.rasterizations-beforeSDC,1,"SDC transfers only redraw the lens")
XCTAssertNotNil(art.cartridgeHitRect(slot:4,values:state))
for slot in 1...4 {
for value in ["empty","loaded","read","write"] {
XCTAssertTrue(art.layers.contains { $0.when["slot\(slot)"] == "sdc" && $0.when["sdcActivity"] == value })
}
}
let beforePrinter = view.rasterizations
state["printerPower"]="on";state["printerPaper"]="printed"
view.apply(state);view.layoutSubtreeIfNeeded()
XCTAssertLessThanOrEqual(view.rasterizations-beforePrinter,2,"Printer changes only expose the LED and paper layers")
let afterPrinter = view.rasterizations
for _ in 0..<60 { view.apply(state);view.layoutSubtreeIfNeeded() }
XCTAssertEqual(afterPrinter,view.rasterizations)
}
@MainActor func testExplicitMetalRedrawAfterPixelChangesResizeAndReattachment() async throws {
let device = try XCTUnwrap(MTLCreateSystemDefaultDevice())
let display = KeyboardDisplay(frame: CGRect(x: 0, y: 0, width: 700, height: 500), device: device)
display.configure()
// No AppKit invalidation or Metal display-link timer may drive this test.
XCTAssertTrue(display.isPaused)
XCTAssertFalse(display.enableSetNeedsDisplay)
let window = NSWindow(contentRect: display.frame, styleMask: [.titled, .resizable], backing: .buffered, defer: false)
window.contentView = display
window.makeKeyAndOrderFront(nil)
defer { window.orderOut(nil); window.contentView = nil }
let words = [UInt32](repeating: 0x0033cc22, count: 640 * 480)
display.pixels = words.withUnsafeBytes { Data($0) }
display.activeVideoRect = CGRect(x: 64, y: 48, width: 512, height: 384)
func waitForFrame(after count: UInt64) async throws {
for _ in 0..<100 {
if display.submittedFrames > count { return }
try await Task.sleep(nanoseconds: 10_000_000)
}
XCTFail("An explicit redraw must submit fresh pixels without AppKit invalidation")
}
let initial = display.submittedFrames
display.requestFrame()
try await waitForFrame(after: initial)
let changed = display.submittedFrames
display.pixels = Data(repeating: 0xff, count: 640 * 480 * 4)
for _ in 0..<10 { display.requestFrame() }
try await waitForFrame(after: changed)
for size in [CGSize(width: 1200, height: 620), CGSize(width: 700, height: 800)] {
let before = display.submittedFrames
window.setContentSize(size)
display.layoutSubtreeIfNeeded()
try await waitForFrame(after: before)
XCTAssertEqual(display.drawableSize.width, display.bounds.width * window.backingScaleFactor, accuracy: 1)
XCTAssertEqual(display.drawableSize.height, display.bounds.height * window.backingScaleFactor, accuracy: 1)
}
window.orderOut(nil)
window.contentView = nil
display.requestFrame()
try await Task.sleep(nanoseconds: 30_000_000)
let hidden = display.submittedFrames
window.contentView = display
window.makeKeyAndOrderFront(nil)
try await waitForFrame(after: hidden)
}
@MainActor func testNativePresentationKeepsOneMetalViewAndSession() async throws {
let directory=FileManager.default.temporaryDirectory.appendingPathComponent("VCCInterface-"+UUID().uuidString)
try FileManager.default.createDirectory(at:directory,withIntermediateDirectories:true)
let suite="VCCInterface-"+UUID().uuidString,defaults=UserDefaults(suiteName:suite)!
defer { defaults.removePersistentDomain(forName:suite);try? FileManager.default.removeItem(at:directory) }
let c=VCCMachineController()
let model=MachineModel(diskStore:.init(url:directory.appendingPathComponent("disks.json")),controller:c,displayDefaults:defaults,inputStore:.init(url:directory.appendingPathComponent("input.json")))
try await settled(model)
model.loadDiagnostic();try await settled(model)
let presentation=PresentationSettings(defaults:defaults)
let host=NSHostingView(rootView:MachineView(machine:model,presentation:presentation,showManualHome: {}))
let window=NSWindow(contentRect:CGRect(x:80,y:100,width:1100,height:820),styleMask:[.titled,.closable,.resizable],backing:.buffered,defer:false)
window.title="VCC Interface Validation";window.contentView=host;window.makeKeyAndOrderFront(nil)
defer { window.orderOut(nil);window.contentView=nil }
func displays(_ view:NSView)->[KeyboardDisplay] { (view as? KeyboardDisplay).map { [$0] } ?? view.subviews.flatMap(displays) }
try await Task.sleep(nanoseconds:200_000_000)
let first=try XCTUnwrap(displays(host).first)
model.resume();try await settled(model)
let before=await snapshot(c)
model.setMultiPak(true);try await settled(model)
model.resume();try await settled(model)
presentation.mode = .system;presentation.expanded=false
try await Task.sleep(nanoseconds:200_000_000)
presentation.expanded=true
try await Task.sleep(nanoseconds:200_000_000)
window.makeFirstResponder(first)
var keyboardStates: [UInt64] = []
let originalKeyChanged = first.keyChanged
first.keyChanged = { keyboardStates.append($0); originalKeyChanged?($0) }
first.keyDown(with: try XCTUnwrap(NSEvent.keyEvent(with: .keyDown, location: .zero,
modifierFlags: [], timestamp: 0, windowNumber: window.windowNumber, context: nil,
characters: "a", charactersIgnoringModifiers: "a", isARepeat: false, keyCode: 0)))
XCTAssertTrue(keyboardStates.contains { $0 != 0 })
let transitionBaseline=await snapshot(c)
for i in 0..<12 {
model.displayPreferences.style = DisplayStyle(scaling: DisplayScaling.allCases[i % 3], scanlines: i % 2 == 0)
presentation.mode = i % 3 == 0 ? .display : .system
presentation.expanded = i % 2 == 0
window.setContentSize(CGSize(width:i % 2 == 0 ? 1000 : 1200,height:i % 2 == 0 ? 700 : 860))
try await Task.sleep(nanoseconds:40_000_000)
host.layoutSubtreeIfNeeded()
XCTAssertEqual(displays(host).count,1)
XCTAssertEqual(first.drawableSize.width, first.bounds.width * (window.backingScaleFactor), accuracy: 1)
XCTAssertEqual(first.drawableSize.height, first.bounds.height * (window.backingScaleFactor), accuracy: 1)
XCTAssertTrue(displays(host).first === first,"Changing views must retain the same Metal/input owner")
}
XCTAssertEqual(keyboardStates.last, 0, "Presentation changes release held keys")
XCTAssertTrue(window.firstResponder === first, "Presentation changes restore CoCo input focus")
let after=await snapshot(c)
XCTAssertEqual(after.generation,transitionBaseline.generation);XCTAssertEqual(after.state,.running)
XCTAssertGreaterThan(after.frames,before.frames);XCTAssertEqual(after.audioStarts,transitionBaseline.audioStarts)
model.pause();try await settled(model)
presentation.mode = .system;presentation.expanded=false
try await Task.sleep(nanoseconds:100_000_000)
let paused=await snapshot(c);presentation.expanded=true
try await Task.sleep(nanoseconds:100_000_000)
model.displayPreferences.style = DisplayStyle(scaling: .smooth, scanlines: true)
_ = try ScreenCapture(pixels: model.pixels, area: model.activeVideoRect).png()
for scaling in DisplayScaling.allCases {
model.displayPreferences.style.scaling = scaling
for size in [CGSize(width: 1200, height: 620), CGSize(width: 940, height: 850)] {
window.setContentSize(size)
try await Task.sleep(nanoseconds: 60_000_000)
host.layoutSubtreeIfNeeded()
XCTAssertEqual(first.drawableSize.width, first.bounds.width * window.backingScaleFactor, accuracy: 1)
XCTAssertEqual(first.drawableSize.height, first.bounds.height * window.backingScaleFactor, accuracy: 1)
}
}
let stillPaused = await snapshot(c)
XCTAssertEqual(stillPaused.frames,paused.frames)
XCTAssertEqual(stillPaused.generation,paused.generation)
XCTAssertEqual(stillPaused.audioStarts,paused.audioStarts)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}