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

83 lines
4.8 KiB
Plaintext

// SPDX-License-Identifier: GPL-3.0-or-later
#import <XCTest/XCTest.h>
#include "../../../src/core/MachineSession.h"
#include "../../../src/core/DebugDisassembler.h"
#include <stdexcept>
using namespace VCC::Mac;
@interface DebuggerMemoryToolsTests : XCTestCase
@end
@implementation DebuggerMemoryToolsTests
- (void)testRangeCaptureIsExactBoundedAndSideEffectFree {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine;
MachineConfiguration config; config.processor = cpu; config.ram = 3;
machine.configure(config); machine.loadDiagnostic(cpu);
machine.debuggerWriteMemory(0x4000, {0x86,0x2a,0x39});
const auto before = machine.snapshot();
const auto mapped = machine.debuggerMemoryRange(0x4000, 3, false);
XCTAssertEqual(mapped.bytes, (std::vector<std::uint8_t>{0x86,0x2a,0x39}));
const auto mmu = machine.debuggerSnapshot().mmu;
const auto physical = machine.debuggerMemoryRange(mmu.Effective[2].RAMStart, 3, true);
XCTAssertEqual(mapped.bytes, physical.bytes);
XCTAssertEqual(machine.debuggerMemoryRange(0x7fffff, 1, true).bytes.size(), 1u);
const auto all = machine.debuggerMemoryRange(0, 0x800000, true);
XCTAssertEqual(all.bytes.size(), 0x800000u);
XCTAssertEqual(all.available.back(), 1);
for (const auto params : {std::pair<std::uint32_t,std::uint32_t>{0,0}, {0x7fffff,2}, {0x800000,1}, {0xfffffff0,0x100}}) {
bool rejected = false;
try { machine.debuggerMemoryRange(params.first, params.second, true); }
catch (const std::invalid_argument&) { rejected = true; }
XCTAssertTrue(rejected);
}
bool mappedWrap = false;
try { machine.debuggerMemoryRange(0xffff, 2, false); }
catch (const std::invalid_argument&) { mappedWrap = true; }
XCTAssertTrue(mappedWrap);
const auto io = machine.debuggerMemoryRange(0xff00, 256, false);
XCTAssertEqual(io.available[0], 0); XCTAssertEqual(io.available[0x90], 1); XCTAssertEqual(io.available[0xf0], 1);
XCTAssertEqual(machine.snapshot().cycles, before.cycles);
XCTAssertEqual(machine.snapshot().generation, before.generation);
XCTAssertEqual(machine.snapshot().cpu.PC, before.cpu.PC);
machine.debuggerWriteMemory(0x4000, {0x12});
XCTAssertEqual(mapped.bytes.front(), 0x86);
}
}
- (void)testPhysicalDisassemblyUsesExplicitLogicalOriginAndTruncatesAtEnd {
for (bool enhanced : {false,true}) {
const auto rows = DisassembleRange({0x20,0xfe,0x8e,0x12}, {}, enhanced, 0xffff, 128);
XCTAssertEqual(rows.size(), 2u); XCTAssertEqual(rows[0].address, 0xffff);
XCTAssertEqual(rows[0].operand, "$FFFF"); XCTAssertEqual(rows[1].address, 1);
XCTAssertEqual(rows[1].bytes, (std::vector<std::uint8_t>{0x8e,0x12}));
XCTAssertEqual(rows[1].mnemonic, "FCB"); XCTAssertFalse(rows[1].valid);
const auto hidden = DisassembleRange({0x86,0xff,0x12}, {1,0,1}, enhanced, 0, 128);
XCTAssertEqual(hidden.size(), 3u); XCTAssertFalse(hidden[0].available); XCTAssertFalse(hidden[1].available);
XCTAssertEqual(hidden[2].mnemonic, "NOP");
XCTAssertTrue(DisassembleRange({}, {}, enhanced, 0, 10).empty());
}
}
- (void)testOS9ServicesRemainOptInAndUnknownServicesStayNumeric {
const std::vector<std::uint8_t> bytes{0x10,0x3f,0x89,0x10,0x3f,0x17,0x10,0x3f,0xfe};
for (bool enhanced : {false,true}) {
const auto plain = DisassembleRange(bytes, {}, enhanced, 0x8000, 1);
XCTAssertEqual(plain[0].mnemonic, "SWI2"); XCTAssertEqual(plain[0].bytes.size(), 2u);
const auto os9 = DisassembleRange(bytes, {}, enhanced, 0x8000, 3, true);
XCTAssertEqual(os9[0].mnemonic, "OS9"); XCTAssertEqual(os9[0].operand, "I$Read ($89)");
XCTAssertEqual(os9[1].operand, "F$CRC ($17)"); XCTAssertEqual(os9[2].operand, "#$FE");
XCTAssertEqual(os9[2].address, 0x8006); XCTAssertEqual(os9[2].bytes.size(), 3u);
const auto shortCall = DisassembleRange({0x10,0x3f}, {}, enhanced, 0, 1, true);
XCTAssertEqual(shortCall[0].mnemonic, "FCB"); XCTAssertEqual(shortCall[0].bytes.size(), 2u);
}
}
- (void)testOS9ModuleHeadersRequireParityAndPreserveEntryBoundary {
std::vector<std::uint8_t> bytes{0x87,0xcd,0x00,0x20,0x00,0x0d,0x11,0x81,0,0,0x10,0,0x20,0x12};
bytes[8] = 0xff;
for (unsigned i = 0; i < 8; ++i) bytes[8] ^= bytes[i];
const auto rows = DisassembleRange(bytes, {}, false, 0x1000, 2, true);
XCTAssertEqual(rows[0].mnemonic, "MODULE"); XCTAssertEqual(rows[0].bytes.size(), 13u);
XCTAssertNotEqual(rows[0].operand.find("entry +$0010"), std::string::npos);
XCTAssertEqual(rows[1].address, 0x100d); XCTAssertEqual(rows[1].mnemonic, "NOP");
bytes[8] ^= 1;
XCTAssertNotEqual(DisassembleRange(bytes, {}, false, 0, 1, true)[0].mnemonic, "MODULE");
}
@end