473 lines
31 KiB
Swift
473 lines
31 KiB
Swift
// 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() } }
|
|
}
|
|
}
|