97 lines
5.7 KiB
Swift
97 lines
5.7 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
import XCTest
|
|
|
|
final class DebuggerMemoryModelTests: 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("Memory inspector operation timed out")
|
|
throw NSError(domain: "DebuggerMemoryTimeout", code: 1)
|
|
}
|
|
|
|
@MainActor func testPhysicalAddressParserKeepsFullWidthAndBounds() {
|
|
XCTAssertEqual(DebuggerModel.hexadecimalAddress("$7FFFFF", maximum: 0x7fffff), 0x7fffff)
|
|
XCTAssertEqual(DebuggerModel.hexadecimalAddress("0x070000", maximum: 0x7ffff), 0x70000)
|
|
XCTAssertNil(DebuggerModel.hexadecimalAddress("080000", maximum: 0x7ffff))
|
|
XCTAssertNil(DebuggerModel.hexadecimalAddress("100000000", maximum: UInt32.max))
|
|
XCTAssertNil(DebuggerModel.hexadecimalAddress("-1", maximum: 0x7fffff))
|
|
XCTAssertNil(DebuggerModel.hexadecimal("10000", maximum: 0x7fffff), "CPU addresses must remain 16-bit even when a caller supplies a wider limit")
|
|
XCTAssertEqual(DebuggerModel.hex(UInt32(0x7fffff), width: 6), "7FFFFF")
|
|
}
|
|
|
|
@MainActor func testPhysicalBrowsingMappedEditsAndRAMResizePreserveStateAndDrafts() 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 = "VCCDebuggerMemoryTests-" + 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 }
|
|
machine.loadDiagnostic()
|
|
try await until { !machine.busy && debugger.snapshot?.machine.state == .paused }
|
|
let generation = try XCTUnwrap(debugger.snapshot).machine.generation
|
|
let focus = machine.focusRequest
|
|
debugger.showMemory(at: 0x4000)
|
|
debugger.editAddressText = "4000"; debugger.editByteText = "5A"; debugger.writeByte()
|
|
try await until { !debugger.commandPending && debugger.memory.first == 0x5a }
|
|
let backing = try XCTUnwrap(debugger.snapshot?.mmu.effective[2]).ramAddress
|
|
debugger.memoryPane = .mmu
|
|
debugger.showPhysicalMemory(at: backing)
|
|
try await until { debugger.snapshot?.physicalAddress == backing && debugger.memory.first == 0x5a }
|
|
XCTAssertEqual(debugger.memoryPane, .memory)
|
|
XCTAssertTrue(debugger.physical); XCTAssertFalse(debugger.canEditMemory)
|
|
XCTAssertEqual(debugger.memoryAddressWidth, 6)
|
|
XCTAssertEqual(debugger.memoryLocation(offset: 0), backing)
|
|
debugger.editByteText = "A5"; debugger.writeByte()
|
|
try await Task.sleep(nanoseconds: 250_000_000)
|
|
XCTAssertEqual(debugger.memory.first, 0x5a, "Physical inspection must not expose the mapped-memory write action")
|
|
debugger.physicalAddressText = "7F"
|
|
try await Task.sleep(nanoseconds: 250_000_000)
|
|
XCTAssertEqual(debugger.physicalAddressText, "7F", "Polling preserves the unfinished physical-address draft")
|
|
debugger.setMemorySpace(.mapped)
|
|
XCTAssertEqual(debugger.memoryAddressText, "4000")
|
|
XCTAssertEqual(debugger.memory.first, 0x5a)
|
|
XCTAssertEqual(debugger.snapshot?.machine.generation, generation)
|
|
XCTAssertEqual(machine.focusRequest, focus)
|
|
|
|
var settings = machine.settings; settings.ram = 3
|
|
machine.applyMachineSettings(settings)
|
|
try await until { !machine.busy && debugger.installedRAM == 0x800000 }
|
|
debugger.setMemorySpace(.physical)
|
|
debugger.physicalAddressText = "7FFFFF"; debugger.goToMemory()
|
|
try await until { debugger.displayedMemoryAddress == 0x7ffff0 && debugger.memory.count == 16 }
|
|
XCTAssertEqual(debugger.memoryLocation(offset: 15), 0x7fffff)
|
|
XCTAssertFalse(debugger.canNextMemory)
|
|
debugger.pageMemory(forward: true)
|
|
XCTAssertEqual(debugger.physicalAddressText, "7FFFF0")
|
|
debugger.physicalAddressText = "800000"; debugger.goToMemory()
|
|
XCTAssertNotNil(debugger.validationMessage)
|
|
XCTAssertEqual(debugger.displayedMemoryAddress, 0x7ffff0)
|
|
|
|
debugger.physicalAddressText = "abc"
|
|
settings.ram = 0; machine.applyMachineSettings(settings)
|
|
try await until { !machine.busy && debugger.installedRAM == 0x20000 && debugger.displayedMemoryAddress < 0x20000 }
|
|
XCTAssertEqual(debugger.physicalAddressText, "abc", "Shrinking RAM must not replace unfinished input")
|
|
XCTAssertLessThanOrEqual(debugger.memory.count, 256)
|
|
XCTAssertNil(machine.error)
|
|
debugger.pageMemory(forward: false)
|
|
try await until { debugger.memory.count == 256 }
|
|
XCTAssertTrue(debugger.physical)
|
|
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
|
|
await withCheckedContinuation { done in machine.shutdown { done.resume() } }
|
|
}
|
|
}
|