use super::*;
use crate::execution_native::NativeEngineRole;
use crate::loader::ppc::PpcSoundState;
use crate::process_context::PendingFileCompletion;
use crate::trap::dispatch::TrapTableProfile;
#[test]
fn file_completion_callback_uses_documented_registers_and_restores_foreground() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let interrupted_pc = 0x0001_0000;
let interrupted_sp = 0x007F_FFC0;
let parameter_block = runner.bus.alloc(64);
let callback_addr = runner.bus.alloc(2);
runner.bus.write_word(callback_addr, 0x4E75); for offset in (0..20).step_by(2) {
runner.bus.write_word(interrupted_pc + offset, 0x4E71); }
runner.m68k.cpu.write_reg(Register::PC, interrupted_pc);
runner.m68k.cpu.write_reg(Register::A7, interrupted_sp);
runner.m68k.cpu.write_reg(Register::A0, 0x1111_1111);
runner.m68k.cpu.write_reg(Register::D0, 0x2222_2222);
runner
.dispatcher
.pending_file_completions
.push_back(PendingFileCompletion {
parameter_block,
completion_addr: callback_addr,
result: -39,
});
assert!(runner.fire_file_completion_callback());
assert_eq!(runner.bus.read_word(parameter_block + 16) as i16, -39);
assert_eq!(runner.m68k.cpu.read_reg(Register::A0), parameter_block);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0) as i32, -39);
assert!(matches!(
runner.active_interrupt_callback.map(|active| active.source),
Some(ActiveInterruptCallbackSource::FileCompletion)
));
assert!(
runner
.bus
.get_alloc_size(runner.file_completion_trampoline)
.is_none(),
"Systemless-owned completion trampoline must stay outside the guest heap"
);
let (_, running) = runner.run_steps(6, None);
assert!(running);
assert!(runner.active_interrupt_callback.is_none());
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), interrupted_sp);
assert_eq!(runner.m68k.cpu.read_reg(Register::A0), 0x1111_1111);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 0x2222_2222);
assert!(!runner.is_halted());
}
#[test]
fn idle_hle_traps_do_not_apply_extra_tick_cost() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner.bus.write_word(base, 0xA975); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 42);
runner.set_guest_tick_for_test(42);
runner.set_instructions_per_tick(5);
let (steps, running) = runner.run_steps(1, None);
assert!(running);
assert_eq!(steps, 1);
assert_eq!(
runner.guest_tick(),
42,
"polling traps should not add synthetic HLE manager cost"
);
assert_eq!(runner.tick_budget, 4);
}
#[test]
fn hle_trap_cost_stops_gui_slice_at_tick_cap() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
let rect = 0x0020_0000u32;
runner.bus.write_word(base, 0xA8A8); runner.bus.write_word(base + 2, 0x4E71); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_word(sp, 1);
runner.bus.write_word(sp + 2, 2);
runner.bus.write_long(sp + 4, rect);
runner.bus.write_word(rect, 10);
runner.bus.write_word(rect + 2, 20);
runner.bus.write_word(rect + 4, 30);
runner.bus.write_word(rect + 6, 40);
runner.bus.write_long(0x016A, 0);
runner.set_guest_tick_for_test(0);
runner.set_instructions_per_tick(5);
let (steps, running) = runner.run_gui_slice_with_audio(8, 1, 0);
assert!(running);
assert_eq!(steps, 1);
assert_eq!(runner.guest_tick(), 1);
assert_eq!(
runner.m68k.cpu.read_reg(Register::PC),
base + 2,
"the next guest instruction should be deferred once HLE cost reaches the GUI tick cap"
);
}
#[test]
fn dispatcher_tick_count_stays_in_sync_with_bus() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let program_start = 0x0001_0000;
let program_words = 20;
for offset in (0..program_words).step_by(2) {
runner.bus.write_word(program_start + offset, 0x4E71);
}
runner.m68k.cpu.write_reg(Register::PC, program_start);
runner.m68k.cpu.write_reg(Register::A7, 0x007F_FFC0);
runner.bus.write_long(0x016A, 0);
runner.set_guest_tick_for_test(0);
runner.set_instructions_per_tick(3);
for _ in 0..3 {
let (_, running) = runner.run_steps(3, None);
assert!(running);
assert_eq!(
runner.bus.read_long(0x016A),
runner.guest_tick(),
"guest low-memory Ticks ({}) diverged from semantic reader ({})",
runner.bus.read_long(0x016A),
runner.guest_tick(),
);
}
}
#[test]
fn tickcount_runner_uses_canonical_dispatch_and_accounting() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner.bus.write_word(base, 0x594F); runner.bus.write_word(base + 2, 0xA975); runner.bus.write_word(base + 4, 0x4E71); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.set_guest_tick_for_test(0x1234_5678);
runner.bus.write_long(0x016A, 0x1234_5678);
runner.set_instructions_per_tick(1_000_000);
let before_traps = runner.dispatcher.trap_count;
let (steps, running) = runner.run_steps(2, None);
assert!(
running,
"runner should not halt on a canonical TickCount trap"
);
assert_eq!(steps, 2);
assert_eq!(runner.bus.read_long(0x000F_FFFC), 0x1234_5678);
assert_eq!(runner.dispatcher.trap_count - before_traps, 1);
}
#[test]
fn halted_by_exit_to_shell_classifies_clean_application_quit() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner.bus.write_word(base, 0xA9F4); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let (_steps, running) = runner.run_steps(1, None);
assert!(!running, "ExitToShell should stop the runner");
assert!(runner.is_halted());
assert_eq!(runner.halted_trap(), Some(0xA9F4));
assert!(
runner.halted_by_exit_to_shell(),
"ExitToShell halt must be classified as a clean application exit"
);
}
#[test]
fn unimplemented_trap_halts_at_the_faulting_instruction() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0xAFFE);
runner.bus.write_word(base + 2, 0x4E71);
runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
let (steps, running) = runner.run_steps(1, None);
assert_eq!(steps, 1);
assert!(
!running,
"an unclassified HLE row must fail closed (pc=${:08X})",
runner.m68k.cpu.read_reg(Register::PC)
);
assert!(runner.is_halted());
assert_eq!(runner.halted_pc(), Some(base));
assert_eq!(runner.halted_trap(), Some(0xAFFE));
assert_eq!(runner.halted_sp(), Some(sp));
}
#[test]
fn exit_to_shell_activates_launch_target_queued_until_event_yield() {
let helper_code0 = minimal_code0(0, 0x2000, 0, 0);
let helper_fork_bytes = make_resource_fork_bytes(&[(*b"CODE", 0, &helper_code0)]);
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner
.dispatcher
.vfs
.insert("Apps/Register Helper".to_string(), Vec::new());
runner
.dispatcher
.vfs_rsrc
.insert("Apps/Register Helper".to_string(), helper_fork_bytes);
runner.dispatcher.ensure_vfs_catalog();
runner
.dispatcher
.queue_pending_launch_application("Apps/Register Helper", true);
runner.bus.write_word(base, 0xA9F4); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let (_steps, running) = runner.run_steps(1, None);
assert!(
running,
"ExitToShell should activate a valid queued launch target"
);
assert!(!runner.is_halted());
assert_eq!(
runner.dispatcher.launched_app_path(),
Some("Apps/Register Helper")
);
}
#[test]
fn exit_to_shell_launches_best_application_created_by_installer() {
let app_code0 = minimal_code0(0, 0x2000, 0, 0);
let app_fork = make_resource_fork_bytes(&[(*b"CODE", 0, &app_code0)]);
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner
.dispatcher
.vfs
.insert("Existing/Previous Game".to_string(), Vec::new());
runner
.dispatcher
.vfs_rsrc
.insert("Existing/Previous Game".to_string(), app_fork.clone());
runner.dispatcher.set_vfs_entry_finfo(
"Existing/Previous Game",
u32::from_be_bytes(*b"APPL"),
u32::from_be_bytes(*b"GAME"),
0,
);
runner.arm_installer_handoff();
for path in ["Installed/Register", "Installed/Main Game"] {
runner.dispatcher.vfs.insert(path.to_string(), Vec::new());
runner
.dispatcher
.vfs_rsrc
.insert(path.to_string(), app_fork.clone());
runner.dispatcher.set_vfs_entry_finfo(
path,
u32::from_be_bytes(*b"APPL"),
u32::from_be_bytes(*b"GAME"),
0,
);
}
runner.bus.write_word(base, 0xA9F4); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let (_steps, running) = runner.run_steps(1, None);
assert!(running, "installer exit should activate the installed game");
assert!(!runner.is_halted());
assert_eq!(
runner.dispatcher.launched_app_path(),
Some("Installed/Main Game")
);
}
#[test]
fn halted_by_exit_to_shell_rejects_invalid_pc_halts() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner
.m68k
.cpu
.write_reg(Register::PC, runner.bus.ram_size());
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let (_steps, running) = runner.run_steps(1, None);
assert!(!running, "invalid PC should stop the runner");
assert!(runner.is_halted());
assert_eq!(runner.halted_trap(), None);
assert!(
!runner.halted_by_exit_to_shell(),
"invalid-PC halts must not be reported as clean application exits"
);
}
#[test]
fn ptinrect_runner_dispatch_matches_pascal_stack_contract() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
let rect = 0x0020_0000u32;
runner.bus.write_word(base, 0xA8AD); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.set_instructions_per_tick(1_000_000);
runner.bus.write_long(sp, rect);
runner.bus.write_word(sp + 4, 20); runner.bus.write_word(sp + 6, 30); runner.bus.write_word(rect, 10); runner.bus.write_word(rect + 2, 25); runner.bus.write_word(rect + 4, 40); runner.bus.write_word(rect + 6, 50);
let before_traps = runner.dispatcher.trap_count;
let before_game = runner.dispatcher.game_trap_count;
let (steps, running) = runner.run_steps(1, None);
assert!(
running,
"runner should not halt on canonical PtInRect dispatch"
);
assert_eq!(steps, 1);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 2);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp + 8);
assert_eq!(runner.bus.read_word(sp + 8), 0x0100);
assert_eq!(runner.dispatcher.trap_count - before_traps, 1);
assert_eq!(runner.dispatcher.game_trap_count - before_game, 1);
}
#[test]
fn constructed_trap_tables_survive_companion_installation_and_observe_native_stores() {
use crate::trap::dispatch::{OS_TRAP_TABLE_BASE, TOOLBOX_TRAP_TABLE_BASE};
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let mut cells = Vec::new();
for (base, count) in [(OS_TRAP_TABLE_BASE, 256), (TOOLBOX_TRAP_TABLE_BASE, 1024)] {
for slot in 0..count {
let cell = base + slot * 4;
let handler = runner.bus.read_long(cell);
assert_ne!(handler, 0);
let instruction = runner.bus.read_word(handler);
assert!(!runner.bus.try_write_word(handler, instruction ^ 0xFFFF));
assert_eq!(runner.bus.read_word(handler), instruction);
cells.push((cell, handler));
}
}
let vectors = runner.dispatcher.trap_exception_vector_defaults.unwrap();
let entry = TOOLBOX_TRAP_TABLE_BASE + 0x175 * 4; let default = runner.bus.read_long(entry);
let patch = 0x0010_1000;
let program = 0x0010_0000;
runner.bus.write_word(patch, 0x4E75); runner.bus.write_word(program, 0xA975); runner.bus.write_word(program + 2, 0x4E71);
runner.bus.write_long(entry, patch);
runner.bus.write_long(0x2C, patch);
let mut app = halted_ppc_app_with_sound(PpcSoundState::default());
runner.init_ppc_companion(app.ppc.take().unwrap());
assert_eq!(
runner.dispatcher.trap_table_profile,
Some(TrapTableProfile::M68k68040)
);
{
let companion = runner
.native
.adapter_mut(NativeEngineRole::Companion)
.unwrap();
for (cell, handler) in cells {
assert_eq!(
companion.memory.read_u32_be(cell),
Some(if cell == entry { patch } else { handler })
);
}
assert_eq!(companion.memory.read_u32_be(0x28), Some(vectors[0]));
assert_eq!(companion.memory.read_u32_be(0x2C), Some(patch));
companion.memory.write_u32_be(entry, default).unwrap();
}
assert_eq!(
runner.dispatcher.trap_table_address(&runner.bus, 0xA975),
Some(default)
);
runner
.native
.adapter_mut(NativeEngineRole::Companion)
.unwrap()
.memory
.write_u32_be(entry, patch)
.unwrap();
runner.m68k.cpu.write_reg(Register::D0, 0xA975);
runner
.dispatcher
.dispatch(0xA746, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
assert_eq!(runner.m68k.cpu.read_reg(Register::A0), patch);
runner.m68k.cpu.write_reg(Register::PC, program);
runner.m68k.cpu.write_reg(Register::A7, 0x007F_FFC0);
assert_eq!(runner.run_steps(1, None), (1, true));
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), patch);
assert_eq!(runner.run_steps(1, None), (1, true));
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), program + 2);
}
#[test]
fn guest_line_vectors_receive_architectural_frames_and_restore_defaults() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let defaults = runner.dispatcher.trap_exception_vector_defaults.unwrap();
let original_sp = 0x007F_FFC0;
let aline_handler = 0x0010_1000;
runner.bus.write_word(aline_handler, 0x2C3C);
runner.bus.write_long(aline_handler + 2, 0xA10E_0010);
runner.bus.write_word(aline_handler + 6, 0x54AF);
runner.bus.write_word(aline_handler + 8, 0x0002);
runner.bus.write_word(aline_handler + 10, 0x4E73);
runner.bus.write_long(0x28, aline_handler);
let aline_program = 0x0010_0000;
runner.bus.write_word(aline_program, 0xA975); runner.bus.write_word(aline_program + 2, 0x4E71); runner.m68k.cpu.write_reg(Register::PC, aline_program);
runner.m68k.cpu.write_reg(Register::A7, original_sp);
assert_eq!(runner.run_steps(1, None), (1, true));
let aline_frame = original_sp - 8;
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), aline_handler);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), aline_frame);
assert_eq!(runner.bus.read_long(aline_frame + 2), aline_program);
assert_eq!(runner.bus.read_word(aline_frame + 6), 0x0028);
assert_eq!(runner.run_steps(3, None), (3, true));
assert_eq!(runner.m68k.cpu.read_reg(Register::D6), 0xA10E_0010);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), original_sp);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), aline_program + 2);
runner.bus.write_long(0x28, defaults[0]);
runner.m68k.cpu.write_reg(Register::PC, aline_program);
let trap_count = runner.dispatcher.trap_count;
assert_eq!(runner.run_steps(1, None), (1, true));
assert_eq!(runner.dispatcher.trap_count, trap_count + 1);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), aline_program + 2);
let fline_handler = 0x0010_1100;
runner.bus.write_word(fline_handler, 0x2A3C); runner.bus.write_long(fline_handler + 2, 0xF11E_0011);
runner.bus.write_word(fline_handler + 6, 0x54AF);
runner.bus.write_word(fline_handler + 8, 0x0002);
runner.bus.write_word(fline_handler + 10, 0x4E73);
runner.bus.write_long(0x2C, fline_handler);
let fline_program = 0x0010_0200;
runner.bus.write_word(fline_program, 0xF000);
runner.bus.write_word(fline_program + 2, 0x4E71);
runner.m68k.cpu.write_reg(Register::PC, fline_program);
runner.m68k.cpu.write_reg(Register::A7, original_sp);
assert_eq!(runner.run_steps(1, None), (1, true));
let fline_frame = original_sp - 8;
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), fline_handler);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), fline_frame);
assert_eq!(runner.bus.read_long(fline_frame + 2), fline_program);
assert_eq!(runner.bus.read_word(fline_frame + 6), 0x002C);
assert_eq!(runner.run_steps(3, None), (3, true));
assert_eq!(runner.m68k.cpu.read_reg(Register::D5), 0xF11E_0011);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), original_sp);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), fline_program + 2);
runner.bus.write_long(0x2C, defaults[1]);
}
#[test]
fn valid_68040_fpu_opcode_does_not_enter_guest_vector_11() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let fline_handler = 0x0010_1100;
runner.bus.write_word(fline_handler, 0x2E3C); runner.bus.write_long(fline_handler + 2, 0xBADF_11E0);
runner.bus.write_word(fline_handler + 6, 0x4E73);
runner.bus.write_long(0x2C, fline_handler);
let program = 0x0010_0000;
runner.bus.write_word(program, 0xF280); runner.bus.write_word(program + 2, 0x0000);
runner.bus.write_word(program + 4, 0x4E71); runner.m68k.cpu.write_reg(Register::PC, program);
runner.m68k.cpu.write_reg(Register::A7, 0x007F_FFC0);
runner.m68k.cpu.write_reg(Register::D7, 0x1357_2468);
assert_eq!(runner.run_steps(1, None), (1, true));
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), program + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), 0x007F_FFC0);
assert_eq!(runner.m68k.cpu.read_reg(Register::D7), 0x1357_2468);
}
#[test]
fn zero_divide_rte_handler_resumes_after_divu_by_zero() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.bus.write_word(0x00FE, 0x4E73); runner.bus.write_long(0x0014, 0x0000_00FE);
let prog = 0x0010_0000u32;
runner.bus.write_word(prog, 0x82C0); runner.bus.write_word(prog + 2, 0x4E71); runner.bus.write_word(prog + 4, 0x4E71);
runner.m68k.cpu.write_reg(Register::PC, prog);
runner.m68k.cpu.write_reg(Register::A7, 0x007F_FFC0);
runner.m68k.cpu.write_reg(Register::D0, 0);
runner.m68k.cpu.write_reg(Register::D1, 100);
let (steps, running) = runner.run_steps(3, None);
assert!(running, "runner must not halt on zero-divide");
assert_eq!(steps, 3);
assert_eq!(
runner.m68k.cpu.read_reg(Register::PC),
prog + 4,
"PC must advance past the DIVU+NOP without re-entering the trap"
);
assert_eq!(
runner.m68k.cpu.read_reg(Register::D1),
100,
"DIVU by zero must leave the destination register unchanged"
);
}
#[test]
fn chk_rte_handler_resumes_after_bounds_violation() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.bus.write_word(0x00FE, 0x4E73); runner.bus.write_long(0x0018, 0x0000_00FE);
let prog = 0x0010_0000u32;
runner.bus.write_word(prog, 0x41BC); runner.bus.write_word(prog + 2, 0x0005); runner.bus.write_word(prog + 4, 0x4E71);
runner.m68k.cpu.write_reg(Register::PC, prog);
runner.m68k.cpu.write_reg(Register::A7, 0x007F_FFC0);
runner.m68k.cpu.write_reg(Register::D0, 100);
let (steps, running) = runner.run_steps(3, None);
assert!(running, "runner must not halt on CHK bounds violation");
assert_eq!(steps, 3);
assert_eq!(
runner.m68k.cpu.read_reg(Register::PC),
prog + 6,
"PC must advance past CHK (4 bytes) + NOP (2 bytes)"
);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 100);
}
#[test]
fn trapv_rte_handler_resumes_when_v_flag_is_set() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.bus.write_word(0x00FE, 0x4E73); runner.bus.write_long(0x001C, 0x0000_00FE);
let prog = 0x0010_0000u32;
runner.bus.write_word(prog, 0x4E76); runner.bus.write_word(prog + 2, 0x4E71);
runner.m68k.cpu.write_reg(Register::PC, prog);
runner.m68k.cpu.write_reg(Register::A7, 0x007F_FFC0);
runner.m68k.cpu.core.set_ccr(0x02);
let (steps, running) = runner.run_steps(3, None);
assert!(running, "runner must not halt on TRAPV");
assert_eq!(steps, 3);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), prog + 4);
}
#[test]
fn disassemble_at_decodes_known_opcodes_with_correct_advance() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let pc = 0x10000u32;
runner.bus.write_word(pc, 0x4E71);
runner.bus.write_word(pc + 2, 0xA8EC);
runner.bus.write_word(pc + 4, 0x4E71);
let out = runner.disassemble_at(pc, 3);
assert_eq!(
out.len(),
3,
"disassemble_at must return exactly count entries"
);
assert_eq!(
out[0].0, pc,
"first entry's PC must equal the requested start"
);
assert!(
out[0].1.contains("NOP"),
"$4E71 must disassemble to NOP, got: {}",
out[0].1
);
assert!(
out[0].2 >= 2 && out[0].2 <= 10,
"instruction size must be in clamp range [2, 10], got {}",
out[0].2
);
assert_eq!(
out[1].0,
pc + out[0].2,
"second entry's PC must equal first PC + first size"
);
assert!(
out[1].1.contains("$A8EC"),
"A-line trap $A8EC must surface in mnemonic (DC.W form), got: {}",
out[1].1
);
assert!(
out[2].1.contains("NOP"),
"third entry must be the second NOP we seeded"
);
}
#[test]
fn disassemble_at_uses_the_configured_ram_boundary() {
let mut runner = FixtureRunner::new(16 * 1024 * 1024, FixtureRunnerConfig::default());
let pc = 12 * 1024 * 1024;
runner.bus.write_word(pc, 0x4E71);
let out = runner.disassemble_at(pc, 1);
assert_eq!(out.len(), 1);
assert!(
out[0].1.contains("NOP"),
"mapped RAM above 8 MiB must not be reported as unmapped"
);
}