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