Files
VCCPlusOSS/platforms/macos/Tests/DebuggerTraceTests.mm
T

128 lines
7.6 KiB
Plaintext

// SPDX-License-Identifier: GPL-3.0-or-later
#import <XCTest/XCTest.h>
#include "../../../src/core/MachineSession.h"
#include "../../../src/core/CpuHost.h"
#include "../../../src/core/mc6809.h"
#include "../../../src/core/hd6309.h"
#include "../../../src/core/tcc1014mmu.h"
#include <stdexcept>
using namespace VCC::Mac;
namespace { template<class F> bool rejectsTrace(F f) { try { f(); } catch (const std::exception&) { return true; } return false; } }
@interface DebuggerTraceTests : XCTestCase
@end
@implementation DebuggerTraceTests
- (void)testInstructionCaptureBoundDoesNotPauseOrMutateGuest {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine; machine.loadDiagnostic(cpu);
auto before = machine.snapshot();
machine.debuggerStartTrace(3, {}, {}, false, false);
XCTAssertEqual(machine.snapshot().state, RunState::Paused);
machine.resume(); machine.advance();
auto trace = machine.debuggerTrace();
XCTAssertEqual(trace.total, 3u); XCTAssertFalse(trace.armed); XCTAssertFalse(trace.capturing);
XCTAssertEqual(trace.status, std::string("Sample limit reached"));
XCTAssertEqual(machine.snapshot().state, RunState::Running);
XCTAssertEqual(machine.snapshot().generation, before.generation);
XCTAssertEqual(trace.records[0].before.PC, 0x8000); XCTAssertEqual(trace.records[0].after.PC, 0x8003);
XCTAssertEqual(trace.records[0].bytes[0], 0x7c); XCTAssertGreaterThan(trace.records[0].cycles, 0);
XCTAssertLessThan(trace.records[0].clock, trace.records[1].clock);
machine.advance(); XCTAssertEqual(machine.debuggerTrace().total, 3u);
auto csv = machine.debuggerExportTrace(0, 2);
XCTAssertTrue(csv.find("INC") != std::string::npos); XCTAssertTrue(csv.find("BRA") != std::string::npos);
XCTAssertTrue(rejectsTrace([&] { machine.debuggerExportTrace(2, 2); }));
}
}
- (void)testMultipleTriggersAndStepTracing {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine; machine.loadDiagnostic(cpu);
machine.debuggerStartTrace(100, {0x9999, 0x8003}, {0x8000, 0x8888}, false, false);
machine.debuggerStep(); XCTAssertEqual(machine.debuggerTrace().total, 0u);
machine.debuggerStep();
auto trace = machine.debuggerTrace(); XCTAssertEqual(trace.total, 1u);
XCTAssertEqual(trace.records[0].before.PC, 0x8003); XCTAssertEqual(trace.records[0].after.PC, 0x8000);
machine.debuggerStep(); trace = machine.debuggerTrace();
XCTAssertFalse(trace.armed); XCTAssertEqual(trace.total, 1u);
XCTAssertEqual(trace.status, std::string("Stop address reached (before instruction)"));
XCTAssertEqual(machine.snapshot().cpu.PC, 0x8003, "Trace stop never prevents guest instruction execution");
machine.debuggerStartTrace(10, {0x9000}, {}, false, false);
machine.resume(); machine.advance(); XCTAssertTrue(machine.debuggerTrace().armed); XCTAssertFalse(machine.debuggerTrace().capturing);
machine.debuggerStopTrace(); XCTAssertFalse(machine.debuggerTrace().armed);
}
}
- (void)testRealScreenAndSchedulerEventsAndImmutablePages {
MachineSession machine; machine.loadDiagnostic();
machine.debuggerStartTrace(100000, {}, {}, true, true);
machine.resume(); machine.advance(); machine.advance(); machine.debuggerStopTrace();
auto first = machine.debuggerTrace(0, 256); auto total = first.total;
bool screen = false, scheduler = false;
std::uint64_t lastClock = 0;
for (std::size_t offset = 0; offset < total; offset += 256) {
for (const auto& row : machine.debuggerTrace(offset).records) {
screen |= row.event == VCC::TraceEvent::ScreenHSYNCLow;
scheduler |= row.event == VCC::TraceEvent::EmulatorCycle;
XCTAssertGreaterThanOrEqual(row.clock, lastClock); lastClock = row.clock;
}
}
XCTAssertTrue(screen); XCTAssertTrue(scheduler);
auto exported = machine.debuggerTraceForExport(1, 2);
machine.debuggerClearTrace(); XCTAssertEqual(machine.debuggerTrace().total, 0u);
const auto historicalCSV = FormatDebugTraceCSV(exported);
XCTAssertTrue(historicalCSV.find("\n2,") != std::string::npos);
XCTAssertTrue(historicalCSV.find("\n3,") != std::string::npos);
XCTAssertEqual(first.total, total); XCTAssertFalse(first.records.empty());
XCTAssertTrue(rejectsTrace([&] { machine.debuggerTrace(0, 257); }));
XCTAssertTrue(rejectsTrace([&] { machine.debuggerStartTrace(100001, {}, {}, false, false); }));
}
- (void)testIRQStagesAndResetRetainStoppedCapture {
MachineSession machine; machine.loadDiagnostic(); machine.debuggerStartTrace(100, {}, {}, false, false);
machine.debuggerStep();
// Same synchronous hooks used by the retained CPU interrupt engines; no
// interrupt inference from CC masks or polling of device registers.
auto state = machine.snapshot().cpu;
VCC::CpuDebugger().TraceCaptureInterruptRequest(INT_IRQ, 0, state);
VCC::CpuDebugger().TraceCaptureInterruptServicing(INT_IRQ, 0, state);
VCC::CpuDebugger().TraceCaptureInterruptExecuting(INT_IRQ, 0, state);
auto trace = machine.debuggerTrace(); XCTAssertEqual(trace.total, 4u);
XCTAssertEqual(trace.records[1].event, VCC::TraceEvent::IRQRequested);
XCTAssertEqual(trace.records[2].event, VCC::TraceEvent::IRQServicing);
XCTAssertEqual(trace.records[3].event, VCC::TraceEvent::IRQExecuting);
machine.softReset(); XCTAssertFalse(machine.debuggerTrace().armed); XCTAssertEqual(machine.debuggerTrace().total, 4u);
machine.reset(); XCTAssertEqual(machine.debuggerTrace().total, 4u);
}
- (void)testRetainedCPUInterruptEnginesEmitActualIRQStages {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
std::vector<std::uint8_t> rom(0x8000, 0x12);
const std::uint8_t program[] = {0x10,0xce,0x70,0x00,0x1c,0xef,0x20,0xfe,0x3b};
std::copy(std::begin(program), std::end(program), rom.begin());
rom[0x7ffe]=0x80; rom[0x7fff]=0; rom[0x7ff8]=0x80; rom[0x7ff9]=8;
MachineSession machine; machine.load(rom, cpu);
machine.debuggerStep(); machine.debuggerStep();
machine.debuggerStartTrace(100, {}, {}, false, false); machine.debuggerStep();
if (cpu == Processor::MC6809) MC6809AssertInterupt(IS_GIME, INT_IRQ);
else HD6309AssertInterupt(IS_GIME, INT_IRQ);
machine.resume(); machine.advance();
const auto trace = machine.debuggerTrace();
bool requested=false, servicing=false, vector=false;
for (const auto& row : trace.records) {
requested |= row.event == VCC::TraceEvent::IRQRequested;
servicing |= row.event == VCC::TraceEvent::IRQServicing;
vector |= row.event == VCC::TraceEvent::IRQExecuting;
}
XCTAssertTrue(requested); XCTAssertTrue(servicing); XCTAssertTrue(vector);
}
}
- (void)testDisabledBreakpointsShareAtomicAuthoritativeState {
MachineSession machine; machine.loadDiagnostic();
machine.debuggerConfigureBreakpoints({}, {0x8000});
machine.resume(); machine.advance(); XCTAssertEqual(machine.snapshot().state, RunState::Running);
machine.debuggerConfigureBreakpoints({0x8000}, {}); machine.advance();
XCTAssertEqual(machine.snapshot().state, RunState::Paused);
machine.debuggerConfigureBreakpoints({0x8000}, {0x8003});
machine.softReset(); machine.reset();
XCTAssertEqual(machine.debuggerSnapshot().disabledBreakpoints.size(), 1u);
XCTAssertTrue(rejectsTrace([&] { machine.debuggerConfigureBreakpoints({0x8000}, {0x8000}); }));
XCTAssertEqual(machine.debuggerSnapshot().disabledBreakpoints[0], 0x8003);
machine.debuggerSetBreakpoints({}); XCTAssertTrue(machine.debuggerSnapshot().disabledBreakpoints.empty());
}
@end