123 lines
7.2 KiB
Swift
123 lines
7.2 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
import XCTest
|
|
|
|
final class DebuggerModelTests: XCTestCase {
|
|
@MainActor private func until(_ condition: () -> Bool) async throws {
|
|
for _ in 0..<500 {
|
|
if condition() { return }
|
|
try await Task.sleep(nanoseconds: 10_000_000)
|
|
}
|
|
XCTFail("Debugger model operation timed out")
|
|
throw NSError(domain: "DebuggerModelTimeout", code: 1)
|
|
}
|
|
|
|
@MainActor func testGraphicsAddressAndSingleStepOverlay() {
|
|
let model = GraphicsPreviewModel()
|
|
model.inspectAddress(0x1a00, physical: false)
|
|
model.addressText = "10000"
|
|
model.applyAddress()
|
|
XCTAssertNotNil(model.addressError)
|
|
XCTAssertEqual(model.request.address, 0x1a00)
|
|
model.inspectAddress(0x60000, physical: true)
|
|
XCTAssertNil(model.addressError)
|
|
XCTAssertEqual(model.addressText, "060000")
|
|
let before = Data([0, 0, 0, 255, 0, 255, 0, 255])
|
|
let after = Data([0, 0, 255, 255, 0, 255, 0, 255])
|
|
let (mask, count) = GraphicsPreviewModel.differences(before, after)
|
|
XCTAssertEqual(count, 1)
|
|
XCTAssertGreaterThan(mask[3], 0)
|
|
XCTAssertEqual(mask[7], 0)
|
|
XCTAssertEqual(GraphicsPreviewModel.differences(after, after).1, 0)
|
|
}
|
|
|
|
@MainActor func testHexadecimalInputRejectsOverflowAndNonHexCharacters() {
|
|
for (input, value) in [("0", 0), ("ffff", 65535), (" $a0 ", 160), ("0X7f", 127), ("0020", 32)] {
|
|
XCTAssertEqual(DebuggerModel.hexadecimal(input), UInt16(value), input)
|
|
}
|
|
for input in ["", "$", "0x", "-1", "+1", "1_00", "10 00", "10000", "FFFFF", "12G0", "12", "é"] {
|
|
XCTAssertNil(DebuggerModel.hexadecimal(input), input)
|
|
}
|
|
XCTAssertEqual(DebuggerModel.hexadecimal("FF", maximum: 255), 255)
|
|
XCTAssertNil(DebuggerModel.hexadecimal("100", maximum: 255))
|
|
XCTAssertEqual(DebuggerModel.hex(0xa5, width: 2), "A5")
|
|
XCTAssertEqual(DebuggerModel.hex(0xa5), "00A5")
|
|
}
|
|
|
|
@MainActor func testInspectorCommandsPreserveFocusDraftsAndSession() async throws {
|
|
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
|
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
|
|
defer { try? FileManager.default.removeItem(at: folder) }
|
|
let suite = "VCCDebuggerModelTests-" + UUID().uuidString
|
|
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
|
|
defer { defaults.removePersistentDomain(forName: suite) }
|
|
let machine = MachineModel(diskStore: .init(url: folder.appendingPathComponent("disks.json")),
|
|
displayDefaults: defaults, inputStore: .init(url: folder.appendingPathComponent("input.json")))
|
|
let debugger = DebuggerModel(machine: machine)
|
|
let polling = Task { await debugger.poll() }
|
|
do {
|
|
try await until { !machine.busy && !debugger.commandPending }
|
|
machine.loadDiagnostic()
|
|
try await until { !machine.busy && !debugger.commandPending && debugger.snapshot?.machine.state == .paused }
|
|
let generation = try XCTUnwrap(debugger.snapshot).machine.generation
|
|
let focus = machine.focusRequest
|
|
debugger.addressText = "123"; debugger.memoryAddressText = "456"
|
|
debugger.pcText = "8000"; debugger.breakpointText = "8000"
|
|
debugger.setPC()
|
|
try await until { !machine.busy && !debugger.commandPending && debugger.programCounter == 0x8000 }
|
|
debugger.addBreakpoint()
|
|
try await until { !machine.busy && !debugger.commandPending && debugger.breakpoints == [0x8000] }
|
|
let graphics = GraphicsPreviewModel()
|
|
graphics.inspectAddress(0x4000, physical: false)
|
|
let previewTask = Task { await graphics.poll(machine: machine) }
|
|
defer { previewTask.cancel() }
|
|
try await until { graphics.readyToStep(machine: machine) && graphics.frame != nil }
|
|
let beforeStep = try XCTUnwrap(graphics.frame?.capture)
|
|
debugger.step()
|
|
try await until { !machine.busy && !debugger.commandPending && debugger.programCounter == 0x8003 }
|
|
try await until { graphics.readyToStep(machine: machine) && graphics.frame?.changes != nil }
|
|
let afterStep = try XCTUnwrap(graphics.frame)
|
|
let expected = GraphicsPreviewModel.differences(beforeStep.rgba, afterStep.capture.rgba).1
|
|
XCTAssertEqual(afterStep.changes, expected)
|
|
let initialByte = try XCTUnwrap(beforeStep.pixel(x: 0, y: 0)).value
|
|
XCTAssertEqual(afterStep.capture.pixel(x: 0, y: 0)?.value, initialByte &+ 1)
|
|
previewTask.cancel()
|
|
await previewTask.value
|
|
XCTAssertTrue(debugger.changedRegisters.contains("PC"))
|
|
XCTAssertEqual(machine.state, .paused)
|
|
debugger.toggleExecution()
|
|
try await until { !machine.busy && !debugger.commandPending && machine.state == .paused && debugger.programCounter == 0x8000 }
|
|
XCTAssertEqual(debugger.snapshot?.machine.generation, generation)
|
|
debugger.removeAllBreakpoints()
|
|
try await until { !machine.busy && !debugger.commandPending && debugger.breakpoints.isEmpty }
|
|
debugger.toggleExecution()
|
|
try await until { !machine.busy && !debugger.commandPending && machine.state == .running && machine.frames > 0 }
|
|
debugger.toggleExecution()
|
|
try await until { !machine.busy && !debugger.commandPending && machine.state == .paused }
|
|
XCTAssertEqual(machine.focusRequest, focus, "Debugger commands must not steal focus from its text fields")
|
|
XCTAssertEqual(debugger.addressText, "123", "Polling preserves unfinished address entry")
|
|
XCTAssertEqual(debugger.memoryAddressText, "456")
|
|
debugger.editAddressText = "4000"; debugger.editByteText = "2A"
|
|
debugger.showMemory(at: 0x4000)
|
|
debugger.writeByte()
|
|
try await until { !machine.busy && !debugger.commandPending && debugger.memory.first == 0x2a }
|
|
XCTAssertEqual(machine.focusRequest, focus)
|
|
XCTAssertEqual(debugger.snapshot?.machine.generation, generation)
|
|
XCTAssertEqual(debugger.editByteText, "2A")
|
|
// Invalid input changes neither the machine nor an existing breakpoint set.
|
|
debugger.breakpointText = "10000"; debugger.addBreakpoint()
|
|
XCTAssertNotNil(debugger.validationMessage); XCTAssertTrue(debugger.breakpoints.isEmpty)
|
|
XCTAssertEqual(machine.state, .paused)
|
|
} catch {
|
|
polling.cancel(); await polling.value
|
|
await withCheckedContinuation { done in machine.shutdown { done.resume() } }
|
|
throw error
|
|
}
|
|
polling.cancel(); await polling.value
|
|
let pausedSnapshot = debugger.snapshot
|
|
try await Task.sleep(nanoseconds: 300_000_000)
|
|
XCTAssertTrue(debugger.snapshot === pausedSnapshot, "Closing an inspector stops its polling")
|
|
XCTAssertEqual(machine.state, .paused, "Closing an inspector does not resume the machine")
|
|
await withCheckedContinuation { done in machine.shutdown { done.resume() } }
|
|
}
|
|
}
|