Files

99 lines
6.0 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
final class DebuggerTests: XCTestCase {
@MainActor private func command(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
await withCheckedContinuation { continuation in operation { continuation.resume(returning: $0) } }
}
@MainActor private func capture(_ controller: VCCMachineController, address: UInt16 = 0x8000,
memory: UInt16 = 0x4000, followPC: Bool = true) async -> VCCDebuggerSnapshot {
await withCheckedContinuation { continuation in
controller.debuggerSnapshot(address: address, followPC: followPC, memoryAddress: memory) {
continuation.resume(returning: $0)
}
}
}
@MainActor func testDebuggerBridgeSnapshotsEditsAndBreakpointsBothCPUs() async {
for use6309 in [false, true] {
let controller = VCCMachineController()
_ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) }
let loaded = await command { controller.loadDiagnostic(use6309: use6309, completion: $0) }
let before = await capture(controller)
XCTAssertTrue(Thread.isMainThread)
XCTAssertEqual(before.machine.state, .paused)
XCTAssertEqual(before.instructions.first?.mnemonic, "INC")
XCTAssertEqual(before.instructions.first?.address, 0x8000)
XCTAssertEqual(before.registers["PC"]?.uint16Value, 0x8000)
XCTAssertEqual(before.registers["E"] != nil, use6309)
XCTAssertEqual(before.memory.count, 256)
let stepped = await command(controller.debuggerStep)
XCTAssertNil(stepped.errorMessage); XCTAssertEqual(stepped.programCounter, 0x8003)
XCTAssertEqual(stepped.generation, loaded.generation); XCTAssertEqual(stepped.state, .paused)
XCTAssertGreaterThan(stepped.cycles, before.machine.cycles)
let after = await capture(controller)
XCTAssertEqual(after.memory[0], before.memory[0] &+ 1)
XCTAssertEqual(before.instructions.first?.address, 0x8000, "Published snapshots remain immutable")
let written = await command { controller.debuggerWriteMemory(address: 0x4000, data: Data([0x5A, 0xA5]), completion: $0) }
XCTAssertNil(written.errorMessage)
let edited = await capture(controller)
XCTAssertEqual(edited.memory.prefix(2), Data([0x5A, 0xA5]))
_ = await command { controller.debuggerSetPC(0x8000, completion: $0) }
_ = await command { controller.debuggerSetBreakpoints([0x8003], completion: $0) }
let running = await command(controller.resume)
XCTAssertEqual(running.state, .running)
var hit = running
for _ in 0..<100 {
hit = await command(controller.snapshot)
if hit.state == .paused { break }
try? await Task.sleep(nanoseconds: 10_000_000)
}
XCTAssertEqual(hit.state, .paused); XCTAssertEqual(hit.programCounter, 0x8003)
let stopped = await capture(controller)
XCTAssertEqual(stopped.breakpoints, [0x8003])
XCTAssertEqual(hit.generation, loaded.generation)
_ = await command(controller.resume)
for _ in 0..<100 {
hit = await command(controller.snapshot)
if hit.state == .paused { break }
try? await Task.sleep(nanoseconds: 10_000_000)
}
XCTAssertGreaterThan(hit.cycles, stopped.machine.cycles, "Continue must pass the current breakpoint before stopping again")
XCTAssertEqual(hit.programCounter, 0x8003)
_ = await command(controller.shutdown)
}
}
@MainActor func testDebuggerRejectionsAndUnavailableMemoryAreSafe() async {
let controller = VCCMachineController()
let empty = await capture(controller)
XCTAssertEqual(empty.machine.state, .empty); XCTAssertTrue(empty.instructions.isEmpty)
_ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) }
_ = await command(controller.loadDiagnostic)
let before = await capture(controller, address: 0xFF00, memory: 0xFF00, followPC: false)
XCTAssertEqual(before.memoryAvailable[0], 0)
XCTAssertFalse(before.instructions.first?.valid ?? true)
XCTAssertEqual(before.instructions.first?.bytes.count, 0)
let boundary = await capture(controller, address: 0xFF8F, memory: 0xFF80, followPC: false)
XCTAssertFalse(boundary.instructions[0].valid)
XCTAssertEqual(boundary.instructions[1].address, 0xFF90,
"An unavailable port must not consume the first safe GIME byte as an operand")
for (address, data) in [(UInt16(0x8000), Data([0])), (0xFF00, Data([0])), (0xFFFF, Data([1, 2]))] {
let rejected = await command { controller.debuggerWriteMemory(address: address, data: data, completion: $0) }
XCTAssertNotNil(rejected.errorMessage)
XCTAssertEqual(rejected.cycles, before.machine.cycles)
XCTAssertEqual(rejected.generation, before.machine.generation)
}
for values: [NSNumber] in [[-1], [65536], [1.5], [NSNumber(value: Double.nan)]] {
let rejected = await command { controller.debuggerSetBreakpoints(values, completion: $0) }
XCTAssertNotNil(rejected.errorMessage)
}
_ = await command(controller.resume)
let edit = await command { controller.debuggerSetPC(0x5000, completion: $0) }
XCTAssertNotNil(edit.errorMessage); XCTAssertEqual(edit.state, .running)
let rejectedStep = await command(controller.debuggerStep)
XCTAssertNotNil(rejectedStep.errorMessage); XCTAssertEqual(rejectedStep.state, .running)
_ = await command(controller.shutdown)
let closed = await capture(controller)
XCTAssertEqual(closed.machine.state, .closed); XCTAssertTrue(closed.instructions.isEmpty)
}
}