// 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() } } } }