Files
VCCPlusOSS/platforms/macos/Tests/MachineSettingsTests.swift

181 lines
11 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import Combine
final class MachineSettingsTests: XCTestCase {
@MainActor private func step(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
await withCheckedContinuation { done in operation { done.resume(returning: $0) } }
}
@MainActor private func settled(_ model: MachineModel) async throws {
for _ in 0..<1000 {
if !model.busy { return }; try await Task.sleep(nanoseconds: 10_000_000)
}
throw NSError(domain: "MachineSettingsTimeout", code: 1)
}
func testInvalidPreferencesFallBackToSafeDefaults() throws {
let suite = "VCCMachineTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
XCTAssertEqual(MachineSettings.remembered(in: defaults), MachineSettings())
for data in [Data("broken".utf8), Data("{}".utf8), try JSONEncoder().encode(MachineSettings(ram: 4)),
try JSONEncoder().encode(MachineSettings(overclock: 0)), try JSONEncoder().encode(MachineSettings(frameInterval: 7))] {
defaults.set(data, forKey: MachineSettings.preferenceKey)
XCTAssertEqual(MachineSettings.remembered(in: defaults), MachineSettings())
}
}
@MainActor func testSettingsPersistAcrossModelRelaunchAndReset() async throws {
let suite = "VCCMachineTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let chosen = MachineSettings(use6309: true, ram: 3, overclock: 3, frameInterval: 4, fastForward: true)
for launch in 0..<2 {
let controller = VCCMachineController()
let model = MachineModel(diskStore: .init(url: folder.appendingPathComponent("disks.json")),
controller: controller, displayDefaults: defaults)
do {
try await settled(model)
XCTAssertEqual(model.settings, launch == 0 ? MachineSettings() : chosen)
model.loadDiagnostic(); try await settled(model)
model.applyMachineSettings(chosen); try await settled(model)
XCTAssertNil(model.error); XCTAssertEqual(model.settings, chosen); XCTAssertEqual(model.state, .paused)
model.reset(); try await settled(model)
XCTAssertEqual(model.settings, chosen); XCTAssertEqual(MachineSettings.remembered(in: defaults), chosen)
_ = await step { controller.tapeAction(5, completion: $0) }
var blocked = chosen; blocked.ram = 0
model.applyMachineSettings(blocked); try await settled(model)
XCTAssertNotNil(model.error); XCTAssertEqual(model.settings, chosen)
XCTAssertEqual(MachineSettings.remembered(in: defaults), chosen, "Rejected hardware changes must not persist")
_ = await step { controller.tapeAction(0, completion: $0) }
let before = await step(controller.snapshot)
model.applyMachineSettings(MachineSettings(ram: 99)); try await settled(model)
let after = await step(controller.snapshot)
XCTAssertEqual(after.generation, before.generation); XCTAssertEqual(model.settings, chosen)
} catch {
await withCheckedContinuation { done in model.shutdown { done.resume() } }; throw error
}
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
@MainActor func testFastForwardAndLiveSettingsPreserveMachineAndSoundChoice() async throws {
let controller = VCCMachineController()
_ = await step { controller.loadDiagnostic(use6309: true, completion: $0) }
var s = await step { controller.setAudioEnabled(true, volume: 0, completion: $0) }
let generation = s.generation
s = await step { controller.configureMachine(use6309: true, ram: 1, overclock: 2, frameInterval: 6, fastForward: true, completion: $0) }
XCTAssertNil(s.errorMessage); XCTAssertEqual(s.generation, generation); XCTAssertEqual(s.state, .paused)
XCTAssertTrue(s.audioEnabled); XCTAssertTrue(s.fastForward)
_ = await step(controller.resume)
try await Task.sleep(nanoseconds: 200_000_000)
s = await step(controller.pause)
XCTAssertNil(s.errorMessage); XCTAssertGreaterThan(s.frames, 12); XCTAssertEqual(s.audioStarts, 0)
XCTAssertLessThanOrEqual(s.presentedFrame, s.frames); XCTAssertLessThan(s.frames - s.presentedFrame, 6)
let frames = s.frames
try await Task.sleep(nanoseconds: 30_000_000)
s = await step(controller.snapshot); XCTAssertEqual(s.frames, frames)
s = await step { controller.configureMachine(use6309: true, ram: 1, overclock: 1, frameInterval: 1, fastForward: false, completion: $0) }
XCTAssertEqual(s.frames, frames); XCTAssertEqual(s.generation, generation); XCTAssertTrue(s.audioEnabled)
_ = await step(controller.resume)
// The first Core Audio graph in a fresh test process can take longer
// than 300 ms to deliver its first callback. Wait for the behavior we
// assert, with a bounded deadline, rather than test launch order.
for _ in 0..<100 {
try await Task.sleep(nanoseconds: 30_000_000)
s = await step(controller.snapshot)
if s.audioConsumed > 0 || s.errorMessage != nil { break }
}
s = await step(controller.pause)
XCTAssertNil(s.errorMessage); XCTAssertGreaterThan(s.audioStarts, 0); XCTAssertGreaterThan(s.audioConsumed, 0)
XCTAssertEqual(s.audioUnderruns, 0); XCTAssertEqual(s.audioOverruns, 0)
let starts = s.audioStarts
s = await step { controller.configureMachine(use6309: true, ram: -1, overclock: 1, frameInterval: 1, fastForward: true, completion: $0) }
XCTAssertNotNil(s.errorMessage); XCTAssertFalse(s.fastForward); XCTAssertEqual(s.generation, generation)
XCTAssertEqual(s.audioStarts, starts)
_ = await step(controller.shutdown)
}
@MainActor func testRecordingBlocksHardwareChangeAndRetainsTape() async {
let controller = VCCMachineController()
_ = await step(controller.loadDiagnostic)
_ = await step { controller.tapeAction(5, completion: $0) }
let before = await step(controller.snapshot)
var s = await step { controller.configureMachine(use6309: true, ram: 0, overclock: 1, frameInterval: 1, fastForward: false, completion: $0) }
XCTAssertNotNil(s.errorMessage); XCTAssertEqual(s.generation, before.generation); XCTAssertEqual(s.tapeMode, 2)
_ = await step { controller.tapeAction(0, completion: $0) }
s = await step { controller.configureMachine(use6309: true, ram: 0, overclock: 1, frameInterval: 1, fastForward: false, completion: $0) }
XCTAssertNil(s.errorMessage); XCTAssertTrue(s.use6309); XCTAssertEqual(s.ramConfiguration, 0)
XCTAssertTrue(s.tapeMounted); XCTAssertEqual(s.state, .paused)
_ = await step(controller.shutdown)
}
@MainActor func testMenuIgnoresFramePollingButTracksCommandChanges() async throws {
let suite = "VCCMenuTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let model = MachineModel(diskStore: .init(url: folder.appendingPathComponent("disks.json")), displayDefaults: defaults)
let menu = model.menuState
var updates = 0
let observation = menu.objectWillChange.sink { updates += 1 }
defer { observation.cancel() }
do {
try await settled(model)
XCTAssertFalse(menu.values.canQuickLoad)
model.loadDiagnostic(); try await settled(model)
XCTAssertTrue(menu.values.canQuickLoad); XCTAssertEqual(menu.values.state, .paused)
model.resume(); try await settled(model)
XCTAssertEqual(menu.values.state, .running)
updates = 0
let frames = model.frames
// Exercise the real bridge/model path, including repeated assignments
// of identical state/settings plus changing pixels and frame counters.
for _ in 0..<12 {
model.poll(); try await Task.sleep(nanoseconds: 30_000_000)
}
XCTAssertGreaterThan(model.frames, frames)
XCTAssertEqual(updates, 0, "Frame and status polling must not rebuild native menus")
model.startPaste(try CocoPaste(String(repeating: "A", count: 100), mode: .text))
try await settled(model)
XCTAssertTrue(menu.values.pasting); XCTAssertFalse(menu.values.canPaste)
updates = 0
let remaining = model.pasteRemaining
for _ in 0..<12 { model.poll(); try await Task.sleep(nanoseconds: 30_000_000) }
XCTAssertLessThan(model.pasteRemaining, remaining)
XCTAssertEqual(updates, 0, "Paste progress must not rebuild menus")
model.pause(); try await settled(model)
XCTAssertFalse(menu.values.pasting)
XCTAssertGreaterThan(updates, 0); XCTAssertEqual(menu.values.state, .paused)
updates = 0
for _ in 0..<4 {
model.poll(); try await Task.sleep(nanoseconds: 30_000_000)
}
XCTAssertEqual(updates, 0, "Paused polling must also leave a tracking menu alone")
model.setVideoOutput(.rgb); try await settled(model)
XCTAssertEqual(menu.values.videoOutput, .rgb)
model.setAudio(false); try await settled(model)
XCTAssertFalse(menu.values.audioEnabled, "Toolbar sound follows accepted command state")
model.setAudio(true); try await settled(model)
XCTAssertTrue(menu.values.audioEnabled)
updates = 0
for _ in 0..<4 {
model.poll(); try await Task.sleep(nanoseconds: 30_000_000)
}
XCTAssertEqual(updates, 0, "Identical sound and video snapshots must not rebuild toolbar menus")
model.setFastForward(true); try await settled(model)
XCTAssertTrue(menu.values.fastForward); XCTAssertFalse(menu.values.busy)
let rom = folder.appendingPathComponent("authored.rom")
try Data(repeating: 0, count: 8192).write(to: rom)
model.selectDiskROM(rom); try await settled(model)
XCTAssertNil(model.error); XCTAssertTrue(menu.values.diskConnected)
XCTAssertEqual(menu.values.canQuickLoad, model.canQuickLoad)
} catch {
await withCheckedContinuation { done in model.shutdown { done.resume() } }; throw error
}
await withCheckedContinuation { done in model.shutdown { done.resume() } }
XCTAssertEqual(menu.values.state, .closed); XCTAssertFalse(menu.values.canQuickLoad)
}
}