Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,257 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import XCTest
|
||||
|
||||
final class ProfileTests: XCTestCase {
|
||||
func testProfileSchemaBoundsAndLocalReferences() throws {
|
||||
let profile = ConfigurationProfile(name: "Games")
|
||||
XCTAssertNoThrow(try profile.validate())
|
||||
var invalid = profile; invalid.version = 2; XCTAssertThrowsError(try invalid.validate())
|
||||
invalid = profile; invalid.systemROM = URL(string: "https://example.com/rom"); XCTAssertThrowsError(try invalid.validate())
|
||||
invalid = profile; invalid.machine.ram = 99; XCTAssertThrowsError(try invalid.validate())
|
||||
invalid = profile; invalid.volume = .nan; XCTAssertThrowsError(try invalid.validate())
|
||||
invalid = profile; invalid.name = "\n"; XCTAssertThrowsError(try invalid.validate())
|
||||
}
|
||||
}
|
||||
|
||||
extension ProfileTests {
|
||||
private struct Fixture {
|
||||
let folder: URL, suite: String, defaults: UserDefaults
|
||||
var diskStore: DiskAssignmentStore { .init(url: folder.appendingPathComponent("disk-settings.json")) }
|
||||
var inputStore: InputSettingsStore { .init(url: folder.appendingPathComponent("input-settings.json")) }
|
||||
var store: ProfileStore { .init(directory: folder.appendingPathComponent("Profiles")) }
|
||||
init() throws {
|
||||
folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
suite = "VCCProfiles-" + UUID().uuidString; defaults = UserDefaults(suiteName: suite)!
|
||||
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
|
||||
}
|
||||
func remove() { defaults.removePersistentDomain(forName: suite); try? FileManager.default.removeItem(at: folder) }
|
||||
func profile() throws -> ConfigurationProfile {
|
||||
var p = ConfigurationProfile(name: "CoCo é / Games")
|
||||
var rom = Data(repeating: 0x12, count: 32768)
|
||||
rom[0] = 0x20; rom[1] = 0xfe; rom[32766] = 0x80; rom[32767] = 0
|
||||
p.systemROM = folder.appendingPathComponent("system.rom"); try rom.write(to: p.systemROM!)
|
||||
p.machine = .init(use6309: true, ram: 3, overclock: 3, frameInterval: 4, fastForward: true)
|
||||
p.videoOutput = 2; p.sound = false; p.volume = 0.25
|
||||
p.media.rom = folder.appendingPathComponent("disk.rom"); try Data(repeating: 0, count: 8192).write(to: p.media.rom!)
|
||||
let floppy = folder.appendingPathComponent("disk é.dsk"); try Data(repeating: 0x5a, count: 161280).write(to: floppy)
|
||||
p.media.drives[0] = .init(url: floppy, writeProtected: true, temporary: true)
|
||||
let hard = folder.appendingPathComponent("hard.vhd"); try Data(repeating: 0x31, count: 4096).write(to: hard)
|
||||
var h = HardDiskAssignments(); h.clockEnabled = false; h.clockReadOnly = false
|
||||
h.drives[1] = .init(url: hard, writeProtected: true, temporary: true); p.media.hardDisks = h
|
||||
let cart = folder.appendingPathComponent("game.ccc"); try Data(repeating: 0x42, count: 8192).write(to: cart)
|
||||
var c = CartridgeAssignments(); c.multiPak = true; c.mpiConfigured = true; c.physicalSlot = 2
|
||||
c.slots[0] = .init(kind: .rom, url: cart); c.slots[1] = .init(kind: .rom, url: cart)
|
||||
c.slots[2].kind = .floppy; c.slots[3].kind = .hardDisk; p.media.cartridges = c
|
||||
p.cassette = folder.appendingPathComponent("tape.cas"); try Data([0x55,0x55,0x3c]).write(to: p.cassette!)
|
||||
p.fastCassette = true; p.input.keyboard = .coco
|
||||
p.input.right.source = .controller; p.input.right.device = "remembered disconnected controller"
|
||||
p.input.left.source = .keyboard
|
||||
return p
|
||||
}
|
||||
}
|
||||
@MainActor private func step(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
|
||||
await withCheckedContinuation { c in operation { c.resume(returning: $0) } }
|
||||
}
|
||||
@MainActor private func apply(_ request: VCCMachineProfile, to controller: VCCMachineController) async -> (Bool, VCCMachineSnapshot) {
|
||||
await withCheckedContinuation { c in controller.applyProfile(request) { c.resume(returning: ($0, $1)) } }
|
||||
}
|
||||
@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)
|
||||
}
|
||||
throw ProfileFailure.message("Profile test timed out")
|
||||
}
|
||||
@MainActor private func withModel(_ f: Fixture, _ body: (MachineModel, VCCMachineController) async throws -> Void) async throws {
|
||||
let c = VCCMachineController()
|
||||
let model = MachineModel(diskStore: f.diskStore, controller: c, displayDefaults: f.defaults, inputStore: f.inputStore)
|
||||
do { try await settled(model); try await body(model, c) }
|
||||
catch { await withCheckedContinuation { done in model.shutdown { done.resume() } }; throw error }
|
||||
await withCheckedContinuation { done in model.shutdown { done.resume() } }
|
||||
}
|
||||
func testProfileLibraryRoundTripRenameDeleteAndBoundedImport() throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var profile = try f.profile(); try f.store.save(profile)
|
||||
XCTAssertEqual(try f.store.load(), [profile])
|
||||
XCTAssertEqual(try ProfileStore.read(f.store.file(profile.id)), profile)
|
||||
let bytes = try Data(contentsOf: f.store.file(profile.id))
|
||||
XCTAssertLessThan(bytes.count, 10000, "Profile contains references, not disk/ROM payloads")
|
||||
var duplicate = profile; duplicate.id = UUID(); XCTAssertThrowsError(try f.store.save(duplicate))
|
||||
profile.name = "Renamed"; try f.store.save(profile); XCTAssertEqual(try f.store.load().first?.name, "Renamed")
|
||||
let exported = f.folder.appendingPathComponent("share.vccprofile"); try ProfileStore.write(profile, to: exported)
|
||||
var imported = try ProfileStore.read(exported); imported.id = UUID(); imported.name = "Imported"; try f.store.save(imported)
|
||||
try f.store.delete(profile.id); XCTAssertEqual(try f.store.load(), [imported])
|
||||
XCTAssertTrue(FileManager.default.fileExists(atPath: profile.systemROM!.path))
|
||||
let bad = f.folder.appendingPathComponent("large.vccprofile"); try Data(repeating: 0, count: 65537).write(to: bad)
|
||||
XCTAssertThrowsError(try ProfileStore.read(bad))
|
||||
var future = imported; future.version = 99
|
||||
try JSONEncoder().encode(future).write(to: bad); XCTAssertThrowsError(try ProfileStore.read(bad))
|
||||
}
|
||||
func testMissingFilesCanBeRemappedWithoutEmbeddingMedia() throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var p = try f.profile()
|
||||
let original = p.systemROM!; let moved = f.folder.appendingPathComponent("Moved system.rom")
|
||||
try FileManager.default.moveItem(at: original, to: moved)
|
||||
XCTAssertThrowsError(try PreparedProfile.read(p)) { XCTAssertTrue($0.localizedDescription.contains("System ROM")) }
|
||||
p.replace(.systemROM, with: moved)
|
||||
XCTAssertEqual(try PreparedProfile.read(p).systemROM?.count, 32768)
|
||||
try Data().write(to: p.media.drives[0]!.url)
|
||||
XCTAssertThrowsError(try PreparedProfile.read(p))
|
||||
}
|
||||
@MainActor func testProfileLoadsAllSettingsAndRecapturesAcrossRelaunch() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var profile = try f.profile()
|
||||
for cpu in [false, true] {
|
||||
profile.machine.use6309 = cpu; try f.store.save(profile)
|
||||
try await withModel(f) { model, controller in
|
||||
await model.loadProfile(profile)
|
||||
XCTAssertNil(model.profileError); XCTAssertEqual(model.state, .paused); XCTAssertEqual(model.frames, 0)
|
||||
XCTAssertEqual(model.systemROMURL, profile.systemROM); XCTAssertEqual(model.settings, profile.machine)
|
||||
XCTAssertEqual(model.videoOutput.rawValue, 2); XCTAssertFalse(model.audioEnabled); XCTAssertEqual(model.volume, 0.25)
|
||||
XCTAssertTrue(model.diskConnected); XCTAssertTrue(model.hardDiskConnected); XCTAssertEqual(model.romSlot, 2)
|
||||
XCTAssertTrue(model.disks[0].mounted); XCTAssertTrue(model.disks[0].writeProtected); XCTAssertTrue(model.diskTemporary[0])
|
||||
XCTAssertTrue(model.hardDisks[1].mounted); XCTAssertTrue(model.hardTemporary[1])
|
||||
XCTAssertTrue(model.tapeMounted); XCTAssertTrue(model.tapeFast); XCTAssertEqual(model.tapeMode, 0)
|
||||
XCTAssertEqual(model.input.settings, profile.input)
|
||||
let recaptured = try await model.captureProfile(name: profile.name, replacing: profile.id)
|
||||
XCTAssertEqual(recaptured, profile)
|
||||
let snapshot = await step(controller.snapshot); XCTAssertEqual(snapshot.programCounter, 0x8000)
|
||||
XCTAssertFalse(snapshot.hardClockEnabled); XCTAssertFalse(snapshot.hardClockReadOnly)
|
||||
model.resume(); try await settled(model); try await Task.sleep(nanoseconds: 40_000_000)
|
||||
let running = await step(controller.snapshot); XCTAssertGreaterThan(running.frames, 0)
|
||||
}
|
||||
}
|
||||
let remembered = try f.diskStore.load()
|
||||
XCTAssertEqual(remembered, profile.media); XCTAssertEqual(try f.inputStore.load(), profile.input)
|
||||
XCTAssertEqual(MachineSettings.remembered(in: f.defaults), profile.machine)
|
||||
XCTAssertEqual(try f.store.load(), [profile])
|
||||
}
|
||||
@MainActor func testProfileModifiedTracksConfigurationNotPresentationOrTransport() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let profile = try f.profile()
|
||||
try await withModel(f) { model, controller in
|
||||
await model.loadProfile(profile); XCTAssertNil(model.profileError)
|
||||
XCTAssertFalse(model.profileModified)
|
||||
let presentation = PresentationSettings(defaults: f.defaults)
|
||||
presentation.mode = .system; presentation.expanded = true
|
||||
model.tapeAction(1); try await settled(model)
|
||||
XCTAssertFalse(model.profileModified, "Playing tape and changing views do not modify a setup")
|
||||
model.volume = 0.7; model.setAudio(model.audioEnabled); try await settled(model)
|
||||
XCTAssertTrue(model.profileModified)
|
||||
model.volume = profile.volume; model.setAudio(model.audioEnabled); try await settled(model)
|
||||
XCTAssertFalse(model.profileModified)
|
||||
model.createDisk(1); try await settled(model)
|
||||
XCTAssertTrue(model.profileModified, "New unbacked media must be visible as a setup change")
|
||||
_ = await step { controller.ejectDisk(inDrive: 1, discard: true, completion: $0) }
|
||||
}
|
||||
}
|
||||
@MainActor func testMalformedMediaRejectsWholeProfileWithoutChangingMachine() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let profile = try f.profile()
|
||||
try await withModel(f) { model, controller in
|
||||
await model.loadProfile(profile); XCTAssertNil(model.profileError)
|
||||
let before = await step(controller.snapshot)
|
||||
let assignments = try Data(contentsOf: f.diskStore.url)
|
||||
var bad = profile; bad.machine.ram = 0; bad.name = "Rejected"
|
||||
bad.media.drives[0]?.url = f.folder.appendingPathComponent("bad.dsk")
|
||||
try Data([1,2,3]).write(to: bad.media.drives[0]!.url)
|
||||
await model.loadProfile(bad)
|
||||
XCTAssertNotNil(model.profileError); XCTAssertEqual(model.profileName, profile.name)
|
||||
XCTAssertEqual(model.settings, profile.machine); XCTAssertEqual(model.systemROMURL, profile.systemROM)
|
||||
let after = await step(controller.snapshot)
|
||||
XCTAssertEqual(after.generation, before.generation); XCTAssertTrue(after.disks[0].mounted)
|
||||
XCTAssertEqual(try Data(contentsOf: f.diskStore.url), assignments)
|
||||
XCTAssertEqual(MachineSettings.remembered(in: f.defaults), profile.machine)
|
||||
}
|
||||
}
|
||||
@MainActor func testDirtyDisksAndRecordingBlockProfileSwitchAndSaveRequiresPaths() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let profile = try f.profile()
|
||||
try await withModel(f) { model, controller in
|
||||
await model.loadProfile(profile)
|
||||
model.createDisk(1); try await settled(model)
|
||||
let before = await step(controller.snapshot)
|
||||
await model.loadProfile(ConfigurationProfile(name: "Empty"))
|
||||
XCTAssertNotNil(model.profileError); XCTAssertTrue(model.disks[1].dirty)
|
||||
let after = await step(controller.snapshot); XCTAssertEqual(after.generation, before.generation)
|
||||
do { _ = try await model.captureProfile(name: "Unsaved"); XCTFail("New disk has no backing path") } catch { }
|
||||
_ = await step { controller.ejectDisk(inDrive: 1, discard: true, completion: $0) }
|
||||
_ = await step { controller.tapeAction(5, completion: $0) }
|
||||
await model.loadProfile(ConfigurationProfile(name: "Empty"))
|
||||
XCTAssertNotNil(model.profileError); XCTAssertEqual(model.tapeMode, 2)
|
||||
XCTAssertEqual(model.profileName, profile.name)
|
||||
}
|
||||
}
|
||||
@MainActor func testBridgeRejectsInvalidSettingsAndPreservesDirtyMedia() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let controller = VCCMachineController()
|
||||
let request = try PreparedProfile.read(f.profile()).request()
|
||||
var (applied, snapshot) = await apply(request, to: controller)
|
||||
XCTAssertTrue(applied); XCTAssertNil(snapshot.errorMessage)
|
||||
let generation = snapshot.generation
|
||||
request.ram = 4
|
||||
(applied, snapshot) = await apply(request, to: controller)
|
||||
XCTAssertFalse(applied); XCTAssertNotNil(snapshot.errorMessage); XCTAssertEqual(snapshot.generation, generation)
|
||||
request.ram = 1
|
||||
_ = await step { controller.createDisk(inDrive: 1, completion: $0) }
|
||||
(applied, snapshot) = await apply(request, to: controller)
|
||||
XCTAssertFalse(applied); XCTAssertTrue(snapshot.disks[1].dirty); XCTAssertEqual(snapshot.generation, generation)
|
||||
_ = await step(controller.shutdown)
|
||||
}
|
||||
}
|
||||
|
||||
extension ProfileTests {
|
||||
@MainActor func testLoadingEmptySetupEjectsOldMediaWithoutChangingFiles() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let profile = try f.profile()
|
||||
let originals = try profile.references.map { try Data(contentsOf: $0.url) }
|
||||
try await withModel(f) { model, controller in
|
||||
await model.loadProfile(profile); XCTAssertNil(model.profileError)
|
||||
let empty = ConfigurationProfile(name: "Bare CoCo")
|
||||
await model.loadProfile(empty); XCTAssertNil(model.profileError)
|
||||
XCTAssertEqual(model.state, .empty); XCTAssertNil(model.systemROMURL); XCTAssertEqual(model.profileName, empty.name)
|
||||
XCTAssertFalse(model.diskEnabled); XCTAssertFalse(model.tapeMounted)
|
||||
XCTAssertTrue(model.disks.allSatisfy { !$0.mounted }); XCTAssertTrue(model.hardDisks.allSatisfy { !$0.mounted })
|
||||
XCTAssertTrue(model.cartridgeNames.allSatisfy { $0.isEmpty }); XCTAssertNil(model.pixels)
|
||||
XCTAssertEqual(model.settings, MachineSettings()); XCTAssertFalse(model.diskConnected); XCTAssertFalse(model.hardDiskConnected)
|
||||
XCTAssertEqual(try profile.references.map { try Data(contentsOf: $0.url) }, originals)
|
||||
}
|
||||
}
|
||||
// A real guest sector write verifies the profile path drains automatic saves,
|
||||
// detects external edits, and never silently discards temporary changes.
|
||||
@MainActor func testProfileSwitchFlushesAutomaticWritesAndBlocksSaveConflicts() async throws {
|
||||
for mode in 0..<3 { // automatic save, external edit conflict, temporary disk
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var profile = try f.profile()
|
||||
var layout = CartridgeAssignments(); layout.slots[0].kind = .floppy
|
||||
profile.media.cartridges = layout
|
||||
profile.media.drives[0]?.writeProtected = false; profile.media.drives[0]?.temporary = mode == 2
|
||||
profile.machine.fastForward = false; profile.machine.overclock = 1
|
||||
let program: [UInt8] = [0x86,0x29,0xb7,0xff,0x40,0x86,1,0xb7,0xff,0x4a,
|
||||
0x86,0xa0,0xb7,0xff,0x48,0x8e,1,0,0x86,0x6b,
|
||||
0xb7,0xff,0x4b,0x30,0x1f,0x26,0xf9,0xb7,0xff,0x4b,0x20,0xfe]
|
||||
var rom = Data(repeating: 0, count: 32768); rom.replaceSubrange(0..<program.count, with: program); rom[32766] = 0x80
|
||||
try rom.write(to: profile.systemROM!)
|
||||
try await withModel(f) { model, controller in
|
||||
await model.loadProfile(profile); XCTAssertNil(model.profileError)
|
||||
let file = profile.media.drives[0]!.url
|
||||
if mode == 1 { try Data(repeating: 0x11, count: 161280).write(to: file) }
|
||||
_ = await step(controller.resume)
|
||||
var snapshot = await step(controller.snapshot)
|
||||
for _ in 0..<100 where !snapshot.disks[0].dirty {
|
||||
try await Task.sleep(nanoseconds: 1_000_000)
|
||||
snapshot = await step(controller.snapshot)
|
||||
}
|
||||
XCTAssertTrue(snapshot.disks[0].dirty)
|
||||
await model.loadProfile(ConfigurationProfile(name: "Next"))
|
||||
let bytes = try Data(contentsOf: file)
|
||||
if mode == 0 {
|
||||
XCTAssertNil(model.profileError); XCTAssertEqual(model.profileName, "Next"); XCTAssertEqual(bytes.prefix(256), Data(repeating: 0x6b, count: 256))
|
||||
} else {
|
||||
XCTAssertNotNil(model.profileError); XCTAssertEqual(model.profileName, profile.name)
|
||||
XCTAssertTrue(model.disks[0].dirty); XCTAssertEqual(model.state, .paused)
|
||||
XCTAssertEqual(bytes, Data(repeating: mode == 1 ? 0x11 : 0x5a, count: 161280))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user