Files

101 lines
5.5 KiB
Plaintext

// SPDX-License-Identifier: GPL-3.0-or-later
#import <XCTest/XCTest.h>
#include "../../../src/core/DebugDisassembler.h"
#include <stdexcept>
using namespace VCC::Mac;
namespace {
DebugInstruction decode(std::initializer_list<std::uint8_t> bytes, bool use6309 = false,
std::uint16_t address = 0x8000, bool native = false) {
std::vector<std::uint8_t> memory(65536, 0x12);
auto cursor = address;
for (auto byte : bytes) memory[cursor++] = byte;
VCC::CPUState state; state.IsNative6309 = native;
return Disassemble(memory, state, use6309, address, 1).front();
}
}
@interface DisassemblerTests : XCTestCase
@end
@implementation DisassemblerTests
- (void)testBasicInstructionsAndSignedBranchTargets {
const auto load = decode({0x86, 0x7f});
XCTAssertEqual(load.mnemonic, "LDA"); XCTAssertEqual(load.operand, "#$7F");
XCTAssertEqual(load.bytes.size(), 2u); XCTAssertTrue(load.valid);
XCTAssertEqual(decode({0x8e, 0x12, 0x34}).operand, "#$1234");
XCTAssertEqual(decode({0x7c, 0x40, 0}).operand, "$4000");
XCTAssertEqual(decode({0x96, 0x42}).operand, "<$42");
XCTAssertEqual(decode({0x20, 0xfb}).operand, "$7FFD");
XCTAssertEqual(decode({0x20, 0x7f}).operand, "$8081");
XCTAssertEqual(decode({0x10, 0x26, 0xff, 0xfc}).operand, "$8000");
XCTAssertEqual(decode({0x16, 0x7f, 0xff}).operand, "$0002");
}
- (void)testIndexedSignedOffsetsIndirectAndPCRelative {
XCTAssertEqual(decode({0xa6, 0x1f}).operand, "-1,X");
XCTAssertEqual(decode({0xa6, 0x88, 0x80}).operand, "-128,X");
XCTAssertEqual(decode({0xa6, 0xa9, 0xff, 0xfe}).operand, "-2,Y");
XCTAssertEqual(decode({0xa6, 0x9f, 0xff, 0xfe}).operand, "[$FFFE]");
XCTAssertEqual(decode({0xa6, 0x9c, 0xfc}).operand, "[-4,PCR]");
XCTAssertEqual(decode({0xa6, 0xf3}).operand, "[,--S]");
XCTAssertFalse(decode({0xa6, 0x87}).valid);
XCTAssertEqual(decode({0xa6, 0x87}, true).operand, "E,X");
XCTAssertEqual(decode({0xa6, 0x8f}, true).operand, ",W");
XCTAssertEqual(decode({0xa6, 0xbe}, true).operand, "[W,Y]");
XCTAssertFalse(decode({0xa6, 0xbe}, false).valid);
}
- (void)testRegisterListsAndTransfers {
XCTAssertEqual(decode({0x34, 0xff}).operand, "CC,A,B,DP,X,Y,U,PC");
XCTAssertEqual(decode({0x36, 0x40}).operand, "S");
XCTAssertEqual(decode({0x1f, 0x01}).operand, "D,X");
XCTAssertFalse(decode({0x1f, 0x61}).valid);
XCTAssertEqual(decode({0x1f, 0x61}, true).operand, "W,X");
XCTAssertEqual(decode({0x10, 0x30, 0x12}, true).operand, "X,Y");
XCTAssertEqual(decode({0x11, 0x38, 0x12}, true).operand, "X+,Y+");
XCTAssertEqual(decode({0x11, 0x39, 0x34}, true).operand, "U-,S-");
XCTAssertEqual(decode({0x11, 0x3a, 0x12}, true).operand, "X+,Y");
XCTAssertEqual(decode({0x11, 0x3b, 0x12}, true).operand, "X,Y+");
XCTAssertFalse(decode({0x11, 0x38, 0x56}, true).valid);
}
- (void)test6309ImmediateMemoryBitOperationsAndNativeIdentity {
const auto emulation = decode({0xcd, 0x12, 0x34, 0x56, 0x78}, true);
const auto native = decode({0xcd, 0x12, 0x34, 0x56, 0x78}, true, 0x8000, true);
XCTAssertEqual(emulation.mnemonic, "LDQ"); XCTAssertEqual(emulation.operand, "#$12345678");
XCTAssertEqual(native.operand, emulation.operand); XCTAssertEqual(native.bytes, emulation.bytes);
XCTAssertFalse(decode({0xcd, 0x12, 0x34, 0x56, 0x78}).valid);
XCTAssertFalse(decode({0x10, 0xec, 0x84}).valid);
XCTAssertEqual(decode({0x01, 0x80, 0x42}, true).operand, "#$80,<$42");
const auto indexed = decode({0x61, 0x80, 0x88, 0xff}, true);
XCTAssertEqual(indexed.operand, "#$80,-1,X"); XCTAssertEqual(indexed.bytes.size(), 4u);
XCTAssertEqual(decode({0x71, 0x80, 0x12, 0x34}, true).operand, "#$80,$1234");
XCTAssertEqual(decode({0x11, 0x30, 0x53, 0x42}, true).operand, "A,2,3,<$42");
XCTAssertFalse(decode({0x11, 0x30, 0xc0, 0x42}, true).valid);
}
- (void)testInstructionFetchWrapAndInvalidProgress {
XCTAssertFalse(decode({0x15}).valid);
XCTAssertFalse(decode({0x11, 0x3e}).valid);
const auto wrap = decode({0x8e, 0x12, 0x34}, false, 0xffff);
XCTAssertEqual(wrap.address, 0xffff); XCTAssertEqual(wrap.operand, "#$1234");
XCTAssertEqual(decode({0x20, 0xfe}, false, 0xffff).operand, "$FFFF");
std::vector<std::uint8_t> memory(65536, 0x12);
memory[0xffff] = 0x10; memory[0] = 0;
const auto rows = Disassemble(memory, {}, false, 0xffff, 2);
XCTAssertFalse(rows[0].valid); XCTAssertEqual(rows[0].mnemonic, "FCB");
XCTAssertEqual(rows[0].operand, "$10,$00"); XCTAssertEqual(rows[1].address, 1);
XCTAssertEqual(rows[1].mnemonic, "NOP");
const auto original = memory;
for (bool use6309 : {false, true}) for (unsigned opcode = 0; opcode < 256; ++opcode) {
memory[0x8000] = opcode;
const auto instruction = Disassemble(memory, {}, use6309, 0x8000, 1).front();
XCTAssertGreaterThan(instruction.bytes.size(), 0u); XCTAssertLessThanOrEqual(instruction.bytes.size(), 6u);
}
memory[0x8000] = original[0x8000]; XCTAssertEqual(memory, original);
}
- (void)testSnapshotAndInstructionCountValidation {
bool shortRejected = false, countRejected = false;
try { Disassemble(std::vector<std::uint8_t>(65535), {}, false, 0, 1); }
catch (const std::invalid_argument&) { shortRejected = true; }
try { Disassemble(std::vector<std::uint8_t>(65536), {}, false, 0, 1025); }
catch (const std::invalid_argument&) { countRejected = true; }
XCTAssertTrue(shortRejected); XCTAssertTrue(countRejected);
XCTAssertTrue(Disassemble(std::vector<std::uint8_t>(65536), {}, false, 0, 0).empty());
}
@end