use super::*;
use crate::cpu::Register;
use crate::callback_manager::CallbackTaskArchitecture;
use crate::sound::PendingDoubleBackCallback;
#[test]
fn idle_snapshot_preserves_extended_cpu_state() {
let mut cpu = m68k::CpuCore::new();
cpu.fpr[0] = m68k::fpu::FloatX80::from_extended(0x3FFF, 0x8000_0000_0000_0000);
let baseline = CpuArchitecturalSnapshot::capture(&cpu);
cpu.change_of_flow = !cpu.change_of_flow;
assert_eq!(
baseline,
CpuArchitecturalSnapshot::capture(&cpu),
"internal flow bookkeeping must not participate in an idle-cycle proof"
);
cpu.fpr[0].mantissa ^= 1;
assert_ne!(
baseline,
CpuArchitecturalSnapshot::capture(&cpu),
"80-bit FPU precision must participate in an idle-cycle proof"
);
cpu.fpr[0].mantissa ^= 1;
cpu.mmu_crp_aptr = 0x1234_5000;
assert_ne!(
baseline,
CpuArchitecturalSnapshot::capture(&cpu),
"canonical MMU state must participate in an idle-cycle proof"
);
cpu.mmu_crp_aptr = 0;
cpu.prefetch_queue[1] = 0x4E71;
assert_ne!(
baseline,
CpuArchitecturalSnapshot::capture(&cpu),
"precise prefetch state must participate in an idle-cycle proof"
);
}
#[test]
fn exact_idle_cycle_requires_cpu_and_memory_repeat() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
let sp = 0x0010_0000u32;
let scratch = 0x0020_0000u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA975;
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_long(sp, 100);
runner.bus.write_long(scratch, 0x1122_3344);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
assert!(runner.bus.fast_mem_window().is_none());
runner.bus.write_long(scratch, 0xAABB_CCDD);
runner.bus.write_long(scratch, 0x1122_3344);
runner.note_idle_cycle_trap_result(0xA971, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert_eq!(runner.guest_tick(), 105);
assert_eq!(runner.bus.read_long(0x016A), 105);
assert_eq!(runner.bus.read_long(sp), 100);
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.idle_cycle_sleep.is_some());
assert!(
runner.bus.fast_mem_window().is_none(),
"the parked sleep keeps a write guard armed across the frontend boundary"
);
runner.dispatcher.set_sent_open_app_event_for_test(true);
assert!(runner.try_resume_proven_idle_cycle(Some(110)));
assert_eq!(runner.guest_tick(), 110);
assert_eq!(runner.bus.read_long(sp), 100);
assert!(runner.idle_cycle_sleep.is_some());
runner.push_mouse_down(20, 30);
assert!(
!runner.try_resume_proven_idle_cycle(Some(115)),
"new host input must revoke a proof before the guest event loop is skipped"
);
assert_eq!(runner.guest_tick(), 110);
assert!(runner.idle_cycle_sleep.is_none());
assert!(runner.bus.fast_mem_window().is_some());
}
#[test]
fn busy_poller_overflows_one_journal_then_backs_off_for_the_tick() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
let work = 0x0030_0000u32;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
assert!(runner.bus.fast_mem_window().is_none());
for offset in 0..(8 * crate::memory::bus::WRITE_PROBE_MAX_ENTRIES as u32) {
runner.bus.write_byte(work + offset, 0xAA);
}
assert!(
runner.bus.fast_mem_window().is_some(),
"the bus voids an overflowing journal immediately, without waiting for the runner"
);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.idle_cycle_site_is_busy(trap_pc, 100));
for _ in 0..4 {
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.bus.fast_mem_window().is_some());
}
assert_eq!(
runner.guest_tick(),
100,
"a busy site is never fast-forwarded"
);
runner.set_guest_tick_for_test(101);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
assert!(runner.bus.fast_mem_window().is_none());
}
#[test]
fn a_site_that_keeps_failing_gets_two_probes_per_tick_then_none() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
let scratch = 0x0020_0000u32;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
runner.bus.write_long(scratch, 0x1111_1111);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some(), "one retry is allowed");
assert!(runner.bus.fast_mem_window().is_none());
runner.bus.write_long(scratch, 0x2222_2222);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.bus.fast_mem_window().is_some());
for _ in 0..8 {
runner.bus.write_long(scratch, 0x3333_3333);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.bus.fast_mem_window().is_some());
}
assert_eq!(runner.guest_tick(), 100);
runner.set_guest_tick_for_test(101);
runner.bus.write_long(0x016A, 101);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
runner.bus.write_long(scratch, 0xAAAA_AAAA);
runner.bus.write_long(scratch, 0x3333_3333);
runner.note_idle_cycle_trap_result(0xA971, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert_eq!(runner.guest_tick(), 105);
assert!(runner.idle_cycle_sleep.is_some());
}
#[test]
fn journal_complete_traps_do_not_cancel_an_idle_probe() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
for opcode in [
0xA972u16, 0xA973, 0xA974, 0xA975, 0xA976, 0xA9EB, 0xA9EC, 0xA870, 0xA871, 0xA917, 0xA924,
0xA92C, 0xA9DA, 0xA8AD, 0xAC70, 0xAC71, 0xAD17, 0xAD24, 0xAD2C, 0xADDA, 0xACAD,
0xA851, 0xAC51, 0xA858, 0xA85D, 0xA86B, 0xA873, 0xA875, 0xA9F1, 0xAC58, 0xAC5D, 0xAC6B,
0xAC73, 0xAC75, 0xADF1, 0xA97F, 0xAD7F,
] {
runner.note_idle_cycle_trap_result(opcode, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(
runner.idle_cycle_probe.is_some(),
"journal-complete trap {opcode:04X} must not cancel the probe"
);
}
for selector in [0x0008_0005u32, 0x0008_0006] {
runner.m68k.cpu.write_reg(Register::D0, selector);
for opcode in [0xAB1Du16, 0xAF1D] {
runner.note_idle_cycle_trap_result(
opcode,
runner.m68k.cpu.read_reg(Register::D0),
false,
);
assert!(
runner.idle_cycle_probe.is_some(),
"admitted QDExtensions selector {selector:08X} must not cancel the probe"
);
}
}
runner.note_idle_cycle_trap_result(0xA893, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(runner.idle_cycle_probe.is_none());
}
#[test]
fn handle_locks_and_rejected_sound_commands_do_not_cancel_an_idle_probe() {
let probe = |runner: &mut FixtureRunner| {
let trap_pc = 0x0002_0000u32;
runner.idle_cycle_probe = None;
runner.idle_cycle_sites = [IdleCycleSiteRecord::default(); IDLE_CYCLE_SITE_SLOTS];
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
};
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
probe(&mut runner);
for opcode in [0xA029u16, 0xA02A, 0xA229, 0xA42A] {
runner.note_idle_cycle_trap_result(opcode, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(
runner.idle_cycle_probe.is_some(),
"handle lock trap {opcode:04X} must not cancel the probe"
);
}
runner.bus.write_word(0x0010_0000, (-203i16) as u16); for opcode in [0xA803u16, 0xAC03] {
runner.note_idle_cycle_trap_result(opcode, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(
runner.idle_cycle_probe.is_some(),
"rejected SndDoCommand {opcode:04X} must not cancel the probe"
);
}
runner.bus.write_word(0x0010_0000, 0); runner.note_idle_cycle_trap_result(0xA803, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(
runner.idle_cycle_probe.is_none(),
"an accepted command must cancel"
);
probe(&mut runner);
runner.note_idle_cycle_trap_result(0xA064, runner.m68k.cpu.read_reg(Register::D0), false); assert!(runner.idle_cycle_probe.is_none(), "MoveHHi must cancel");
}
#[test]
fn counted_idle_passes_stop_before_the_update_would_set_different_flags() {
assert_eq!(passes_with_unchanged_flags(0x001C, 1, 2), 0x7FFF - 0x001C);
assert_eq!(passes_with_unchanged_flags(0x8005, 1, 2), 0xFFFF - 0x8005);
assert_eq!(passes_with_unchanged_flags(0x8000, 1, 2), 0);
assert_eq!(passes_with_unchanged_flags(0x0000, 1, 2), 0);
assert_eq!(passes_with_unchanged_flags(0x10, 4, 1), (0x7F - 0x10) / 4);
assert_eq!(
passes_with_unchanged_flags(0x0001_0000, 1, 4),
0x7FFF_FFFF - 0x0001_0000
);
assert_eq!(passes_with_unchanged_flags(0x0010, 0xFFFF, 2), 0x0F);
assert_eq!(passes_with_unchanged_flags(0x8010, 0xFFFF, 2), 0x10);
assert_eq!(passes_with_unchanged_flags(0x7FFF, 0xFFFF, 2), 0);
}
#[test]
fn only_add_or_subtract_immediate_to_memory_may_update_an_idle_counter() {
assert_eq!(add_immediate_to_memory_width(0x526D), Some(2)); assert_eq!(add_immediate_to_memory_width(0x52B9), Some(4)); assert_eq!(add_immediate_to_memory_width(0x5310), Some(1)); assert_eq!(add_immediate_to_memory_width(0x066D), Some(2)); assert_eq!(add_immediate_to_memory_width(0x04B8), Some(4)); assert_eq!(add_immediate_to_memory_width(0x5241), None); assert_eq!(add_immediate_to_memory_width(0x5249), None); assert_eq!(add_immediate_to_memory_width(0x51C8), None); assert_eq!(add_immediate_to_memory_width(0x527A), None); assert_eq!(add_immediate_to_memory_width(0x302D), None); }
#[test]
fn an_idle_counter_is_verified_only_when_its_update_is_its_sole_reader() {
use crate::memory::{AccessHit, AccessSource};
let pc = 0x0061_7CAC;
let hit = |write, address, len, source| AccessHit {
write,
address,
len,
source,
};
let rmw = AccessSource::Instruction(pc);
let changes = [(0x0060_7724u32, 0x001C_0000u32, 0x001D_0000u32)];
let opcode = |at: u32| if at == pc { 0x526D } else { 0x302D };
let bytes = |address: u32| match address {
0x0060_7724 => (0x00, 0x00),
0x0060_7725 => (0x1C, 0x1D),
_ => (0, 0),
};
let counter = IdleCounter {
address: 0x0060_7724,
width: 2,
step: 1,
};
let pair = [
hit(false, 0x0060_7724, 2, rmw),
hit(true, 0x0060_7724, 2, rmw),
];
assert_eq!(
verified_idle_counter(&pair, &changes, opcode, bytes),
Some(counter)
);
let other = AccessSource::Instruction(pc + 8);
let read_elsewhere = [pair[0], pair[1], hit(false, 0x0060_7724, 2, other)];
assert_eq!(
verified_idle_counter(&read_elsewhere, &changes, opcode, bytes),
None
);
let host = [hit(false, 0x0060_7724, 2, AccessSource::Host), pair[1]];
assert_eq!(verified_idle_counter(&host, &changes, opcode, bytes), None);
let split = [pair[0], hit(true, 0x0060_7724, 2, other)];
assert_eq!(verified_idle_counter(&split, &changes, opcode, bytes), None);
let moved = [
hit(false, 0x0060_7724, 2, other),
hit(true, 0x0060_7724, 2, other),
];
assert_eq!(verified_idle_counter(&moved, &changes, opcode, bytes), None);
let long_changes = [
(0x0060_7720u32, 0x0000_0000u32, 0x0000_0000u32),
(0x0060_7724, 0x0863_0000, 0x0864_0000),
];
let long_changes = &long_changes[1..];
let long_opcode = |at: u32| if at == pc { 0x52AD } else { 0x302D }; let long_bytes = |address: u32| match address {
0x0060_7724 => (0x08, 0x08),
0x0060_7725 => (0x63, 0x64),
_ => (0, 0),
};
let long_hits = [
hit(false, 0x0060_7722, 4, rmw),
hit(true, 0x0060_7724, 1, rmw),
hit(true, 0x0060_7725, 1, rmw),
];
assert_eq!(
verified_idle_counter(&long_hits, long_changes, long_opcode, long_bytes),
Some(IdleCounter {
address: 0x0060_7722,
width: 4,
step: 1
})
);
let stray = [long_hits[0], hit(true, 0x0060_7726, 1, rmw)];
assert_eq!(
verified_idle_counter(&stray, long_changes, long_opcode, long_bytes),
None
);
let wider = [(0x0060_7724u32, 0x001C_0000u32, 0x001D_0001u32)];
assert_eq!(verified_idle_counter(&pair, &wider, opcode, bytes), None);
}
#[test]
fn failed_counter_verifications_back_a_site_off_exponentially() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let site = 0x0002_0000u32;
let resume = |runner: &FixtureRunner| {
runner
.idle_cycle_sites
.iter()
.find(|rec| rec.site == site)
.unwrap()
.counter_resume_tick
};
for (failure, wait) in [4u32, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 2048]
.iter()
.enumerate()
{
runner.note_idle_counter_verification(site, 1000, false);
assert_eq!(resume(&runner), 1000 + wait, "failure {}", failure + 1);
}
runner.note_idle_counter_verification(site, 5000, true);
assert_eq!(resume(&runner), 5000);
runner.note_idle_counter_verification(site, 5000, false);
assert_eq!(resume(&runner), 5004, "success resets the streak");
}
#[test]
fn idle_cycle_backoff_expires_across_tick_wrap() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.idle_cycle_sites[0] = IdleCycleSiteRecord {
site: 0x20000,
tick: u32::MAX - 1,
probes: 0,
cancel_streak: 2,
resume_tick: (u32::MAX - 1).wrapping_add(4),
..IdleCycleSiteRecord::default()
};
assert!(runner.idle_cycle_site_is_busy(0x20000, u32::MAX));
assert!(runner.idle_cycle_site_is_busy(0x20000, 0));
assert!(runner.idle_cycle_site_is_busy(0x20000, 1));
assert!(!runner.idle_cycle_site_is_busy(0x20000, 2));
}
#[test]
fn repeated_trap_cancels_back_a_site_off_and_a_closed_proof_resets_it() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA975;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
for _ in 0..2 {
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
runner.note_idle_cycle_trap_result(0xA893, runner.m68k.cpu.read_reg(Register::D0), false); assert!(runner.idle_cycle_probe.is_none());
}
for _ in 0..4 {
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
}
assert!(runner.idle_cycle_probe.is_none());
runner.bus.write_long(0x016A, 104);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
assert!(runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
let rec = runner
.idle_cycle_sites
.iter()
.find(|rec| rec.site == trap_pc)
.expect("site record");
assert_eq!(rec.cancel_streak, 0);
assert_eq!(rec.resume_tick, 0);
}
#[test]
fn chrome_repaint_stays_out_of_an_armed_idle_journal() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let screen_base = 0x0040_0000u32;
runner.dispatcher.screen_mode = (screen_base, 1024, 1024, 768, 8);
runner.bus.write_long(0x0824, screen_base);
runner.bus.write_word(0x0BAA, 20);
runner.bus.begin_write_probe();
runner.redraw_chrome_outside_idle_journal();
assert!(!runner.bus.take_write_probe_overflow());
assert!(
runner.bus.suspend_write_probe().is_some(),
"the journal must still be armed after the repaint"
);
runner.bus.cancel_write_probe();
runner.bus.begin_write_probe();
runner.redraw_chrome_outside_idle_journal();
assert!(runner.bus.finish_write_probe_unchanged());
}
#[test]
fn first_parked_repaint_revokes_the_park_when_guest_overwrote_a_chrome_pixel() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let screen_base = 0x0040_0000u32;
runner.dispatcher.screen_mode = (screen_base, 1024, 1024, 768, 8);
runner.bus.write_long(0x0824, screen_base);
runner.bus.write_word(0x0BAA, 20);
runner.dispatcher.menus.push(crate::trap::menu::Menu {
id: 1,
title: String::from("Apple"),
items: Vec::new(),
enabled: true,
handle: 0,
in_menu_bar: true,
hierarchical: false,
visible_in_menu_bar: true,
});
runner.dispatcher.front_window = 0;
runner.dispatcher.fullscreen_locked = false;
runner.dispatcher.menu_bar_hidden = false;
runner.redraw_chrome_outside_idle_journal();
let pixel = screen_base + 5 * 1024 + 100;
assert_ne!(
runner.bus.read_byte(pixel),
0xAA,
"fixture: a painted menu-bar pixel must differ from the sentinel"
);
runner.bus.write_byte(pixel, 0xAA);
runner.park_proven_idle_cycle(0x0002_0000, 205);
assert!(runner.idle_cycle_sleep.is_some());
runner.redraw_chrome_outside_idle_journal();
assert_ne!(
runner.bus.read_byte(pixel),
0xAA,
"the repaint repainted the scribbled chrome pixel"
);
assert!(
runner.idle_cycle_sleep.is_none(),
"a repaint that changed guest RAM must revoke the park"
);
assert!(
runner.bus.suspend_write_probe().is_none(),
"the revoked park's journal must be closed"
);
}
#[test]
fn byte_identical_parked_repaints_keep_the_park() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let screen_base = 0x0040_0000u32;
runner.dispatcher.screen_mode = (screen_base, 1024, 1024, 768, 8);
runner.bus.write_long(0x0824, screen_base);
runner.bus.write_word(0x0BAA, 20);
runner.dispatcher.menus.push(crate::trap::menu::Menu {
id: 1,
title: String::from("Apple"),
items: Vec::new(),
enabled: true,
handle: 0,
in_menu_bar: true,
hierarchical: false,
visible_in_menu_bar: true,
});
runner.dispatcher.front_window = 0;
runner.dispatcher.fullscreen_locked = false;
runner.dispatcher.menu_bar_hidden = false;
runner.redraw_chrome_outside_idle_journal();
runner.park_proven_idle_cycle(0x0002_0000, 205);
assert!(runner.idle_cycle_sleep.is_some());
runner.redraw_chrome_outside_idle_journal();
runner.redraw_chrome_outside_idle_journal();
assert!(
runner.idle_cycle_sleep.is_some(),
"byte-identical repaints must keep the park"
);
let journal = runner
.bus
.suspend_write_probe()
.expect("the park's journal must still be armed");
runner.bus.resume_write_probe(journal);
assert!(runner.bus.finish_write_probe_unchanged());
}
#[test]
fn host_snapshot_tracks_window_list_and_pending_native_menu_selection() {
let mut runner = FixtureRunner::new(1024 * 1024, FixtureRunnerConfig::default());
let before = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.window_list.push(0x0012_3456);
assert_ne!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
runner.dispatcher.window_list.pop();
assert_eq!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
runner
.dispatcher
.pending_native_menu_selection
.stage((3, 1));
assert_ne!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
}
#[test]
fn volume_query_idle_proof_tracks_working_directory_changes() {
let runner = FixtureRunner::new(1024 * 1024, FixtureRunnerConfig::default());
let before = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.app_wd_refnum.with_mut(|refnum| *refnum = -42);
assert_ne!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
let volume = crate::process_context::ProcessVfsVolumeRecord {
ref_num: -1, name: "Disk".into(), root_dir_id: 2, attributes: 0,
file_count: 1, allocation_block_count: 100, allocation_block_size: 4096,
clump_size: 4096, free_blocks: 50, bitmap_start: 3, allocation_pointer: 4,
allocation_start: 5, next_catalog_id: 17, created_date: 1, modified_date: 2,
};
runner.dispatcher.vfs_volumes.with_mut(|volumes| volumes.push(volume));
let mounted = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.vfs_volumes.with_mut(|volumes| volumes[0].free_blocks -= 1);
assert_ne!(mounted, IdleCycleHostSnapshot::capture(&runner.dispatcher));
assert!(idle_cycle_trap_is_journal_complete(0xA007, true, true, true, 0, false));
assert!(!idle_cycle_trap_is_journal_complete(0xA407, true, true, true, 0, false));
}
#[test]
fn port_idle_proof_tracks_quickdraw_host_state() {
let mut runner = FixtureRunner::new(1024 * 1024, FixtureRunnerConfig::default());
let before = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.qddone_seen_ports.insert(0x1234);
assert_ne!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
runner.dispatcher.qddone_seen_ports.clear();
runner.dispatcher.tx_size = 14;
assert_ne!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
}
#[test]
fn window_and_textedit_mutators_still_cancel_an_idle_probe() {
for opcode in [0xA918u16, 0xA91F, 0xA928, 0xA929, 0xA9D8, 0xA9D9, 0xA9DC] {
let mut runner = FixtureRunner::new(1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::A7, 0x0008_0000);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
runner.note_idle_cycle_trap_result(opcode, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(
runner.idle_cycle_probe.is_none(),
"{opcode:04X} must cancel the probe"
);
}
}
#[test]
fn teidle_inside_a_proof_parks_when_idle_and_fails_on_memory_when_it_blinks() {
for (blink_due, expect_park) in [(false, true), (true, false)] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
let sp = 0x0010_0000u32;
let te_handle = 0x0020_0000u32;
let te_rec = 0x0020_0100u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA975; runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(te_handle, te_rec);
runner.bus.write_word(te_rec + 0x20, 5); runner.bus.write_word(te_rec + 0x22, 5); runner.bus.write_word(te_rec + 0x24, 1); runner
.bus
.write_long(te_rec + 0x34, if blink_due { 60 } else { 100 }); runner.bus.write_word(te_rec + 0x38, 0); runner.bus.write_long(sp - 4, te_handle);
runner.m68k.cpu.write_reg(Register::A7, sp);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
let before = CpuArchitecturalSnapshot::capture(&runner.m68k.cpu.core);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.bus.write_long(sp - 4, te_handle);
let result =
runner
.dispatcher
.dispatch_dialog(true, 0x1DA, &mut runner.m68k.cpu, &mut runner.bus);
assert!(result.unwrap().is_ok());
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
runner.note_idle_cycle_trap_result(0xA9DA, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(runner.idle_cycle_probe.is_some(), "TEIdle is admitted");
assert_eq!(
before,
CpuArchitecturalSnapshot::capture(&runner.m68k.cpu.core),
"TEIdle must leave the architectural state as it found it"
);
assert_eq!(runner.bus.read_word(te_rec + 0x38), u16::from(blink_due));
let parked = runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105));
assert_eq!(parked, expect_park, "blink_due={blink_due}");
assert_eq!(runner.idle_cycle_sleep.is_some(), expect_park);
}
}
#[test]
fn poll_anchor_covers_the_input_family_only() {
for opcode in [0xA972u16, 0xA973, 0xA974, 0xA975, 0xA976, 0xAD76] {
assert!(is_poll_anchor_trap(opcode), "{opcode:04X}");
}
for opcode in [0xA970u16, 0xA971, 0xA991, 0xA9EB, 0xA893, 0x4E71] {
assert!(!is_poll_anchor_trap(opcode), "{opcode:04X}");
}
}
#[test]
fn input_poll_cycle_proves_and_parks_like_a_null_event_cycle() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
let sp = 0x0010_0000u32;
let keymap = 0x0020_0000u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA976;
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(keymap, 0);
runner.bus.write_long(keymap + 16, 0x0001_0000);
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(105)));
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
runner.bus.write_long(keymap, 0);
runner.note_idle_cycle_trap_result(0xA976, runner.m68k.cpu.read_reg(Register::D0), false);
runner.note_idle_cycle_trap_result(0xA974, runner.m68k.cpu.read_reg(Register::D0), false);
runner.note_idle_cycle_trap_result(0xA975, runner.m68k.cpu.read_reg(Register::D0), false);
runner.bus.write_long(keymap + 16, 0x0001_0000);
runner.bus.write_long(keymap + 16, 0x0001_0000);
runner.note_idle_cycle_trap_result(0xA9EB, runner.m68k.cpu.read_reg(Register::D0), false);
assert!(
runner.idle_cycle_probe.is_some(),
"cycle traps kept the probe"
);
assert!(runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)));
assert_eq!(runner.guest_tick(), 100);
assert!(runner.idle_cycle_sleep.is_some());
}
#[test]
fn period_two_poll_cycle_proves_and_advances() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
let set_d5 = |runner: &mut FixtureRunner, v: u32| runner.m68k.cpu.core.set_d(5, v);
set_d5(&mut runner, 0x39);
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)));
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)));
assert!(
runner.idle_cycle_probe.is_some(),
"probe armed at 0x39 state"
);
set_d5(&mut runner, 0x2C);
assert!(
!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)),
"mid-period arrival must not prove"
);
assert!(
runner.idle_cycle_probe.is_some(),
"mid-period arrival must keep the probe alive"
);
set_d5(&mut runner, 0x39);
assert!(
runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)),
"origin state closes the period-2 proof and parks at the cap"
);
assert!(runner.idle_cycle_sleep.is_some());
}
#[test]
fn aperiodic_state_walk_never_proves() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
for step in 0..24u32 {
runner.m68k.cpu.core.set_d(5, 0x1000 + step);
assert!(
!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)),
"step {step} must not prove"
);
}
assert!(runner.idle_cycle_sleep.is_none());
}
#[test]
fn cycle_longer_than_period_cap_never_proves() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.core.set_d(5, 0);
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)));
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)));
for state in 1..=IDLE_CYCLE_MAX_PERIOD {
runner.m68k.cpu.core.set_d(5, u32::from(state));
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)));
}
runner.m68k.cpu.core.set_d(5, 0);
assert!(!runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)));
assert!(runner.idle_cycle_sleep.is_none());
}
#[test]
fn exact_null_event_cycle_supports_alternating_sites_headlessly() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let site_a = 0x0002_0000u32;
let site_b = 0x0002_1000u32;
runner.m68k.cpu.write_reg(Register::PC, site_a + 2);
runner.m68k.cpu.core.ppc = site_a;
runner.m68k.cpu.core.ir = 0xA970;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_null_event_cycle_fastfwd(site_a, None));
assert!(!runner.try_exact_null_event_cycle_fastfwd(site_b, None));
assert_eq!(runner.idle_cycle_last_seen, Some((site_a, 100)));
assert!(!runner.try_exact_null_event_cycle_fastfwd(site_a, None));
assert!(runner.idle_cycle_probe.is_some());
assert!(!runner.try_exact_null_event_cycle_fastfwd(site_b, None));
assert!(runner.idle_cycle_probe.is_some());
assert!(!runner.try_exact_null_event_cycle_fastfwd(site_a, None));
assert_eq!(runner.guest_tick(), 101);
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.idle_cycle_sleep.is_none());
}
#[test]
fn exact_idle_cycle_rejects_an_architectural_cpu_change() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA970;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(100)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(100)));
assert!(runner.idle_cycle_probe.is_some());
runner.m68k.cpu.write_reg(Register::D3, 1);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(100)));
assert_eq!(runner.guest_tick(), 100);
assert!(runner.idle_cycle_sleep.is_none());
assert!(
runner.idle_cycle_probe.is_some(),
"a changed state may start a new observation but must not reuse the old proof"
);
}
#[test]
fn exact_null_event_cycle_covers_the_complete_guest_state_machine() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let event = 0x0020_0000u32;
let delay_base = 0x0021_0000u32;
let tick_base = 0x0022_0000u32;
let flag_base = 0x0023_0000u32;
let stack = 0x0010_0000u32;
for (offset, word) in [
(0, 0x554F),
(2, 0x3F3C),
(4, 0xFFFF),
(6, 0x4879),
(8, (event >> 16) as u16),
(10, event as u16),
(12, 0xA970),
(14, 0x4A5F),
(16, 0x4879),
(18, ((event + 10) >> 16) as u16),
(20, (event + 10) as u16),
(22, 0xA871),
(24, 0xA9B4),
(26, 0x594F),
(28, 0xA975),
(30, 0x3028),
(32, 16),
(34, 0x48C0),
(36, 0xD0A9),
(38, 32),
(40, 0xB09F),
(42, 0x5DC0),
(44, 0x4A6A),
(46, 48),
(48, 0x56C1),
(50, 0x8001),
(52, 0x6700),
(54, 0xFFCA),
] {
runner.bus.write_word(code + offset, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, stack);
runner.m68k.cpu.write_reg(Register::A0, delay_base);
runner.m68k.cpu.write_reg(Register::A1, tick_base);
runner.m68k.cpu.write_reg(Register::A2, flag_base);
runner.m68k.cpu.write_reg(Register::D0, 0);
runner.m68k.cpu.write_reg(Register::D1, 0);
runner.bus.write_word(delay_base + 16, 5);
runner.bus.write_long(tick_base + 32, 100);
runner.bus.write_word(flag_base + 48, 0);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
let (_, running) = runner.run_steps_internal(
1_000,
Some(100),
0,
true,
false,
FrameFinalization::Deferred,
);
assert!(running);
let sleep = runner
.idle_cycle_sleep
.as_ref()
.expect("the complete null-event state machine should prove an identity cycle");
assert_eq!(sleep.trap_pc, code + 12);
assert_eq!(sleep.wake_tick, 101);
assert!(!runner.try_resume_proven_idle_cycle(Some(101)));
assert_eq!(runner.guest_tick(), 101);
assert!(runner.idle_cycle_sleep.is_none());
assert_eq!(runner.m68k.cpu.core.pc, code + 14);
}
#[test]
fn proven_idle_cycle_stops_sleeping_at_its_known_dependency() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
let sp = 0x0010_0000u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA975;
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.park_proven_idle_cycle(trap_pc, 103);
assert!(!runner.try_resume_proven_idle_cycle(Some(110)));
assert_eq!(runner.guest_tick(), 103);
assert!(runner.idle_cycle_sleep.is_none());
assert!(runner.bus.fast_mem_window().is_some());
}
#[test]
fn exact_idle_cycle_rejects_changed_memory_and_non_quiescent_traps() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
let scratch = 0x0020_0000u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA975;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
runner.bus.write_byte(scratch, 1);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert_eq!(runner.guest_tick(), 100);
runner.m68k.cpu.write_reg(Register::D0, 0x0004_0001); runner.note_idle_cycle_trap_result(0xAB1D, runner.m68k.cpu.read_reg(Register::D0), false); assert!(runner.idle_cycle_probe.is_none());
assert!(runner.idle_cycle_last_seen.is_none());
assert!(runner.bus.fast_mem_window().is_some());
}
#[test]
fn ordinary_tick_advance_cancels_an_exact_idle_cycle_probe() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000u32;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 200, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
runner.advance_guest_tick();
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.idle_cycle_last_seen.is_none());
assert!(runner.bus.fast_mem_window().is_some());
}
#[test]
fn spin_fastfwd_template_f_saved_register_beq_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x598F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x201F);
runner.bus.write_word(base + 6, 0xBE80);
runner.bus.write_word(base + 8, 0x67F6);
runner.bus.write_word(base + 10, 0x4E71);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D7, 100);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.bus.write_long(sp - 4, 100);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 101);
assert_eq!(runner.bus.read_long(sp - 4), 101);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(count, 0, "post-trap body remains for exact CPU execution");
for _ in 0..3 {
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
}
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 101);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 10);
}
fn saved_register_deadline_wait(tick: u32, deadline: u32) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
for (offset, word) in [0x594F, 0xA975, 0x201F, 0xBA80, 0x62F6, 0x4E71]
.into_iter()
.enumerate()
{
runner.bus.write_word(base + offset as u32 * 2, word);
}
runner.bus.write_long(0x016A, tick);
runner.set_guest_tick_for_test(tick);
runner.m68k.cpu.write_reg(Register::D0, 0xDEAD_BEEF);
runner.m68k.cpu.write_reg(Register::D5, deadline);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.bus.write_long(0x0010_0000, tick);
runner
}
#[test]
fn spin_fastfwd_saved_register_deadline_preserves_cpu_exit_state() {
for preamble in [0x594F, 0x598F] {
for (tick, deadline) in [(100, 101), (100, 107), (0x7FFF_FFFE, 0x8000_0001)] {
let mut runner = saved_register_deadline_wait(tick, deadline);
runner.bus.write_word(0x0001_0000, preamble);
let mut count = 0;
assert!(!runner.try_tickcount_spin_fastfwd(0x0001_0004, None, &mut count));
assert_eq!(runner.guest_tick(), deadline);
assert_eq!(runner.bus.read_long(0x0010_0000), deadline);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 0xDEAD_BEEF);
assert_eq!(runner.m68k.cpu.read_reg(Register::D5), deadline);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), 0x0010_0000);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), 0x0001_0004);
assert_eq!(count, 0);
for _ in 0..3 {
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
}
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), deadline);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), 0x0010_0004);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), 0x0001_000A);
assert_eq!(runner.m68k.cpu.core.get_sr() & 0x0F, 4);
}
}
}
#[test]
fn spin_fastfwd_saved_register_deadline_rejects_expired_or_unsafe_loops() {
for (tick, deadline) in [(100, 100), (101, 100), (u32::MAX, 0), (100, 1_000_101)] {
let mut runner = saved_register_deadline_wait(tick, deadline);
let mut count = 0;
assert!(!runner.try_tickcount_spin_fastfwd(0x0001_0004, None, &mut count));
assert_eq!(runner.guest_tick(), tick);
assert_eq!(runner.bus.read_long(0x0010_0000), tick);
assert_eq!(count, 0);
}
for (address, replacement) in [
(0x0001_0000, 0x4E71), (0x0001_0002, 0xA976), (0x0001_0006, 0xB080), (0x0001_0008, 0x62F4), (0x0001_0008, 0x6200), (0x0001_0008, 0x6EF6), ] {
let mut runner = saved_register_deadline_wait(100, 105);
runner.bus.write_word(address, replacement);
runner.m68k.cpu.write_reg(Register::D0, 105);
let mut count = 0;
assert!(!runner.try_tickcount_spin_fastfwd(0x0001_0004, None, &mut count));
assert_eq!(runner.guest_tick(), 100);
assert_eq!(runner.bus.read_long(0x0010_0000), 100);
assert_eq!(count, 0);
}
let mut runner = saved_register_deadline_wait(100, 105);
runner.bus.write_word(0x0001_0006, 0xB080);
runner.bus.write_word(0x0001_0008, 0x67F6);
runner.m68k.cpu.write_reg(Register::D0, 100);
let mut count = 0;
assert!(!runner.try_tickcount_spin_fastfwd(0x0001_0004, None, &mut count));
assert_eq!(
runner.guest_tick(),
100,
"CMP D0,D0; BEQ cannot become unequal"
);
}
#[test]
fn spin_fastfwd_saved_register_deadline_honors_gui_cap_and_vbl_callbacks() {
let mut runner = saved_register_deadline_wait(100, 105);
runner.set_instructions_per_tick(1_000);
runner.tick_budget = 777;
let mut count = 0;
assert!(runner.try_tickcount_spin_fastfwd(0x0001_0004, Some(102), &mut count));
assert_eq!(runner.guest_tick(), 102);
assert_eq!(runner.bus.read_long(0x0010_0000), 102);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), 0x0001_0004);
assert_eq!(runner.tick_budget, 1_000);
assert_eq!(count, 0);
let mut runner = saved_register_deadline_wait(100, 105);
runner.m68k.cpu.core.set_sr_noint_nosp(0x2000);
let task = 0x0020_2000;
runner.bus.write_word(task + 4, 1);
runner.bus.write_long(task + 6, 0x0004_1234);
runner.bus.write_word(task + 10, 1);
runner.bus.write_word(task + 12, 0);
runner.dispatcher.vbl_tasks.push(VblTask {
task_ptr: task,
architecture: CallbackTaskArchitecture::M68k,
slot: None,
pending: false,
});
assert!(!runner.try_tickcount_spin_fastfwd(0x0001_0004, None, &mut count));
assert_eq!(runner.guest_tick(), 101);
assert_eq!(runner.bus.read_long(0x0010_0000), 100);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 0xDEAD_BEEF);
assert_eq!(
runner.m68k.cpu.read_reg(Register::PC),
runner.vbl_trampoline
);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), 0x000F_FFFC);
assert_eq!(runner.bus.read_long(0x000F_FFFC), 0x0001_0004);
let active = runner
.active_interrupt_callback
.expect("VBL callback pending");
assert!(matches!(active.source, ActiveInterruptCallbackSource::Vbl));
assert_eq!(active.resume_pc, 0x0001_0004);
assert_eq!(active.resume_sp, 0x0010_0000);
}
#[test]
fn spin_fastfwd_template_f_rejects_stateful_branch_target() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x52B8);
runner.bus.write_word(base + 2, 0x0002);
runner.bus.write_word(base + 4, 0x594F);
runner.bus.write_word(base + 6, 0xA975);
runner.bus.write_word(base + 8, 0x201F);
runner.bus.write_word(base + 10, 0xBE80);
runner.bus.write_word(base + 12, 0x67F2);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D7, 100);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.bus.write_long(sp - 4, 100);
let mut count = 0usize;
runner.try_tickcount_spin_fastfwd(base + 8, None, &mut count);
assert_eq!(runner.guest_tick(), 100);
assert_eq!(runner.bus.read_long(sp - 4), 100);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(count, 0);
}
#[test]
fn spin_fastfwd_template_g_elapsed_frame_local_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let a5 = 0x0001_8000u32;
let a6 = 0x0010_1000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x598F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x201F);
runner.bus.write_word(base + 6, 0x2D40);
runner.bus.write_word(base + 8, 0xFFFC);
runner.bus.write_word(base + 10, 0x202E);
runner.bus.write_word(base + 12, 0xFFFC);
runner.bus.write_word(base + 14, 0x90AD);
runner.bus.write_word(base + 16, 0xFFDC);
runner.bus.write_word(base + 18, 0x306E);
runner.bus.write_word(base + 20, 0x0008);
runner.bus.write_word(base + 22, 0xB1C0);
runner.bus.write_word(base + 24, 0x6EE6);
runner.bus.write_word(base + 26, 0x4E71);
runner.bus.write_long(a5 - 36, 400);
runner.bus.write_word(a6 + 8, 5);
runner.bus.write_long(0x016A, 401);
runner.set_guest_tick_for_test(401);
runner.m68k.cpu.write_reg(Register::A5, a5);
runner.m68k.cpu.write_reg(Register::A6, a6);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.bus.write_long(sp - 4, 401);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 405);
assert_eq!(runner.bus.read_long(sp - 4), 405);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(count, 0, "post-trap body remains for exact CPU execution");
for _ in 0..7 {
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
}
assert_eq!(runner.bus.read_long(a6 - 4), 405);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 5);
assert_eq!(runner.m68k.cpu.read_reg(Register::A0), 5);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 26);
}
#[test]
fn spin_fastfwd_template_a_advances_ticks_and_skips_loop() {
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, 0x201F);
runner.bus.write_word(base + 6, 0x5380);
runner.bus.write_word(base + 8, 0xB680);
runner.bus.write_word(base + 10, 0x62F4);
runner.bus.write_word(base + 12, 0x4E71);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D3, 500);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let pc_after_trap = base + 4;
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(pc_after_trap, None, &mut count);
assert!(!hit_cap, "no tick_cap was set, cap should not trip");
assert_eq!(runner.guest_tick(), 501, "advanced to D3+imm");
assert_eq!(runner.bus.read_long(0x016A), 501, "bus $016A in sync");
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 500);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), 0x0010_0004);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 12);
assert_eq!(count, 4);
}
#[test]
fn spin_fastfwd_refills_instruction_budget_at_each_elapsed_guest_tick() {
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, 0x201F);
runner.bus.write_word(base + 6, 0x5380);
runner.bus.write_word(base + 8, 0xB680);
runner.bus.write_word(base + 10, 0x62F4);
runner.bus.write_word(base + 12, 0x4E71);
runner.set_instructions_per_tick(1_000);
runner.tick_budget = 777;
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D3, 500);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 501);
assert_eq!(runner.tick_budget, 1_000);
}
#[test]
fn spin_fastfwd_rejects_register_mismatch() {
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, 0x221F); runner.bus.write_word(base + 6, 0x5380); runner.bus.write_word(base + 8, 0xB680); runner.bus.write_word(base + 10, 0x62F4);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D3, 500);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let pc_after_trap = base + 4;
let mut count = 0usize;
runner.try_tickcount_spin_fastfwd(pc_after_trap, None, &mut count);
assert_eq!(runner.guest_tick(), 100);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), 0);
assert_eq!(count, 0);
}
#[test]
fn spin_fastfwd_template_b_memory_target_variant() {
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, 0x201F);
runner.bus.write_word(base + 6, 0xB0AE);
runner.bus.write_word(base + 8, 0xFFFC);
runner.bus.write_word(base + 10, 0x63F4);
runner.bus.write_word(base + 12, 0x4E71);
let a6 = 0x0010_1000u32;
runner.bus.write_long(a6.wrapping_sub(4), 400);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A6, a6);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let pc_after_trap = base + 4;
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(pc_after_trap, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 401);
assert_eq!(runner.bus.read_long(0x016A), 401);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 401);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), 0x0010_0004);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 12);
assert_eq!(count, 3);
}
#[test]
fn spin_fastfwd_template_b_rejects_stateful_pretrap_body() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let counter = 0x0001_8000u32;
let a6 = 0x0001_9000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x52B0);
runner.bus.write_word(base + 2, 0x3C00);
runner.bus.write_word(base + 4, 0x594F);
runner.bus.write_word(base + 6, 0xA975);
runner.bus.write_word(base + 8, 0x201F);
runner.bus.write_word(base + 10, 0xB0AE);
runner.bus.write_word(base + 12, 0xFFFC);
runner.bus.write_word(base + 14, 0x63F0);
runner.bus.write_word(base + 16, 0x4E71);
runner.bus.write_long(counter, 7);
runner.bus.write_long(a6 - 4, 400);
runner.bus.write_long(0x016A, 100);
runner.bus.write_long(sp, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A0, counter);
runner.m68k.cpu.write_reg(Register::D3, 0);
runner.m68k.cpu.write_reg(Register::A6, a6);
runner.m68k.cpu.write_reg(Register::A7, sp);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 8, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 100);
assert_eq!(runner.bus.read_long(counter), 7);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), 0);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
assert_eq!(count, 0);
}
#[test]
fn spin_fastfwd_template_b_signed_ble_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let a5 = 0x0001_8000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x201F);
runner.bus.write_word(base + 6, 0xB0AD);
runner.bus.write_word(base + 8, 0xFFF0);
runner.bus.write_word(base + 10, 0x6FF4);
runner.bus.write_word(base + 12, 0x4E71);
runner.bus.write_long(a5 - 16, 400);
runner.bus.write_long(0x016A, 100);
runner.bus.write_long(sp, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A5, a5);
runner.m68k.cpu.write_reg(Register::A7, sp);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 401);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 401);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 12);
assert_eq!(count, 3);
}
#[test]
fn spin_fastfwd_template_b_signed_blt_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let a5 = 0x0001_8000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x201F);
runner.bus.write_word(base + 6, 0xB0AD);
runner.bus.write_word(base + 8, 0xFFF0);
runner.bus.write_word(base + 10, 0x6DF4);
runner.bus.write_word(base + 12, 0x4E71);
runner.bus.write_long(a5 - 16, 400);
runner.bus.write_long(0x016A, 100);
runner.bus.write_long(sp, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A5, a5);
runner.m68k.cpu.write_reg(Register::A7, sp);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 400);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 400);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 12);
assert_eq!(count, 3);
}
#[test]
fn spin_fastfwd_template_b_signed_ble_rejects_overflow_target() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let a5 = 0x0001_8000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x201F);
runner.bus.write_word(base + 6, 0xB0AD);
runner.bus.write_word(base + 8, 0xFFF0);
runner.bus.write_word(base + 10, 0x6FF4);
runner.bus.write_long(a5 - 16, i32::MAX as u32);
runner.bus.write_long(0x016A, 100);
runner.bus.write_long(sp, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A5, a5);
runner.m68k.cpu.write_reg(Register::A7, sp);
let mut count = 0usize;
runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert_eq!(runner.guest_tick(), 100);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), 0);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
assert_eq!(count, 0);
}
#[test]
fn spin_fastfwd_template_c_absolute_long_target_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let target_addr = 0x0002_FE44u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x201F);
runner.bus.write_word(base + 6, 0xB0B9);
runner.bus.write_long(base + 8, target_addr);
runner.bus.write_word(base + 12, 0x65F2);
runner.bus.write_word(base + 14, 0x4E71);
runner.bus.write_long(target_addr, 400);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let pc_after_trap = base + 4;
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(pc_after_trap, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 400);
assert_eq!(runner.bus.read_long(0x016A), 400);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 400);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), 0x0010_0004);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 14);
assert_eq!(count, 3);
}
#[test]
fn spin_fastfwd_template_e_computed_signed_deadline_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let a5 = 0x0001_8000u32;
let a6 = 0x0010_1000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x302E);
runner.bus.write_word(base + 6, 0xFFFE);
runner.bus.write_word(base + 8, 0x48C0);
runner.bus.write_word(base + 10, 0xD0AD);
runner.bus.write_word(base + 12, 0xFFF0);
runner.bus.write_word(base + 14, 0xB09F);
runner.bus.write_word(base + 16, 0x6EEE);
runner.bus.write_word(base + 18, 0x4E71);
runner.bus.write_word(a6 - 2, 5);
runner.bus.write_long(a5 - 16, 400);
runner.bus.write_long(0x016A, 100);
runner.bus.write_long(sp - 4, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A5, a5);
runner.m68k.cpu.write_reg(Register::A6, a6);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 405);
assert_eq!(runner.bus.read_long(sp - 4), 405);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(count, 0, "post-trap body remains for exact CPU execution");
for _ in 0..5 {
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
}
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 405);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 18);
}
#[test]
fn spin_fastfwd_template_e_computed_signed_deadline_inclusive_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let a5 = 0x0001_8000u32;
let a6 = 0x0010_1000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x302E);
runner.bus.write_word(base + 6, 0xFFFE);
runner.bus.write_word(base + 8, 0x48C0);
runner.bus.write_word(base + 10, 0xD0AD);
runner.bus.write_word(base + 12, 0xFFF0);
runner.bus.write_word(base + 14, 0xB09F);
runner.bus.write_word(base + 16, 0x6CEE);
runner.bus.write_word(base + 18, 0x4E71);
runner.bus.write_word(a6 - 2, 5);
runner.bus.write_long(a5 - 16, 400);
runner.bus.write_long(0x016A, 100);
runner.bus.write_long(sp - 4, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A5, a5);
runner.m68k.cpu.write_reg(Register::A6, a6);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 406);
assert_eq!(runner.bus.read_long(sp - 4), 406);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(count, 0, "post-trap body remains for exact CPU execution");
for _ in 0..5 {
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
}
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 405);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 18);
}
#[test]
fn spin_fastfwd_template_e_rejects_inclusive_signed_overflow() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let a5 = 0x0001_8000u32;
let a6 = 0x0010_1000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x302E);
runner.bus.write_word(base + 6, 0xFFFE);
runner.bus.write_word(base + 8, 0x48C0);
runner.bus.write_word(base + 10, 0xD0AD);
runner.bus.write_word(base + 12, 0xFFF0);
runner.bus.write_word(base + 14, 0xB09F);
runner.bus.write_word(base + 16, 0x6CEE);
runner.bus.write_word(a6 - 2, 0);
runner.bus.write_long(a5 - 16, i32::MAX as u32);
runner.bus.write_long(0x016A, 100);
runner.bus.write_long(sp - 4, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A5, a5);
runner.m68k.cpu.write_reg(Register::A6, a6);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 100);
assert_eq!(runner.bus.read_long(sp - 4), 100);
assert_eq!(count, 0);
}
#[test]
fn spin_fastfwd_template_e_rejects_mismatched_extension_register() {
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, 0x302E); runner.bus.write_word(base + 6, 0xFFFE);
runner.bus.write_word(base + 8, 0x48C1); runner.bus.write_word(base + 10, 0xD0AD);
runner.bus.write_word(base + 12, 0xFFF0);
runner.bus.write_word(base + 14, 0xB09F);
runner.bus.write_word(base + 16, 0x6EEE);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
let mut count = 0usize;
runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert_eq!(runner.guest_tick(), 100);
assert_eq!(count, 0);
}
#[test]
fn spin_fastfwd_template_d_bcc_stack_compare_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x42A7);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0xBE9F);
runner.bus.write_word(base + 6, 0x64F8);
runner.bus.write_word(base + 8, 0x4E71);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D7, 500);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.bus.write_long(sp - 4, 100);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 501);
assert_eq!(runner.bus.read_long(sp - 4), 501);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(count, 0, "CMP/BCC remain for exact CPU execution");
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 8);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
}
#[test]
fn spin_fastfwd_template_d_lemmings_beq_variant() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x42A7);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0xBE9F);
runner.bus.write_word(base + 6, 0x67F8);
runner.bus.write_word(base + 8, 0x4E71);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D7, 100);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.bus.write_long(sp - 4, 100);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 101);
assert_eq!(runner.bus.read_long(sp - 4), 101);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(count, 0, "CMP/BEQ remain for exact CPU execution");
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
assert!(matches!(
runner.m68k.cpu.step(&mut runner.bus),
crate::cpu::StepResult::Ok
));
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 8);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
}
#[test]
fn spin_fastfwd_template_d_beq_does_not_advance_after_tick_changed() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x42A7);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0xBE9F);
runner.bus.write_word(base + 6, 0x67F8);
runner.bus.write_long(0x016A, 101);
runner.set_guest_tick_for_test(101);
runner.m68k.cpu.write_reg(Register::D7, 100);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.bus.write_long(sp - 4, 101);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 101);
assert_eq!(runner.bus.read_long(sp - 4), 101);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(count, 0);
}
#[test]
fn spin_fastfwd_template_d_honors_gui_tick_cap() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x42A7);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0xBE9F);
runner.bus.write_word(base + 6, 0x64F8);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(1_000);
runner.tick_budget = 777;
runner.m68k.cpu.write_reg(Register::D7, 500);
runner.m68k.cpu.write_reg(Register::A7, sp - 4);
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.bus.write_long(sp - 4, 100);
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, Some(102), &mut count);
assert!(hit_cap);
assert_eq!(runner.guest_tick(), 102);
assert_eq!(runner.bus.read_long(sp - 4), 102);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 4);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(
runner.tick_budget,
runner.instructions_per_tick() as i32,
"a capped synthetic boundary must leave a fresh tick budget"
);
}
#[test]
fn spin_fastfwd_leaves_interrupt_callback_state_unsynthesized() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let target_addr = 0x0002_FE44u32;
let task_ptr = 0x0020_2000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0x594F);
runner.bus.write_word(base + 2, 0xA975);
runner.bus.write_word(base + 4, 0x201F);
runner.bus.write_word(base + 6, 0xB0B9);
runner.bus.write_long(base + 8, target_addr);
runner.bus.write_word(base + 12, 0x65F2);
runner.bus.write_word(base + 14, 0x4E71);
runner.bus.write_long(target_addr, 400);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(1_000);
runner.tick_budget = 777;
runner.m68k.cpu.write_reg(Register::PC, base + 4);
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.m68k.cpu.write_reg(Register::D0, 0xDEAD_BEEF);
runner.m68k.cpu.core.set_sr_noint_nosp(0x2000);
runner.bus.write_long(sp, 100);
runner.bus.write_word(task_ptr + 4, 1);
runner.bus.write_long(task_ptr + 6, 0x0004_1234);
runner.bus.write_word(task_ptr + 10, 1);
runner.bus.write_word(task_ptr + 12, 0);
runner.dispatcher.vbl_tasks.push(VblTask {
task_ptr,
architecture: CallbackTaskArchitecture::M68k,
slot: None,
pending: false,
});
let mut count = 0usize;
let hit_cap = runner.try_tickcount_spin_fastfwd(base + 4, None, &mut count);
assert!(!hit_cap);
assert_eq!(runner.guest_tick(), 101);
assert_eq!(runner.bus.read_long(0x016A), 101);
assert_eq!(count, 0);
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 0xDEAD_BEEF);
assert_eq!(
runner.m68k.cpu.read_reg(Register::PC),
runner.vbl_trampoline
);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp - 4);
assert_eq!(runner.bus.read_long(sp - 4), base + 4);
assert_eq!(
runner.tick_budget,
runner.instructions_per_tick() as i32,
"an interrupted synthetic boundary must leave a fresh tick budget"
);
let active = runner
.active_interrupt_callback
.expect("VBL callback should remain active for normal resume handling");
assert!(matches!(active.source, ActiveInterruptCallbackSource::Vbl));
assert_eq!(active.resume_pc, base + 4);
assert_eq!(active.resume_sp, sp);
}
#[test]
fn spin_fastfwd_gate_defaults_on_with_gui_cadence_guarded_by_tick_cap() {
assert!(spin_wait_fastfwd_gate(false, false, false, false));
assert!(spin_wait_fastfwd_gate(false, false, false, true));
assert!(spin_wait_fastfwd_gate(false, false, true, true));
assert!(!spin_wait_fastfwd_gate(false, false, true, false));
}
#[test]
fn spin_fastfwd_gate_force_off_wins() {
assert!(!spin_wait_fastfwd_gate(false, true, false, false));
assert!(!spin_wait_fastfwd_gate(false, true, true, true));
assert!(!spin_wait_fastfwd_gate(true, true, false, true));
assert!(!spin_wait_fastfwd_gate(true, true, true, false));
}
#[test]
fn spin_fastfwd_gate_force_on_remains_enabled() {
assert!(spin_wait_fastfwd_gate(true, false, false, false));
assert!(spin_wait_fastfwd_gate(true, false, true, false));
}
#[test]
fn menu_flash_uses_frontend_time_while_application_ticks_are_frozen() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let mut tracking = crate::menu_manager::test_process_menu_tracking(128);
tracking.set_flash_tick(100);
tracking.begin_flash(3, 0x0080_0002);
runner.process_context.set_menu_tracking(Some(tracking));
runner.frozen_ticks = Some(100);
runner.advance_menu_presentation_clock(std::time::Duration::from_millis(300));
runner.run_steps_internal(0, Some(102), 0, true, false, FrameFinalization::Deferred);
assert_eq!(runner.frozen_ticks, Some(100));
assert_eq!(
runner
.process_context
.with_menu_tracking_mut(|tracking| tracking.advance_flash())
.unwrap(),
crate::menu_manager::MenuFlashStep::Complete(0x0080_0002)
);
}
#[test]
fn tracking_refire_freeze_policy_keeps_dialog_ticks_live() {
assert!(tracking_refire_should_freeze_ticks(0xA93D));
assert!(tracking_refire_should_freeze_ticks(0xAD3D));
assert!(tracking_refire_should_freeze_ticks(0xA80B));
assert!(tracking_refire_should_freeze_ticks(0xAC0B));
assert!(tracking_refire_should_freeze_ticks(0xA968));
assert!(tracking_refire_should_freeze_ticks(0xAD68));
assert!(tracking_refire_should_freeze_ticks(0xA91E));
assert!(tracking_refire_should_freeze_ticks(0xAD1E));
assert!(tracking_refire_should_freeze_ticks(0xA925));
assert!(tracking_refire_should_freeze_ticks(0xAD25));
assert!(tracking_refire_should_freeze_ticks(0xA905));
assert!(tracking_refire_should_freeze_ticks(0xAD05));
assert!(tracking_refire_should_freeze_ticks(0xA926));
assert!(tracking_refire_should_freeze_ticks(0xAD26));
assert!(!tracking_refire_should_freeze_ticks(0xA991));
assert!(!tracking_refire_should_freeze_ticks(0xAD91));
assert!(tracking_refire_uses_dialog_callbacks(0xA991));
assert!(!tracking_refire_uses_dialog_callbacks(0xA9EA));
assert!(tracking_refire_advances_gui_idle_tick(0xA991));
for alert in [0xA985, 0xA986, 0xA987, 0xA988] {
assert!(!tracking_refire_should_freeze_ticks(alert));
assert!(tracking_refire_uses_dialog_callbacks(alert));
assert!(tracking_refire_advances_gui_idle_tick(alert));
assert!(tracking_refire_advances_gui_idle_tick(alert | 0x0400));
}
assert!(tracking_refire_advances_gui_idle_tick(0xA9EA));
}
#[test]
fn trackcontrol_refire_allows_guest_scrollbar_callback_to_execute() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0001_0000u32;
let sp = 0x0010_0000u32;
let marker = runner.bus.alloc(2);
let action_proc = runner.bus.alloc(12);
let ctrl_ptr = runner.bus.alloc(40);
let ctrl_handle = runner.bus.alloc(4);
runner.bus.write_word(trap_pc, 0xA968); runner.bus.write_word(action_proc, 0x33FC); runner.bus.write_word(action_proc + 2, 0x7A5A);
runner.bus.write_long(action_proc + 4, marker);
runner.bus.write_word(action_proc + 8, 0x4E74); runner.bus.write_word(action_proc + 10, 6);
runner.bus.write_long(ctrl_handle, ctrl_ptr);
runner.bus.write_word(ctrl_ptr + 8, 60);
runner.bus.write_word(ctrl_ptr + 10, 240);
runner.bus.write_word(ctrl_ptr + 12, 220);
runner.bus.write_word(ctrl_ptr + 14, 256);
runner.bus.write_byte(ctrl_ptr + 16, 0xFF);
runner.bus.write_word(ctrl_ptr + 18, 40);
runner.bus.write_word(ctrl_ptr + 20, 0);
runner.bus.write_word(ctrl_ptr + 22, 100);
runner.dispatcher.control_manager.set_proc_id(ctrl_ptr, 16);
runner
.dispatcher
.input_state
.set_mouse_button_for_test(true);
runner
.dispatcher
.input_state
.set_mouse_position_for_test((210, 248));
runner.bus.write_long(sp, action_proc);
runner.bus.write_word(sp + 4, 210);
runner.bus.write_word(sp + 6, 248);
runner.bus.write_long(sp + 8, ctrl_handle);
runner.bus.write_word(sp + 12, 0xBEEF);
runner.m68k.cpu.write_reg(Register::PC, trap_pc);
runner.m68k.cpu.write_reg(Register::A7, sp);
let (_steps, running) = runner.run_steps(20, None);
assert!(running);
assert_eq!(runner.bus.read_word(marker), 0x7A5A);
assert!(runner.dispatcher.is_control_tracking());
assert!(!runner.dispatcher.is_control_action_callback_pending());
}
#[test]
fn standard_file_refires_yield_before_unrelated_modeless_callbacks() {
for (selector, pop_total) in [(0x0002u16, 28u32), (0x0006, 16)] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
let reply_ptr = runner.bus.alloc(80);
let proc_addr = 0x0001_1000u32;
runner.bus.write_word(base, 0xA9EA); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_word(sp, selector);
runner.bus.write_long(sp + 2, reply_ptr);
if selector == 0x0002 {
runner.bus.write_long(sp + 10, 0); runner.bus.write_word(sp + 14, 0); } else {
runner.bus.write_long(sp + 6, 0); runner.bus.write_word(sp + 10, 0); }
runner.bus.write_word(proc_addr, 0x4E56); runner
.dispatcher
.modeless_dialog_draw_proc_queue
.push_back((0, proc_addr, 1));
let (steps, running) = runner.run_gui_slice_with_audio(1, 0, 0);
assert!(running);
assert_eq!(steps, 1);
assert!(runner.dispatcher.is_standard_file_get_tracking());
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
assert!(runner.active_interrupt_callback.is_none());
assert_eq!(
runner.dispatcher.modeless_dialog_draw_proc_queue.len(),
1,
"selector ${selector:04X} must not consume another manager's callback"
);
let (idle_steps, idle_running) = runner.run_gui_slice_with_audio(16, 3, 0);
assert!(idle_running);
assert_eq!(idle_steps, 3);
assert_eq!(runner.guest_tick(), 3);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base);
runner.dispatcher.modeless_dialog_draw_proc_queue.clear();
runner
.process_context
.shared_event_queue()
.push_back(QueuedEvent {
what: 3,
message: 0x0000_351B, when: 0,
where_v: 0,
where_h: 0,
modifiers: 0,
});
let (cancel_steps, cancel_running) = runner.run_gui_slice_with_audio(1, 3, 0);
assert!(cancel_running);
assert_eq!(cancel_steps, 1);
assert!(!runner.dispatcher.is_standard_file_get_tracking());
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base + 2);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp + pop_total);
assert_eq!(runner.bus.read_byte(reply_ptr), 0);
}
}
#[test]
fn modal_dialog_refire_still_schedules_its_draw_callback() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
let proc_addr = 0x0001_1000u32;
runner.bus.write_word(base, 0xA991); runner.bus.write_word(proc_addr, 0x4E56); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
let mut tracking = dialog_tracking_for_test(0, 0);
tracking.draw_proc_queue.push_back((proc_addr, 1));
tracking.draw_procs_done = false;
tracking.rendered_pixels_final = false;
runner.dispatcher.dialog_tracking = Some(tracking);
let (steps, running) = runner.run_gui_slice_with_audio(1, 0, 0);
assert!(running);
assert_eq!(steps, 1);
assert!(matches!(
runner.active_interrupt_callback,
Some(ActiveInterruptCallback {
source: ActiveInterruptCallbackSource::DialogDrawProc,
..
})
));
assert_ne!(runner.m68k.cpu.read_reg(Register::PC), base);
}
#[test]
fn modal_dialog_refire_preserves_application_cdef_callback_redirection() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
let side_effect = 0x0001_2000u32;
let dialog_ptr = runner.bus.alloc(200);
let control_handle = runner.bus.alloc(4);
let control_ptr = runner.bus.alloc(36);
let cdef_handle = runner.bus.alloc(4);
let cdef_proc = runner.bus.alloc(20);
runner.bus.write_word(base, 0xA991); runner.bus.write_word(cdef_proc, 0x4E56); runner.bus.write_word(cdef_proc + 2, 0);
runner.bus.write_word(cdef_proc + 4, 0x33FC); runner.bus.write_word(cdef_proc + 6, 0xCAFE);
runner.bus.write_long(cdef_proc + 8, side_effect);
runner.bus.write_word(cdef_proc + 12, 0x4E5E); runner.bus.write_word(cdef_proc + 14, 0x4E74); runner.bus.write_word(cdef_proc + 16, 12);
runner.bus.write_long(cdef_handle, cdef_proc);
runner.dispatcher.init_cgraf_window(
&mut runner.bus,
&mut runner.m68k.cpu,
dialog_ptr,
0,
100,
120,
220,
360,
"",
2,
true,
false,
false,
0,
);
runner.dispatcher.front_window = dialog_ptr;
runner.dispatcher.window_bounds = (100, 120, 220, 360);
runner
.dispatcher
.dialog_items
.insert(dialog_ptr, Vec::new());
runner.bus.write_long(control_handle, control_ptr);
runner.bus.write_long(control_ptr, 0);
runner.bus.write_long(control_ptr + 4, dialog_ptr);
runner.bus.write_word(control_ptr + 8, 10);
runner.bus.write_word(control_ptr + 10, 10);
runner.bus.write_word(control_ptr + 12, 50);
runner.bus.write_word(control_ptr + 14, 80);
runner.bus.write_byte(control_ptr + 16, 255);
runner.bus.write_byte(control_ptr + 17, 0);
runner.bus.write_long(control_ptr + 24, cdef_handle);
runner.bus.write_long(dialog_ptr + 140, control_handle);
runner
.dispatcher
.control_manager
.register(control_handle, control_ptr, 160 << 4, 0);
let item_hit = runner.bus.alloc(2);
runner.bus.write_long(sp, item_hit);
runner.bus.write_long(sp + 4, 0);
runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
let (steps, running) = runner.run_gui_slice_with_audio(1, 0, 0);
assert!(running);
assert_eq!(steps, 1);
assert_eq!(
runner.m68k.cpu.read_reg(Register::PC),
runner.dispatcher.control_def_trampoline,
"ModalDialog must not replace the CDEF callback entry with its refire PC"
);
let (_steps, running) = runner.run_steps(64, None);
assert!(running);
assert_eq!(
runner.bus.read_word(side_effect),
0xCAFE,
"the application CDEF must execute before ModalDialog refires"
);
}
#[test]
fn tracking_refire_survives_async_callback_injection() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(base, 0xA991); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
let mut tracking = dialog_tracking_for_test(0, 0);
tracking.flash_remaining = 6;
tracking.flash_delay = 3;
runner.dispatcher.dialog_tracking = Some(tracking);
runner.active_interrupt_callback = Some(ActiveInterruptCallback {
source: ActiveInterruptCallbackSource::Timer,
resume_pc: base + 2,
resume_sp: sp,
d_regs: [0; 8],
a_regs: [0, 0, 0, 0, 0, 0, 0, sp],
sr: 0x2000,
ccr: 0,
restore_port: None,
});
let (steps, running) = runner.run_steps(2, None);
assert!(running);
assert_eq!(steps, 2);
assert!(
runner.active_interrupt_callback.is_none(),
"active={:?} deferred={:?} pc=${:08X} sp=${:08X}",
runner.active_interrupt_callback.map(|active| (
active.source,
active.resume_pc,
active.resume_sp
)),
runner.deferred_tracking_refire_pc,
runner.m68k.cpu.read_reg(Register::PC),
runner.m68k.cpu.read_reg(Register::A7),
);
assert!(runner.deferred_tracking_refire_pc.is_none());
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base);
}
#[test]
fn gui_modaldialog_idle_refire_advances_one_tick() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner.bus.write_word(base, 0xA991); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 0);
runner.set_guest_tick_for_test(0);
runner.set_instructions_per_tick(1_000_000);
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(0, 0));
let (steps, running) = runner.run_gui_slice_with_audio(1, 1, 0);
assert!(running);
assert_eq!(steps, 1);
assert_eq!(runner.guest_tick(), 1);
assert_eq!(runner.tick_budget, runner.instructions_per_tick() as i32);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base);
}
#[test]
fn time_driven_modal_wait_avoids_instruction_budget_refire_storm() {
fn modal_runner() -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.bus.write_word(0x10000, 0xA991);
runner.m68k.cpu.write_reg(Register::PC, 0x10000);
runner.m68k.cpu.write_reg(Register::A7, 0x100000);
runner.set_guest_tick_for_test(0);
runner.bus.write_long(0x016A, 0);
runner.set_instructions_per_tick(10_000);
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(0, 0));
runner
}
let mut diagnostic = modal_runner();
let mut timed = modal_runner();
let (diagnostic_steps, diagnostic_running) = diagnostic.run_steps(20_000, Some(2));
let (timed_steps, timed_running) = timed.run_gui_cpu_slice(20_000, 2);
assert!(diagnostic_running && timed_running);
assert_eq!(diagnostic.guest_tick(), 2);
assert_eq!(timed.guest_tick(), 2);
assert!(
diagnostic_steps > 1_000,
"legacy mode consumes synthetic refires"
);
assert_eq!(timed_steps, 2, "one idle refire per simulated tick");
for register in [Register::PC, Register::A7] {
assert_eq!(
diagnostic.m68k.cpu.read_reg(register),
timed.m68k.cpu.read_reg(register)
);
}
}
#[test]
fn gui_modaldialog_idle_refire_runs_until_tick_cap() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner.bus.write_word(base, 0xA991); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 0);
runner.set_guest_tick_for_test(0);
runner.set_instructions_per_tick(1_000_000);
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(0, 0));
let (steps, running) = runner.run_gui_slice_with_audio(16, 2, 0);
assert!(running);
assert_eq!(steps, 2);
assert_eq!(runner.guest_tick(), 2);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), base);
}
#[test]
fn gui_modaldialog_refire_unfreezes_prior_control_tracking() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
runner.bus.write_word(base, 0xA991); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 182);
runner.set_guest_tick_for_test(182);
runner.frozen_ticks = Some(182);
runner.set_instructions_per_tick(1_000_000);
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(0, 0));
let (steps, running) = runner.run_gui_slice_with_audio(16, 184, 0);
assert!(running);
assert_eq!(steps, 1);
assert_eq!(runner.frozen_ticks, None);
assert_eq!(runner.guest_tick(), 184);
assert_eq!(runner.guest_tick(), 184);
}
#[test]
fn gui_modaldialog_null_filter_fires_at_tick_cap() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let filter_proc = 0x0001_1000u32;
runner.bus.write_word(base, 0xA991); runner.bus.write_word(filter_proc, 0x4E56); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 0);
runner.set_guest_tick_for_test(0);
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(filter_proc, 0x0010_0100));
let (steps, running) = runner.run_gui_slice_with_audio(1, 0, 0);
assert!(running);
assert_eq!(steps, 1);
assert_eq!(runner.guest_tick(), 0);
assert_ne!(runner.m68k.cpu.read_reg(Register::PC), base);
assert!(!runner.has_pending_sound_work());
assert!(
!runner
.dispatcher
.dialog_tracking
.as_ref()
.unwrap()
.rendered_pixels_final
);
}
#[test]
fn gui_modaldialog_update_filter_fires_at_tick_cap() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let filter_proc = 0x0001_1000u32;
runner.bus.write_word(base, 0xA991); runner.bus.write_word(filter_proc, 0x4E56); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 0);
runner.set_guest_tick_for_test(0);
runner
.process_context
.shared_event_queue()
.push_back(QueuedEvent {
what: 6,
message: 0,
when: 0,
where_v: 0,
where_h: 0,
modifiers: 0,
});
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(filter_proc, 0x0010_0100));
let (steps, running) = runner.run_gui_slice_with_audio(1, 0, 0);
assert!(running);
assert_eq!(steps, 1);
assert_eq!(runner.guest_tick(), 0);
assert_ne!(runner.m68k.cpu.read_reg(Register::PC), base);
assert!(
!runner
.dispatcher
.dialog_tracking
.as_ref()
.unwrap()
.rendered_pixels_final
);
}
#[test]
fn gui_modaldialog_mouse_down_goes_to_filter_before_default_handling() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let filter_proc = 0x0001_1000u32;
runner.bus.write_word(base, 0xA991); runner.bus.write_word(filter_proc, 0x4E56); runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 0);
runner.set_guest_tick_for_test(0);
runner
.process_context
.shared_event_queue()
.push_back(QueuedEvent {
what: 1,
message: 0,
when: 0,
where_v: 12,
where_h: 24,
modifiers: 0,
});
let mut tracking = dialog_tracking_for_test(filter_proc, 0x0010_0100);
tracking.items.push(DialogItem {
item_type: 4,
rect: (8, 16, 20, 30),
text: String::from("OK"),
resource_id: 0,
proc_ptr: 0,
sel_start: 0,
sel_end: 0,
});
runner.dispatcher.dialog_tracking = Some(tracking);
let (steps, running) = runner.run_gui_slice_with_audio(1, 0, 0);
assert!(running);
assert_eq!(steps, 1);
assert_ne!(runner.m68k.cpu.read_reg(Register::PC), base);
let event_ptr = runner.dialog_filter_event;
assert_eq!(runner.bus.read_word(event_ptr), 1);
assert_eq!(runner.bus.read_word(event_ptr + 10), 12);
assert_eq!(runner.bus.read_word(event_ptr + 12), 24);
assert!(
runner.process_context.event_queue().is_empty(),
"the filter callback should consume a queued button mouseDown event"
);
}
#[test]
fn modaldialog_filter_null_event_is_paced_per_guest_tick() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let filter_proc = 0x0001_1000u32;
let dialog_ptr = 0x0020_0000u32;
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(filter_proc, 0x0010_0100));
runner.set_guest_tick_for_test(42);
runner.bus.write_long(0x016A, 42);
assert!(runner.should_fire_dialog_filter_proc());
runner.dialog_filter_last_null_event_tick = Some((dialog_ptr, 42));
assert!(
!runner.should_fire_dialog_filter_proc(),
"a synthetic null event should not refire twice in the same guest tick"
);
runner.set_guest_tick_for_test(43);
runner.bus.write_long(0x016A, 43);
assert!(
runner.should_fire_dialog_filter_proc(),
"the next guest tick should allow another ModalDialog null-event filter call"
);
}
#[test]
fn modaldialog_filter_real_events_bypass_null_event_pacing() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let filter_proc = 0x0001_1000u32;
let dialog_ptr = 0x0020_0000u32;
runner.dispatcher.dialog_tracking = Some(dialog_tracking_for_test(filter_proc, 0x0010_0100));
runner.set_guest_tick_for_test(42);
runner.bus.write_long(0x016A, 42);
runner.dialog_filter_last_null_event_tick = Some((dialog_ptr, 42));
runner
.process_context
.shared_event_queue()
.push_back(QueuedEvent {
what: 1,
message: 0,
when: 0,
where_v: 12,
where_h: 34,
modifiers: 0,
});
assert!(
runner.should_fire_dialog_filter_proc(),
"mouse/key/update events must still enter the filter immediately"
);
runner.process_context.shared_event_queue().clear();
let window_ptr = runner.bus.alloc(170);
runner.dispatcher.init_cgraf_window(
&mut runner.bus,
&mut runner.m68k.cpu,
window_ptr,
0,
100,
120,
220,
360,
"",
2,
true,
false,
false,
0,
);
runner
.dispatcher
.dialog_tracking
.as_mut()
.unwrap()
.dialog_ptr = window_ptr;
runner.dialog_filter_last_null_event_tick = Some((window_ptr, 42));
assert!(
runner.should_fire_dialog_filter_proc(),
"a pending updateEvt for the active dialog must bypass null-event pacing"
);
}
#[test]
fn spin_fastfwd_rejects_wrong_branch_target() {
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, 0x201F);
runner.bus.write_word(base + 6, 0x5380);
runner.bus.write_word(base + 8, 0xB680);
runner.bus.write_word(base + 10, 0x62F6);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::D3, 500);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
let pc_after_trap = base + 4;
let mut count = 0usize;
runner.try_tickcount_spin_fastfwd(pc_after_trap, None, &mut count);
assert_eq!(runner.guest_tick(), 100);
assert_eq!(count, 0);
}
struct VirtualIdleArm {
runner: FixtureRunner,
rect: u32,
watched: u32,
timer_marker: u32,
sound_marker: u32,
callback: u32,
}
fn virtual_idle_arm(virtual_idle: bool) -> VirtualIdleArm {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.virtual_idle_enabled = virtual_idle;
let base = 0x0001_0000u32;
let rect = 0x0003_0000u32;
let watched = 0x0003_0010u32;
let timer_marker = 0x0003_0020u32;
let sound_marker = 0x0003_0030u32;
let timer_callback = 0x0002_0000u32;
let sound_callback = 0x0002_0100u32;
let mut program = vec![
0x554F, 0xA973, 0x121F, 0x3439, (watched >> 16) as u16,
watched as u16,
0x4879, (rect >> 16) as u16,
rect as u16,
];
for coordinate in [10u16, 20, 30, 40] {
program.extend([0x3F3C, coordinate]); }
program.extend([
0xA8A7, 0x60DA, ]);
for (index, word) in program.into_iter().enumerate() {
runner.bus.write_word(base + 2 * index as u32, word);
}
for (index, word) in [
0x5279,
(timer_marker >> 16) as u16,
timer_marker as u16,
0x4E75,
]
.into_iter()
.enumerate()
{
runner.bus.write_word(timer_callback + 2 * index as u32, word);
}
for (index, word) in [
0x5279,
(sound_marker >> 16) as u16,
sound_marker as u16,
0x4E74,
0x0008,
]
.into_iter()
.enumerate()
{
runner.bus.write_word(sound_callback + 2 * index as u32, word);
}
runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(20_000);
runner.dispatcher.input_state.set_mouse_button_for_test(true);
runner.dispatcher.timer_tasks.push(TimerTask {
task_ptr: 0x0039_38C8,
architecture: CallbackTaskArchitecture::M68k,
extended: false,
callback: timer_callback,
active: true,
fire_at_tick: 101,
fire_at_subtick: 101_437_000,
last_fired_tick: None,
});
VirtualIdleArm {
runner,
rect,
watched,
timer_marker,
sound_marker,
callback: sound_callback,
}
}
impl VirtualIdleArm {
fn observe(&self, steps: usize, running: bool) -> (usize, bool, u32, i32, u64, CpuArchitecturalSnapshot, u64) {
use std::hash::{Hash, Hasher};
let mut ram = std::collections::hash_map::DefaultHasher::new();
self.runner.bus.ram_slice(0, self.runner.bus.ram_size()).hash(&mut ram);
(
steps,
running,
self.runner.guest_tick(),
self.runner.tick_budget,
self.runner.total_instructions,
CpuArchitecturalSnapshot::capture(&self.runner.m68k.cpu.core),
ram.finish(),
)
}
}
#[test]
fn virtual_idle_cursor_is_invisible_across_fixed_slices() {
let mut plain = virtual_idle_arm(false);
let mut cursor = virtual_idle_arm(true);
let slices = [2_993usize, 4_001, 997, 6_007, 3_331, 5_003, 7_919, 1_009];
for round in 0..12 {
for (index, &slice) in slices.iter().enumerate() {
for arm in [&mut plain, &mut cursor] {
match (round, index) {
(2, 3) => {
arm.runner.bus.write_word(arm.rect + 2, 0x7777);
arm.runner.bus.write_word(arm.watched, 0x1234);
}
(4, 1) | (7, 6) => {
let header = 0x0020_0000;
let buffer = 0x0020_1000;
arm.runner.bus.write_long(header + 12, buffer);
arm.runner.bus.write_long(buffer + 4, 1);
arm.runner.dispatcher.sound_manager.queue_doubleback_callback(
PendingDoubleBackCallback {
callback_addr: arm.callback,
chan_ptr: 0x0039_3000,
header_ptr: header,
exhausted_buffer_index: 0,
},
);
}
_ => {}
}
}
let (steps, running) = plain.runner.run_steps(slice, None);
let expected = plain.observe(steps, running);
let (steps, running) = cursor.runner.run_steps(slice, None);
assert!(
expected == cursor.observe(steps, running),
"round {round} slice {index}: the cursor changed what the slice exposed"
);
}
}
assert_eq!(plain.runner.bus.read_word(plain.timer_marker), 1, "the timer ran");
assert_eq!(plain.runner.bus.read_word(plain.sound_marker), 2, "both callbacks ran");
assert_eq!(plain.runner.virtual_idle_entries, 0);
assert!(
cursor.runner.virtual_idle_entries > 0,
"the cursor must actually have skipped passes"
);
}
#[test]
fn track_control_custom_cdef_preserves_guest_parts_and_release_cancellation() {
for (initial_part, release_part) in [(42u16, 42u16), (42, 17), (42, 0), (0, 0)] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0001_0000u32;
let sp = 0x0010_0000u32;
let port = runner.bus.alloc(200);
let handle = runner.bus.alloc(4);
let pointer = runner.bus.alloc(36);
let cdef_handle = runner.bus.alloc(4);
let cdef = runner.bus.alloc(48);
let tested_point = runner.bus.alloc(4);
let supplied_part = runner.bus.alloc(4);
let calls = runner.bus.alloc(2);
runner.bus.write_long(supplied_part, u32::from(initial_part));
runner.bus.write_word(base, 0xA968);
runner.bus.write_word(base + 2, 0x60FE); runner.bus.write_word(cdef, 0x4E56); runner.bus.write_word(cdef + 2, 0);
runner.bus.write_word(cdef + 4, 0x0C6E); runner.bus.write_word(cdef + 6, 1);
runner.bus.write_word(cdef + 8, 12);
runner.bus.write_word(cdef + 10, 0x6608); runner.bus.write_word(cdef + 12, 0x23EE); runner.bus.write_word(cdef + 14, 8);
runner.bus.write_long(cdef + 16, tested_point);
runner.bus.write_word(cdef + 20, 0x2039); runner.bus.write_long(cdef + 22, supplied_part);
runner.bus.write_word(cdef + 26, 0x2D40); runner.bus.write_word(cdef + 28, 20);
runner.bus.write_word(cdef + 30, 0x5279); runner.bus.write_long(cdef + 32, calls);
runner.bus.write_word(cdef + 36, 0x4E5E); runner.bus.write_word(cdef + 38, 0x4E74); runner.bus.write_word(cdef + 40, 12);
runner.bus.write_long(cdef_handle, cdef);
runner.bus.write_long(handle, pointer);
runner.bus.write_long(pointer + 4, port);
runner.bus.write_word(port + 8, (-100i16) as u16);
runner.bus.write_word(port + 10, (-120i16) as u16);
for (offset, value) in [(8, 10), (10, 10), (12, 50), (14, 80)] {
runner.bus.write_word(pointer + offset, value);
}
runner.bus.write_byte(pointer + 16, 255);
runner.bus.write_long(pointer + 24, cdef_handle);
runner
.dispatcher
.control_manager
.register(handle, pointer, 160 << 4, 0);
runner
.dispatcher
.input_state
.set_mouse_button_for_test(true);
runner
.dispatcher
.input_state
.set_mouse_position_for_test((120, 140));
runner.bus.write_long(sp, 0);
runner.bus.write_word(sp + 4, 120); runner.bus.write_word(sp + 6, 140);
runner.bus.write_long(sp + 8, handle);
runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, sp);
let (_, running) = runner.run_steps(512, None);
assert!(running);
if initial_part == 0 {
assert!(!runner.dispatcher.is_control_tracking());
assert_eq!(runner.bus.read_word(sp + 12), 0);
assert_eq!(runner.bus.read_word(calls), 1);
assert_eq!(runner.bus.read_byte(pointer + 17), 0);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp + 12);
continue;
}
assert!(runner.dispatcher.is_control_tracking());
assert_eq!(runner.bus.read_byte(pointer + 17), 42);
assert_eq!(runner.bus.read_long(tested_point), (20 << 16) | 20);
assert_eq!(
runner.bus.read_word(calls),
2,
"guest test and pressed drawing must execute once"
);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp);
runner
.bus
.write_long(supplied_part, u32::from(release_part));
runner
.dispatcher
.input_state
.set_mouse_position_for_test((105, 125));
runner
.dispatcher
.input_state
.set_mouse_button_for_test(false);
runner
.bus
.write_byte(crate::memory::globals::addr::MB_STATE, 0x80);
let (_, running) = runner.run_steps(512, None);
assert!(running);
assert!(!runner.dispatcher.is_control_tracking());
assert_eq!(
runner.bus.read_word(sp + 12),
if release_part == 42 { 42 } else { 0 }
);
assert_eq!(runner.bus.read_byte(pointer + 17), 0);
assert_eq!(runner.bus.read_long(tested_point), (5 << 16) | 5);
assert_eq!(
runner.bus.read_word(calls),
4,
"release hit test and restoration must execute"
);
assert_eq!(runner.m68k.cpu.read_reg(Register::A7), sp + 12);
}
}
#[test]
fn zero_sleep_wait_next_event_proves_a_cycle_and_wakes_for_input() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000;
let sp = 0x0010_0000;
let event = 0x0010_0100;
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(0x016A, 100);
for iteration in 0..3 {
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA860;
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_long(sp, 0); runner.bus.write_long(sp + 4, 0); runner.bus.write_long(sp + 8, event);
runner.bus.write_word(sp + 12, 0xFFFF);
runner
.dispatcher
.dispatch(0xA860, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
assert_eq!(runner.bus.read_word(event), 0);
assert!(runner.note_idle_cycle_trap_result(
0xA860,
runner.m68k.cpu.read_reg(Register::D0),
false
));
assert_eq!(
runner.try_exact_null_event_cycle_fastfwd(trap_pc, Some(100)),
iteration == 2
);
}
assert_eq!(runner.guest_tick(), 100);
assert!(runner.idle_cycle_sleep.is_some());
runner.push_mouse_down(20, 30);
assert!(!runner.try_resume_proven_idle_cycle(Some(110)));
assert_eq!(runner.guest_tick(), 100);
assert!(runner.idle_cycle_sleep.is_none());
}
#[test]
fn wait_next_event_sleep_events_and_redraw_reject_an_idle_probe() {
for (sleep, deliver_event, redraw) in [(60, false, false), (0, true, false), (0, false, true)] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000;
let sp = 0x0010_0000;
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.set_guest_tick_for_test(100);
runner.m68k.cpu.write_reg(Register::A7, sp);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(105)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(105)));
assert!(runner.idle_cycle_probe.is_some());
if deliver_event {
runner.push_mouse_down(20, 30);
}
if redraw {
runner.dispatcher.event_queue.invalidate_menu_bar();
}
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.bus.write_long(sp, 0);
runner.bus.write_long(sp + 4, sleep);
runner.bus.write_long(sp + 8, 0x0010_0100);
runner.bus.write_word(sp + 12, 0xFFFF);
runner
.dispatcher
.dispatch(0xA860, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
assert!(!runner.note_idle_cycle_trap_result(
0xA860,
runner.m68k.cpu.read_reg(Register::D0),
false
));
assert!(runner.idle_cycle_probe.is_none());
if sleep != 0 {
assert_eq!(runner.dispatcher.pending_wait_sleep_ticks, sleep);
assert!(runner.dispatcher.pending_wait_next_event_return.is_some());
}
assert_eq!(runner.guest_tick(), 100);
}
}
#[test]
fn parked_event_loop_wakes_for_menu_bar_invalidation() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000;
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(0x016A, 100);
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(100)));
assert!(!runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(100)));
assert!(runner.try_exact_idle_cycle_fastfwd(trap_pc, 101, Some(100)));
runner.dispatcher.event_queue.invalidate_menu_bar();
assert!(!runner.try_resume_proven_idle_cycle(Some(105)));
assert_eq!(runner.guest_tick(), 100);
assert!(runner.idle_cycle_sleep.is_none());
assert!(runner.dispatcher.event_queue.menu_bar_is_invalid());
}
fn zero_sleep_event_loop_for_deferred_slices() -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0002_0000;
let event = 0x0010_0100;
let mut words = vec![
0x4267, 0x3F3C,
0xFFFF, 0x4879,
(event >> 16) as u16,
event as u16, 0x42A7,
0x42A7, 0xA860,
0x548F, 0x42A7,
0xA924,
0x588F, ];
words.extend(std::iter::repeat_n(0x4E71, 70));
words.push(0x6000);
let displacement = -((words.len() * 2) as i16);
words.push(displacement as u16);
for (index, word) in words.into_iter().enumerate() {
runner.bus.write_word(base + index as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(0x016A, 100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner
}
#[test]
fn deferred_cpu_slices_prove_long_zero_sleep_event_loops() {
let mut runner = zero_sleep_event_loop_for_deferred_slices();
for _ in 0..12 {
let (steps, running) = runner.run_gui_cpu_slice(64, 100);
assert!(running);
assert!(steps <= 64);
if runner.idle_cycle_sleep.is_some() {
break;
}
}
assert!(runner.idle_cycle_sleep.is_some());
assert_eq!(runner.guest_tick(), 100);
runner.push_mouse_down(20, 30);
for _ in 0..4 {
let (_, running) = runner.run_gui_cpu_slice(64, 100);
assert!(running);
if runner.bus.read_word(0x0010_0100) == 1 {
break;
}
}
assert_eq!(runner.bus.read_word(0x0010_0100), 1);
assert!(runner.idle_cycle_sleep.is_none());
}
#[test]
fn frame_composition_and_changed_input_revoke_unfinished_deferred_proofs() {
for compose in [false, true] {
let mut runner = zero_sleep_event_loop_for_deferred_slices();
for _ in 0..12 {
let (_, running) = runner.run_gui_cpu_slice(64, 100);
assert!(running);
if runner.idle_cycle_probe.is_some() {
break;
}
}
assert!(runner.idle_cycle_probe.is_some());
if compose {
runner.composite_frame();
} else {
runner.push_mouse_down(20, 30);
runner.run_gui_cpu_slice(1, 100);
}
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.idle_cycle_sleep.is_none());
assert_eq!(runner.guest_tick(), 100);
}
}
#[test]
fn calendar_conversion_and_help_getters_preserve_an_exact_idle_probe() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let site = 0x0002_0000;
let date = 0x0003_0000;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::A0, date);
runner.m68k.cpu.write_reg(Register::D0, 0);
runner
.dispatcher
.dispatch(0xA9C6, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
assert_eq!(runner.bus.read_word(date), 1904);
assert_eq!(runner.bus.read_word(date + 2), 1);
assert_eq!(runner.bus.read_word(date + 4), 1);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(0x016A, 100);
assert!(!runner.try_exact_idle_cycle_fastfwd(site, 101, Some(100)));
assert!(!runner.try_exact_idle_cycle_fastfwd(site, 101, Some(100)));
assert!(runner.idle_cycle_probe.is_some());
runner
.dispatcher
.dispatch(0xA9C6, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
runner.note_idle_cycle_trap_result(0xA9C6, 0, false);
assert!(runner.idle_cycle_probe.is_some());
for selector in [0x0003, 0x0007] {
runner.m68k.cpu.write_reg(Register::D0, selector);
let input_selector = runner.m68k.cpu.read_reg(Register::D0);
runner
.dispatcher
.dispatch(0xA830, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
assert_eq!(runner.m68k.cpu.read_reg(Register::D0), 0);
assert_eq!(runner.bus.read_word(0x0010_0000), 0);
runner.note_idle_cycle_trap_result(0xA830, input_selector, false);
assert!(
runner.idle_cycle_probe.is_some(),
"use the input selector, not its FALSE result"
);
}
assert!(runner.try_exact_idle_cycle_fastfwd(site, 101, Some(100)));
assert!(runner.idle_cycle_sleep.is_some());
assert_eq!(runner.guest_tick(), 100);
}
#[test]
fn help_mutations_and_unknown_selectors_still_reject_idle_probes() {
for selector in [0x0104, 0x0200, 0xFFFF] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let site = 0x0002_0000;
let sp = 0x0010_0000;
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(site, 101, Some(100)));
assert!(!runner.try_exact_idle_cycle_fastfwd(site, 101, Some(100)));
runner.m68k.cpu.write_reg(Register::D0, selector);
runner.bus.write_long(sp, 0x0003_0000);
runner
.dispatcher
.dispatch(0xA830, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
runner.note_idle_cycle_trap_result(0xA830, selector, false);
assert!(
runner.idle_cycle_probe.is_none(),
"reject selector {selector:04X}"
);
assert!(runner.idle_cycle_sleep.is_none());
assert_eq!(runner.guest_tick(), 100);
}
}
#[test]
fn deferred_guest_calendar_help_loop_proves_with_clobbered_d0() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0002_0000;
let event = 0x0003_0100;
let mut words = vec![
0x7000,
0xA9C6, 0x4267,
0x303C,
0x0003,
0xA830,
0x548F, 0x4267,
0x3F3C,
0xFFFF,
0x4879,
(event >> 16) as u16,
event as u16,
0xA970,
0x548F,
0xA9B4, ];
words.extend(std::iter::repeat_n(0x4E71, 70));
words.push(0x6000);
let displacement = -((words.len() * 2) as i16);
words.push(displacement as u16);
for (index, word) in words.into_iter().enumerate() {
runner.bus.write_word(base + index as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::A0, 0x0003_0000);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(0x016A, 100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
for _ in 0..12 {
let (steps, running) = runner.run_gui_cpu_slice(64, 100);
assert!(running);
assert!(steps <= 64);
if runner.idle_cycle_sleep.is_some() {
break;
}
}
assert!(runner.idle_cycle_sleep.is_some());
assert_eq!(runner.guest_tick(), 100);
runner.push_mouse_down(20, 30);
for _ in 0..4 {
runner.run_gui_cpu_slice(64, 100);
if runner.bus.read_word(event) == 1 {
break;
}
}
assert_eq!(runner.bus.read_word(event), 1);
assert!(runner.idle_cycle_sleep.is_none());
}
#[test]
fn deferred_guest_menu_clear_loop_parks_and_delivers_mouse_input() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let base = 0x0002_0000;
let event = 0x0003_0100;
let mut words = vec![
0x4267,
0xA938, 0xA9B4, 0x4267,
0x3F3C,
0xFFFF,
0x4879,
(event >> 16) as u16,
event as u16,
0xA970,
0x548F, ];
words.extend(std::iter::repeat_n(0x4E71, 70));
words.push(0x6000);
let displacement = -((words.len() * 2) as i16);
words.push(displacement as u16);
for (index, word) in words.into_iter().enumerate() {
runner.bus.write_word(base + index as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, base);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::A0, 0x0003_0000);
runner.set_guest_tick_for_test(100);
runner.bus.write_long(0x016A, 100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
for _ in 0..12 {
let (steps, running) = runner.run_gui_cpu_slice(64, 100);
assert!(running);
assert!(steps <= 64);
if runner.idle_cycle_sleep.is_some() {
break;
}
}
assert!(runner.idle_cycle_sleep.is_some());
assert_eq!(runner.guest_tick(), 100);
runner.push_mouse_down(20, 30);
for _ in 0..4 {
runner.run_gui_cpu_slice(64, 100);
if runner.bus.read_word(event) == 1 {
break;
}
}
assert_eq!(runner.bus.read_word(event), 1);
assert!(runner.idle_cycle_sleep.is_none());
}
#[test]
fn changing_menu_clear_cancels_an_idle_probe_before_it_can_park() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let site = 0x0002_0000;
let sp = 0x0010_0000;
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_word(sp, 0);
runner
.bus
.write_word(crate::memory::globals::addr::THE_MENU, 243);
runner.set_guest_tick_for_test(100);
assert!(!runner.try_exact_idle_cycle_fastfwd(site, 101, Some(100)));
assert!(!runner.try_exact_idle_cycle_fastfwd(site, 101, Some(100)));
let was_noop = runner.dispatcher.hilite_menu_clear_is_noop(&runner.bus, 0);
assert!(!was_noop);
runner
.dispatcher
.dispatch(0xA938, &mut runner.m68k.cpu, &mut runner.bus)
.unwrap();
assert_eq!(
runner.bus.read_word(crate::memory::globals::addr::THE_MENU),
0
);
runner.note_idle_cycle_trap_result(0xA938, 0, was_noop);
assert!(runner.idle_cycle_probe.is_none());
assert!(runner.idle_cycle_sleep.is_none());
assert!(!idle_cycle_trap_is_journal_complete(
0xA938, true, true, true, 0, false
));
assert!(!idle_cycle_trap_is_journal_complete(
0xAD38, true, true, true, 0, false
));
assert!(idle_cycle_trap_is_journal_complete(
0xA938, true, true, true, 0, true
));
assert!(idle_cycle_trap_is_journal_complete(
0xAD38, true, true, true, 0, true
));
}
#[test]
fn dialog_host_snapshot_changes_with_front_and_membership() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let initial = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.front_window = 0x1234;
let front_changed = IdleCycleHostSnapshot::capture(&runner.dispatcher);
assert_ne!(initial, front_changed);
runner.dispatcher.dialog_items.insert(0x1234, Vec::new());
let dialog_added = IdleCycleHostSnapshot::capture(&runner.dispatcher);
assert_ne!(front_changed, dialog_added);
runner.dispatcher.dialog_items.remove(&0x1234);
assert_eq!(front_changed, IdleCycleHostSnapshot::capture(&runner.dispatcher));
}
#[test]
fn setcursor_idle_cycle_checks_cursor_state_memory_and_patches() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let image = 0x0020_0000u32;
let words = [0x594F, 0xA975, 0x588F, 0x4879, (image >> 16) as u16,
image as u16, 0xA851, 0x6000, 0xFFF0];
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x0010_0000, image);
assert!(runner.idle_cursor_call_guards().is_some());
runner.bus.write_long(0x0010_0000, u32::MAX - 16);
assert!(runner.idle_cursor_call_guards().is_none(), "unmapped cursor records must not be elided");
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(100_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
let (_, running) = runner.run_steps_internal(
20_000, Some(100), 0, true, false, FrameFinalization::Deferred,
);
assert!(running);
assert!(runner.idle_cycle_sleep.is_some(), "stable cursor cycle should park");
runner.bus.write_byte(image, 0x80);
assert!(!runner.try_resume_proven_idle_cycle(Some(102)), "guest cursor edits must revoke the proof");
assert!(runner.idle_cycle_sleep.is_none());
runner.dispatcher.install_trap_address(&mut runner.bus, 0xA851, 0x0030_0000).unwrap();
assert!(runner.idle_query_has_unsafe_dispatch(0xA851));
assert!(runner.idle_query_has_unsafe_dispatch(0xAC51));
}
#[test]
fn dialog_state_changes_cancel_a_parked_idle_cycle() {
for change_membership in [false, true] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA975;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.park_proven_idle_cycle(trap_pc, 103);
if change_membership {
runner.dispatcher.dialog_items.insert(0x1234, Vec::new());
} else {
runner.dispatcher.front_window = 0x1234;
}
assert!(!runner.try_resume_proven_idle_cycle(Some(102)));
assert_eq!(runner.guest_tick(), 100);
assert!(runner.idle_cycle_sleep.is_none());
}
}
#[test]
fn exact_idle_cycle_admits_real_dialog_and_bit_queries() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let event = 0x0020_0000u32;
let stack = 0x0010_0000u32;
let words = [
0x594F, 0xA975, 0x588F,
0x554F, 0x4879, (event >> 16) as u16, event as u16, 0xA97F, 0x4A1F,
0x594F, 0x2F3C, 0, 1, 0x2F3C, 0, 1, 0xA858, 0x588F, 0x6000, 0xFFDA,
];
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + (i as u32 * 2), word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, stack);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
let (_, running) = runner.run_steps_internal(
2_000, Some(100), 0, true, false, FrameFinalization::Deferred,
);
assert!(running);
assert!(runner.idle_cycle_sleep.is_some(), "the real query cycle must be proven");
}
#[test]
fn patched_sound_dialog_and_bit_queries_cancel_an_idle_probe() {
for opcode in [0xA800u16, 0xA858, 0xA97F] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let handler = 0x0020_0000u32;
let anchor = 0x0003_0000u32;
runner.bus.write_word(code, opcode);
runner.bus.write_word(handler, 0x4E75); assert!(!runner.idle_query_has_unsafe_dispatch(opcode));
runner.dispatcher.install_trap_address(&mut runner.bus, opcode, handler).unwrap();
assert!(runner.idle_query_has_unsafe_dispatch(opcode));
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
assert!(!runner.try_exact_idle_cycle_fastfwd(anchor, 101, Some(100)));
assert!(!runner.try_exact_idle_cycle_fastfwd(anchor, 101, Some(100)));
assert!(runner.idle_cycle_probe.is_some());
let (_, running) = runner.run_steps_internal(
1, Some(100), 0, true, false, FrameFinalization::Deferred,
);
assert!(running);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), handler);
assert!(runner.idle_cycle_probe.is_none(), "patched {opcode:04X} must cancel");
}
}
#[test]
fn quickdraw_mirror_and_cached_port_changes_revoke_idle_proofs() {
for mutate_cache in [false, true] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let trap_pc = 0x0002_0000;
let port = 0x0020_0000;
runner.dispatcher.current_port.with_mut(|current| *current = port);
runner.dispatcher.process_quickdraw_port_state_attached = true;
runner.m68k.cpu.write_reg(Register::PC, trap_pc + 2);
runner.m68k.cpu.core.ppc = trap_pc;
runner.m68k.cpu.core.ir = 0xA975;
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.park_proven_idle_cycle(trap_pc, 103);
if mutate_cache {
runner.dispatcher.port_draw_states.insert(port, Default::default());
} else {
runner.dispatcher.fg_color = (123, 456, 789);
}
assert!(!runner.try_resume_proven_idle_cycle(Some(102)));
assert_eq!(runner.guest_tick(), 100);
assert!(runner.idle_cycle_sleep.is_none());
}
}
#[test]
fn dialog_event_dispatch_syncs_quickdraw_mirror_before_handler() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let port = 0x0020_0000u32;
let event = 0x0021_0000u32;
let sp = 0x0010_0000u32;
runner.dispatcher.current_port.with_mut(|current| *current = port);
runner.dispatcher.process_quickdraw_port_state_attached = true;
runner.dispatcher.port_draw_states.insert(port, Default::default());
runner.dispatcher.fg_color = (1, 2, 3);
runner.bus.write_word(port + 6, 0xC000);
runner.bus.write_word(port + 36, 123);
runner.bus.write_word(port + 38, 456);
runner.bus.write_word(port + 40, 789);
runner.bus.write_word(event, 0);
runner.bus.write_long(sp, event);
runner.m68k.cpu.write_reg(Register::A7, sp);
let before = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.dispatch(0xA97F, &mut runner.m68k.cpu, &mut runner.bus).unwrap();
assert_eq!(runner.dispatcher.fg_color, (123, 456, 789));
assert_ne!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
}
#[test]
fn pending_manager_calls_keep_dialog_queries_out_of_idle_proofs() {
let runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
assert!(!runner.idle_query_has_unsafe_dispatch(0xA97F));
let before = IdleCycleHostSnapshot::capture(&runner.dispatcher);
assert!(runner.dispatcher.guest_calls.begin_m68k(
crate::guest_call::GuestCallTarget {
isa: crate::guest_procedure::GuestIsa::M68k,
entry: 0x1000,
rtoc: 0,
},
0x2000,
0x3000,
));
assert!(runner.idle_query_has_unsafe_dispatch(0xA97F));
assert!(!runner.idle_query_has_unsafe_dispatch(0xA858));
assert_ne!(before, IdleCycleHostSnapshot::capture(&runner.dispatcher));
}
#[test]
fn pending_guest_call_cancels_dialog_query_pass_recording() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let anchor = 0x0003_0000u32;
let event = 0x0020_0000u32;
let sp = 0x0010_0000u32;
runner.bus.write_word(code, 0xA97F);
runner.bus.write_long(sp, event);
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, sp);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
assert!(runner.dispatcher.guest_calls.begin_m68k(
crate::guest_call::GuestCallTarget {
isa: crate::guest_procedure::GuestIsa::M68k,
entry: 0x1000,
rtoc: 0,
},
0x4000,
0x5000,
));
runner.idle_cycle_sites[0].site = anchor;
runner.idle_cycle_sites[0].tick = 100;
runner.idle_cycle_sites[0].probes = IDLE_CYCLE_MAX_PROBES_PER_TICK + 1;
runner.note_virtual_anchor_arrival(anchor);
assert!(runner.pass_recorder.is_some());
let (_, running) = runner.run_steps_internal(
1, Some(100), 0, true, false, FrameFinalization::Deferred,
);
assert!(running);
assert_eq!(runner.m68k.cpu.read_reg(Register::PC), code + 2);
assert!(runner.pass_recorder.is_none());
}
#[test]
fn virtual_idle_rejects_a_pass_that_changes_quickdraw_mirrors() {
for mutate_mirror in [false, true] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let anchor = 0x0002_0000u32;
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.idle_cycle_sites[0].site = anchor;
runner.idle_cycle_sites[0].tick = 100;
runner.idle_cycle_sites[0].probes = IDLE_CYCLE_MAX_PROBES_PER_TICK + 1;
runner.note_virtual_anchor_arrival(anchor);
assert!(runner.pass_recorder.is_some());
runner.total_instructions += 1;
runner.tick_budget -= 1;
runner.pass_recorder.as_mut().unwrap().executed = 1;
if mutate_mirror {
runner.dispatcher.fg_color = (123, 456, 789);
}
runner.note_virtual_anchor_arrival(anchor);
assert_eq!(runner.virtual_idle_cycle.is_some(), !mutate_mirror);
}
}
#[test]
fn virtual_device_loop_preserves_cursor_and_guest_state_across_slices() {
fn arm(enabled: bool) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.virtual_idle_enabled = enabled;
let code = 0x0002_0000u32;
let rect = 0x0030_0000u32;
let mut words = vec![
0x42A7, 0xAA32, 0x205F, 0x2F08, 0xAA31, 0x4879, (rect >> 16) as u16, rect as u16, 0x42A7, 0xA855, 0xA853, 0x6000,
];
words.push((-((words.len() as i16 - 1) * 2 + 2)) as u16);
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
for (i, value) in [0, 0, 100, 100].into_iter().enumerate() {
runner.bus.write_word(rect + i as u32 * 2, value);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(20_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.dispatcher.input_state.set_mouse_position_for_test((20, 20));
runner
}
for browser_slices in [false, true] {
let mut plain = arm(false);
let mut cursor = arm(true);
let rounds = if browser_slices { 100 } else { 16 };
for round in 0..rounds {
if round == 6 {
for runner in [&mut plain, &mut cursor] {
runner.dispatcher.input_state.set_mouse_position_for_test((200, 200));
}
}
let run = |runner: &mut FixtureRunner| {
if browser_slices {
runner.run_gui_cpu_slice_until_host_work(3_331, runner.guest_tick() + 1)
} else {
runner.run_steps(3_331, None)
}
};
assert_eq!(run(&mut plain), run(&mut cursor));
assert_eq!(plain.guest_tick(), cursor.guest_tick(),
"round={round} browser={browser_slices} plain_budget={} cursor_budget={} plain_steps={} cursor_steps={} entries={}",
plain.tick_budget, cursor.tick_budget, plain.total_instructions,
cursor.total_instructions, cursor.virtual_idle_entries);
assert_eq!(plain.tick_budget, cursor.tick_budget);
assert_eq!(plain.total_instructions, cursor.total_instructions);
assert_eq!(CpuArchitecturalSnapshot::capture(&plain.m68k.cpu.core),
CpuArchitecturalSnapshot::capture(&cursor.m68k.cpu.core));
assert_eq!(plain.dispatcher.cursor_state.snapshot(), cursor.dispatcher.cursor_state.snapshot());
assert_eq!(plain.bus.ram_slice(0, plain.bus.ram_size()),
cursor.bus.ram_slice(0, cursor.bus.ram_size()));
}
assert!(cursor.virtual_idle_entries > 0, "the repeated device loop should be recorded (browser={browser_slices})");
}
}
#[test]
fn virtual_device_recording_rejects_unbalanced_cursor_changes() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let anchor = 0x0002_0000;
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.note_virtual_device_anchor_arrival(anchor);
assert!(runner.pass_recorder.is_some());
runner.total_instructions += 1;
runner.tick_budget -= 1;
runner.pass_recorder.as_mut().unwrap().executed = 1;
runner.dispatcher.cursor_state.hide();
runner.note_virtual_device_anchor_arrival(anchor);
assert!(runner.virtual_idle_cycle.is_none(), "a changed cursor cannot be elided");
}
#[test]
fn patched_device_and_cursor_traps_cancel_virtual_recordings() {
for opcode in [0xA853u16, 0xA855, 0xAA31, 0xAA32] {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.install_trap_address(&mut runner.bus, opcode, 0x0020_0000).unwrap();
runner.note_virtual_device_anchor_arrival(0x0002_0000);
assert!(runner.pass_recorder.is_some());
runner.record_pass_trap(opcode, true, 0, 0);
assert!(runner.pass_recorder.is_none(), "patched {opcode:04X} must cancel");
}
}
#[test]
fn virtual_pass_with_unbounded_trap_respects_browser_slice_boundaries() {
fn arm(enabled: bool) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.virtual_idle_enabled = enabled;
let code = 0x0002_0000u32;
let port_out = 0x0030_0000u32;
let mut words = vec![
0x42A7, 0xAA32, 0x588F, 0x4879, (port_out >> 16) as u16, port_out as u16, 0xA874, 0x6000,
];
words.push((-((words.len() as i16 - 1) * 2 + 2)) as u16);
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(20_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner
}
for stop_at_any_trap in [false, true] {
let mut plain = arm(false);
let mut cursor = arm(true);
for _ in 0..12 {
let cap = plain.guest_tick() + 1;
assert_eq!(plain.run_gui_cpu_slice(3_331, cap), cursor.run_gui_cpu_slice(3_331, cap));
assert_eq!(plain.guest_tick(), cursor.guest_tick());
assert_eq!(plain.tick_budget, cursor.tick_budget);
assert_eq!(CpuArchitecturalSnapshot::capture(&plain.m68k.cpu.core),
CpuArchitecturalSnapshot::capture(&cursor.m68k.cpu.core));
}
assert!(cursor.virtual_idle_entries > 0, "the unbounded pass must first be recorded");
for _ in 0..80 {
let cap = plain.guest_tick() + 1;
let run = |runner: &mut FixtureRunner| {
if stop_at_any_trap {
runner.run_gui_cpu_slice_until_trap(3_331, cap)
} else {
runner.run_gui_cpu_slice_until_host_work(3_331, cap)
}
};
assert_eq!(run(&mut plain), run(&mut cursor));
assert_eq!(plain.guest_tick(), cursor.guest_tick());
assert_eq!(plain.tick_budget, cursor.tick_budget);
assert_eq!(CpuArchitecturalSnapshot::capture(&plain.m68k.cpu.core),
CpuArchitecturalSnapshot::capture(&cursor.m68k.cpu.core));
assert_eq!(plain.bus.ram_slice(0, plain.bus.ram_size()),
cursor.bus.ram_slice(0, cursor.bus.ram_size()));
}
}
}
#[test]
fn sound_status_idle_snapshot_tracks_queued_work_and_callbacks() {
for selector in [0x0010_0008, 0x0510_0008] {
assert!(!idle_cycle_trap_is_journal_complete(0xA800, true, true, true, selector, false));
assert!(virtual_idle_trap_is_journal_complete(0xA800, true, true, true, selector, false));
assert!(!virtual_idle_trap_is_journal_complete(0xA800, true, true, true, selector, true));
}
for selector in [0x0014_0008, 0x0510_0009, 0x0000_0008] {
assert!(!idle_cycle_trap_is_journal_complete(0xA800, true, true, true, selector, false));
assert!(!virtual_idle_trap_is_journal_complete(0xA800, true, true, true, selector, false));
}
let runner = FixtureRunner::new(1024 * 1024, FixtureRunnerConfig::default());
let initial = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.sound_manager.with_mut(|sound| {
sound.channels.push(crate::sound::SndChannel::new(0x1234, false));
});
let channel = IdleCycleHostSnapshot::capture(&runner.dispatcher);
assert_ne!(initial, channel);
runner.dispatcher.sound_manager.with_mut(|sound| {
assert!(sound.enqueue_command(0x1234, crate::sound::SndCommand { cmd: 1, param1: 0, param2: 0 }));
});
assert_ne!(channel, IdleCycleHostSnapshot::capture(&runner.dispatcher));
let queued = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.sound_manager.with_mut(|sound| {
sound.pending_callbacks.push(PendingDoubleBackCallback {
callback_addr: 0, chan_ptr: 0x4321, header_ptr: 0, exhausted_buffer_index: 0,
});
});
assert_ne!(queued, IdleCycleHostSnapshot::capture(&runner.dispatcher));
}
#[test]
fn sound_status_poll_cursor_preserves_slices_and_observes_new_work() {
fn arm(virtual_idle: bool) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.virtual_idle_enabled = virtual_idle;
let code = 0x0002_0000u32;
let channel = 0x0030_0000u32;
let status = 0x0030_1000u32;
let mut words = vec![
0x594F, 0xA975, 0x588F, 0x554F, 0x2F3C, (channel >> 16) as u16, channel as u16,
0x3F3C, 24,
0x4879, (status >> 16) as u16, status as u16,
0x203C, 0x0510, 0x0008, 0xA800, 0x4A5F, 0x6000,
];
let branch_offset = -((words.len() as i32 - 1) * 2 + 2);
words.push(branch_offset as i16 as u16);
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(20_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.dispatcher.event_queue.push_back(crate::event_queue::QueuedEvent {
what: 1, message: 0, when: 0, where_v: 10, where_h: 20, modifiers: 0,
});
runner.dispatcher.sound_manager.with_mut(|sound| {
sound.channels.push(crate::sound::SndChannel::new(channel, false));
});
runner
}
let mut plain = arm(false);
let mut cursor = arm(true);
for round in 0..12 {
if round == 5 {
for runner in [&mut plain, &mut cursor] {
runner.dispatcher.sound_manager.with_mut(|sound| {
assert!(sound.enqueue_command(0x0030_0000, crate::sound::SndCommand {
cmd: 1, param1: 0, param2: 0,
}));
});
}
}
let a = plain.run_steps(3_331, None);
let b = cursor.run_steps(3_331, None);
assert_eq!(a, b);
assert_eq!(plain.guest_tick(), cursor.guest_tick());
assert_eq!(plain.tick_budget, cursor.tick_budget);
assert_eq!(plain.total_instructions, cursor.total_instructions);
assert_eq!(CpuArchitecturalSnapshot::capture(&plain.m68k.cpu.core),
CpuArchitecturalSnapshot::capture(&cursor.m68k.cpu.core));
assert_eq!(plain.bus.ram_slice(0, plain.bus.ram_size()),
cursor.bus.ram_slice(0, cursor.bus.ram_size()));
}
assert_eq!(plain.virtual_idle_entries, 0);
assert_eq!(plain.dispatcher.event_queue.len(), cursor.dispatcher.event_queue.len());
assert_eq!(cursor.dispatcher.event_queue.len(), 1, "the queued event must remain available");
assert!(cursor.virtual_idle_entries > 0, "the status poll must use the cursor");
assert_eq!(cursor.bus.read_byte(0x0030_1000 + 12), 1, "new queued work must reach the guest");
}
#[test]
fn sound_status_idle_snapshot_tracks_file_pause_while_channel_stays_busy() {
let runner = FixtureRunner::new(1024 * 1024, FixtureRunnerConfig::default());
let channel = 0x1234;
runner.dispatcher.sound_manager.with_mut(|sound| {
sound.play_file_buffer(channel, vec![0x90; 64], 22_050 << 16, None);
});
let playing = IdleCycleHostSnapshot::capture(&runner.dispatcher);
assert!(playing.sound_channels_busy.iter().any(|&(ptr, busy)| ptr == channel && busy));
runner.dispatcher.sound_manager.with_mut(|sound| {
assert_eq!(sound.toggle_file_paused(channel), Some(true));
});
let paused = IdleCycleHostSnapshot::capture(&runner.dispatcher);
assert_eq!(playing.sound_channels_busy, paused.sound_channels_busy);
assert_ne!(playing, paused, "the separately visible paused bit must revoke a proof");
}
#[test]
fn virtual_idle_held_key_repeat_matches_unoptimized_across_due_and_release() {
fn arm(enabled: bool) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.virtual_idle_enabled = enabled;
let code = 0x0002_0000u32;
let channel = 0x0030_0000u32;
let status = 0x0030_1000u32;
let mut words = vec![
0x594F,
0xA975,
0x588F, 0x554F,
0x2F3C,
(channel >> 16) as u16,
channel as u16,
0x3F3C,
24,
0x4879,
(status >> 16) as u16,
status as u16,
0x203C,
0x0510,
0x0008,
0xA800,
0x4A5F,
0x6000,
];
let branch_offset = -((words.len() as i32 - 1) * 2 + 2);
words.push(branch_offset as i16 as u16);
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(20_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.dispatcher.sound_manager.with_mut(|sound| {
sound
.channels
.push(crate::sound::SndChannel::new(channel, false));
});
runner.push_key_down(0x7b, 0x1c);
runner
.dispatcher
.input_state
.arm_key_repeat(0x7b, 0x1c, 101);
runner
}
let mut plain = arm(false);
let mut cursor = arm(true);
let mut saw_auto_key = false;
for round in 0..18 {
if round == 9 {
plain.push_key_up(0x7b, 0x1c);
cursor.push_key_up(0x7b, 0x1c);
}
if round == 12 {
plain.push_key_down(0x7c, 0x1d);
cursor.push_key_down(0x7c, 0x1d);
}
assert_eq!(plain.run_steps(3_331, None), cursor.run_steps(3_331, None));
assert_eq!(plain.guest_tick(), cursor.guest_tick());
assert_eq!(plain.tick_budget, cursor.tick_budget);
assert_eq!(plain.total_instructions, cursor.total_instructions);
let mut plain_cpu = CpuArchitecturalSnapshot::capture(&plain.m68k.cpu.core);
let mut cursor_cpu = CpuArchitecturalSnapshot::capture(&cursor.m68k.cpu.core);
plain_cpu.dar_save = [0; 16];
cursor_cpu.dar_save = [0; 16];
plain_cpu.sr_save = 0;
cursor_cpu.sr_save = 0;
assert_eq!(plain_cpu, cursor_cpu, "round {round}");
assert_eq!(
plain.bus.ram_slice(0, plain.bus.ram_size()),
cursor.bus.ram_slice(0, cursor.bus.ram_size())
);
assert_eq!(
plain.dispatcher.input_state.key_repeat(),
cursor.dispatcher.input_state.key_repeat()
);
assert_eq!(
plain.dispatcher.key_map_bytes(),
cursor.dispatcher.key_map_bytes()
);
let events = |runner: &FixtureRunner| {
runner
.dispatcher
.event_queue
.iter()
.map(|e| (e.what, e.message, e.when, e.where_v, e.where_h, e.modifiers))
.collect::<Vec<_>>()
};
assert_eq!(events(&plain), events(&cursor));
saw_auto_key |= events(&plain).iter().any(|event| event.0 == 5);
}
assert!(saw_auto_key, "the due auto-key must actually be posted");
assert!(
cursor.virtual_idle_entries > 0,
"held key should not prevent a future-repeat proof"
);
}
#[test]
fn held_repeat_stale_rollback_is_overwritten_before_operand_address_error() {
fn runner(stale: u32) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.m68k.cpu.core.set_cpu_type(m68k::CpuType::M68000);
runner.bus.write_long(3 * 4, 0x0003_0000);
runner.bus.write_word(0x0003_0000, 0x4e71); runner.bus.write_word(0x0002_0000, 0x3018); runner.m68k.cpu.write_reg(Register::PC, 0x0002_0000);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::A0, 0x0021_0001); runner.m68k.cpu.write_reg(Register::D0, 0x1234_5678);
runner.m68k.cpu.core.dar_save = [stale; 16];
runner.m68k.cpu.core.sr_save = stale as u16;
runner
}
let mut a = runner(0xaaaa_aaaa);
let mut b = runner(0x5555_5555);
let _ = a.m68k.cpu.run_batch(&mut a.bus, 1, &[0]);
let _ = b.m68k.cpu.run_batch(&mut b.bus, 1, &[0]);
assert_eq!(a.m68k.cpu.read_reg(Register::PC), 0x0003_0000);
assert_eq!(a.m68k.cpu.read_reg(Register::A0), 0x0021_0001);
assert_eq!(a.m68k.cpu.read_reg(Register::D0), 0x1234_5678);
assert_eq!(
CpuArchitecturalSnapshot::capture(&a.m68k.cpu.core),
CpuArchitecturalSnapshot::capture(&b.m68k.cpu.core)
);
assert_eq!(
a.bus.ram_slice(0, a.bus.ram_size()),
b.bus.ram_slice(0, b.bus.ram_size())
);
}
#[test]
fn held_repeat_stale_rollback_does_not_change_fetch_exception() {
fn runner(stale: u32, cpu_type: m68k::CpuType) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.m68k.cpu.core.set_cpu_type(cpu_type);
runner.bus.write_long(3 * 4, 0x0003_0000);
runner.bus.write_word(0x0003_0000, 0x4e71);
runner.m68k.cpu.write_reg(Register::PC, 0x0002_0001);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::A0, 0x0021_0001);
runner.m68k.cpu.write_reg(Register::D0, 0x1234_5678);
runner.m68k.cpu.core.dar_save = [stale; 16];
runner.m68k.cpu.core.sr_save = stale as u16;
runner
}
for cpu in [m68k::CpuType::M68000, m68k::CpuType::M68020] {
let mut a = runner(0xaaaa_aaaa, cpu);
let mut b = runner(0x5555_5555, cpu);
let _ = a.m68k.cpu.run_batch(&mut a.bus, 1, &[0]);
let _ = b.m68k.cpu.run_batch(&mut b.bus, 1, &[0]);
assert_eq!(a.m68k.cpu.read_reg(Register::PC), 0x0003_0002, "{cpu:?}");
assert_eq!(a.m68k.cpu.read_reg(Register::D0), 0x1234_5678);
let mut a_state = CpuArchitecturalSnapshot::capture(&a.m68k.cpu.core);
let mut b_state = CpuArchitecturalSnapshot::capture(&b.m68k.cpu.core);
a_state.dar_save = [0; 16];
b_state.dar_save = [0; 16];
a_state.sr_save = 0;
b_state.sr_save = 0;
assert_eq!(a_state, b_state, "{cpu:?}");
assert_eq!(
a.bus.ram_slice(0, a.bus.ram_size()),
b.bus.ram_slice(0, b.bus.ram_size())
);
}
}
#[test]
fn held_repeat_stale_rollback_does_not_change_interrupt_entry() {
fn runner(stale: u32, cpu_type: m68k::CpuType) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.m68k.cpu.core.set_cpu_type(cpu_type);
runner.bus.write_long(25 * 4, 0x0003_0000); runner.bus.write_word(0x0002_0000, 0x4e71);
runner.bus.write_word(0x0003_0000, 0x4e71);
runner.m68k.cpu.core.set_sr(0x2000);
runner.m68k.cpu.write_reg(Register::PC, 0x0002_0000);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::D0, 0x1234_5678);
runner.m68k.cpu.core.dar_save = [stale; 16];
runner.m68k.cpu.core.sr_save = stale as u16;
runner.m68k.cpu.core.set_irq(1);
runner
}
for cpu in [m68k::CpuType::M68000, m68k::CpuType::M68020] {
let mut a = runner(0xaaaa_aaaa, cpu);
let mut b = runner(0x5555_5555, cpu);
let _ = a.m68k.cpu.run_batch(&mut a.bus, 1, &[0]);
let _ = b.m68k.cpu.run_batch(&mut b.bus, 1, &[0]);
assert!(
matches!(a.m68k.cpu.read_reg(Register::PC), 0x0003_0000 | 0x0003_0002),
"interrupt handler must run: {cpu:?}"
);
assert_ne!(a.m68k.cpu.read_reg(Register::A7), 0x0010_0000);
assert_eq!(a.m68k.cpu.read_reg(Register::D0), 0x1234_5678);
let mut a_state = CpuArchitecturalSnapshot::capture(&a.m68k.cpu.core);
let mut b_state = CpuArchitecturalSnapshot::capture(&b.m68k.cpu.core);
a_state.dar_save = [0; 16];
b_state.dar_save = [0; 16];
a_state.sr_save = 0;
b_state.sr_save = 0;
assert_eq!(a_state, b_state, "{cpu:?}");
assert_eq!(
a.bus.ram_slice(0, a.bus.ram_size()),
b.bus.ram_slice(0, b.bus.ram_size())
);
}
}
#[test]
fn held_repeat_stale_rollback_does_not_change_trace_exception() {
fn runner(stale: u32, cpu_type: m68k::CpuType, sr: u16, instruction: u16) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.m68k.cpu.core.set_cpu_type(cpu_type);
runner.bus.write_long(9 * 4, 0x0003_0000); runner.bus.write_word(0x0002_0000, instruction);
runner.bus.write_word(0x0002_0002, 0x4e71);
runner.bus.write_word(0x0003_0000, 0x4e71);
runner.m68k.cpu.core.set_sr(sr);
runner.m68k.cpu.write_reg(Register::PC, 0x0002_0000);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.m68k.cpu.write_reg(Register::D0, 0x1234_5678);
runner.m68k.cpu.core.dar_save = [stale; 16];
runner.m68k.cpu.core.sr_save = stale as u16;
runner
}
for (cpu, sr, instruction) in [
(m68k::CpuType::M68000, 0xa000, 0x4e71), (m68k::CpuType::M68020, 0xa000, 0x4e71), (m68k::CpuType::M68020, 0x6000, 0x6002), ] {
let mut a = runner(0xaaaa_aaaa, cpu, sr, instruction);
let mut b = runner(0x5555_5555, cpu, sr, instruction);
let _ = a.m68k.cpu.run_batch(&mut a.bus, 1, &[0]);
let _ = b.m68k.cpu.run_batch(&mut b.bus, 1, &[0]);
assert_eq!(
a.m68k.cpu.read_reg(Register::PC),
0x0003_0000,
"{cpu:?} SR={sr:04x}"
);
assert_ne!(a.m68k.cpu.read_reg(Register::A7), 0x0010_0000);
let mut a_state = CpuArchitecturalSnapshot::capture(&a.m68k.cpu.core);
let mut b_state = CpuArchitecturalSnapshot::capture(&b.m68k.cpu.core);
a_state.dar_save = [0; 16];
b_state.dar_save = [0; 16];
a_state.sr_save = 0;
b_state.sr_save = 0;
assert_eq!(a_state, b_state, "{cpu:?} SR={sr:04x}");
assert_eq!(
a.bus.ram_slice(0, a.bus.ram_size()),
b.bus.ram_slice(0, b.bus.ram_size())
);
}
}
#[test]
fn held_repeat_isolate_write_probe_and_cpu_rollback_scratch() {
fn runner(probed: bool) -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.virtual_idle_enabled = false;
let code = 0x0002_0000u32;
for (i, word) in [0x7001, 0x2f00, 0x221f, 0x60f8].into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
assert!(
runner.bus.fast_mem_window().is_some(),
"unprobed fixture must expose direct RAM"
);
if probed {
runner.bus.begin_write_probe();
assert!(
runner.bus.fast_mem_window().is_none(),
"probe must withdraw direct RAM"
);
}
runner
}
let mut plain = runner(false);
let mut probed = runner(true);
let mut first_scratch_difference = None;
for round in 0..20 {
let a = plain.m68k.cpu.run_batch(&mut plain.bus, 3_331, &[0]);
let b = probed.m68k.cpu.run_batch(&mut probed.bus, 3_331, &[0]);
assert_eq!(a.instructions, b.instructions, "round {round}");
let mut a = CpuArchitecturalSnapshot::capture(&plain.m68k.cpu.core);
let mut b = CpuArchitecturalSnapshot::capture(&probed.m68k.cpu.core);
if (a.dar_save != b.dar_save || a.sr_save != b.sr_save)
&& first_scratch_difference.is_none()
{
first_scratch_difference = Some(round);
}
a.dar_save = [0; 16];
b.dar_save = [0; 16];
a.sr_save = 0;
b.sr_save = 0;
assert_eq!(a, b, "architectural state at round {round}");
assert_eq!(
plain.bus.ram_slice(0, plain.bus.ram_size()),
probed.bus.ram_slice(0, probed.bus.ram_size())
);
}
println!("first rollback scratch difference with write probe: {first_scratch_difference:?}");
}
#[test]
fn blockmove_idle_cycle_requires_unobserved_ram_and_unpatched_trap() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let source = 0x0020_0000u32;
let destination = 0x0020_0100u32;
runner.bus.write_long(source, 0x1234_5678);
runner.bus.write_long(destination, 0x1234_5678);
let words = [
0x594F,
0xA975,
0x588F,
0x207C,
(source >> 16) as u16,
source as u16,
0x227C,
(destination >> 16) as u16,
destination as u16,
0x7004,
0xA02E,
0x6000,
0xFFE8,
];
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(100_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
let (_, running) = runner.run_steps_internal(
20_000,
Some(100),
0,
true,
false,
FrameFinalization::Deferred,
);
assert!(running);
assert!(
runner.idle_cycle_sleep.is_some(),
"stable copy cycle should park"
);
runner.bus.write_byte(source, 0xFF);
assert!(
!runner.try_resume_proven_idle_cycle(Some(102)),
"source edits must revoke the proof"
);
assert!(!runner
.bus
.idle_memory_range_is_journal_safe(source, 0x07FF_FFFF, 4));
assert!(!runner
.bus
.idle_memory_range_is_journal_safe(source, destination, 4097));
assert!(!runner
.bus
.idle_memory_range_is_journal_safe(source, destination, u32::MAX));
assert!(
runner
.bus
.idle_memory_range_is_journal_safe(source, source + 1, 4),
"overlap in ordinary RAM is supported"
);
runner.m68k.cpu.write_reg(Register::A0, source);
runner.m68k.cpu.write_reg(Register::A1, destination);
runner.m68k.cpu.write_reg(Register::D0, 4);
assert!(!runner.idle_query_has_unsafe_dispatch(0xA02E));
runner
.dispatcher
.install_trap_address(&mut runner.bus, 0xA02E, 0x0030_0000)
.unwrap();
assert!(runner.idle_query_has_unsafe_dispatch(0xA02E));
assert!(runner.idle_query_has_unsafe_dispatch(0xA22E));
let mut presented = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
presented
.bus
.enable_outline_presentation((0x0070_0000, 16, 16, 16, 8), [[0; 3]; 256], 2);
assert!(presented
.bus
.idle_memory_range_is_journal_safe(source, destination, 4));
for (i, word) in words.into_iter().enumerate() {
presented.bus.write_word(code + i as u32 * 2, word);
}
presented.bus.write_long(source, 0x1234_5678);
presented.bus.write_long(destination, 0x1234_5678);
presented.m68k.cpu.write_reg(Register::PC, code);
presented.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
presented.bus.write_long(0x016A, 100);
presented.set_guest_tick_for_test(100);
presented.set_instructions_per_tick(100_000);
presented.dispatcher.set_sent_open_app_event_for_test(true);
let (_, running) = presented.run_steps_internal(
20_000,
Some(100),
0,
true,
false,
FrameFinalization::Deferred,
);
assert!(running);
assert!(
presented.idle_cycle_sleep.is_some(),
"unobserved presentation copy should park"
);
presented
.bus
.set_idle_test_superseded_store(Some(destination));
assert!(
!presented.try_resume_proven_idle_cycle(Some(102)),
"pending presentation store must revoke the proof"
);
assert!(!presented
.bus
.idle_memory_range_is_journal_safe(source, destination, 4));
presented.bus.set_idle_test_superseded_store(None);
presented
.bus
.enable_outline_presentation((source, 16, 16, 16, 8), [[0; 3]; 256], 2);
assert!(!presented
.bus
.idle_memory_range_is_journal_safe(source, destination, 4));
let mut foreign = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
assert!(foreign
.bus
.idle_memory_range_is_journal_safe(source, destination, 4));
let memory = PpcSectionMem::new();
foreign.bus.attach_guest_address_space(memory.shared_view());
assert!(
!foreign
.bus
.idle_memory_range_is_journal_safe(source, destination, 4),
"cross-ISA writes can bypass the classic bus journal"
);
}
#[test]
fn resident_getresource_cycle_rechecks_shared_state_and_guest_pointer() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let ptr = 0x0020_0000u32;
let handle = 0x0020_0100u32;
let kind = *b"STR#";
let id = 150;
runner.dispatcher.register_empty_resource_file(5);
runner
.dispatcher
.set_current_resource_refnum(&mut runner.bus, 5);
runner
.dispatcher
.insert_resource_pointer_for_test(5, (kind, id), ptr);
runner
.dispatcher
.insert_loaded_resource_handle_for_test(handle, (ptr, kind, id));
runner
.dispatcher
.insert_resource_handle_file_for_test(handle, 5);
runner
.dispatcher
.remember_resource_handle_index(handle, 5, kind, id);
runner.dispatcher.with_resource_manager_mut(|manager| {
manager.resident_resources.insert((5, kind, id));
});
runner.dispatcher.track_handle_ptr(ptr, handle);
runner.dispatcher.set_handle_state_bits(handle, 0x20);
runner.bus.write_long(handle, ptr);
let proof = runner
.idle_resident_resource(kind, id)
.expect("resident fixed point");
runner.dispatcher.register_empty_resource_file(9);
runner
.dispatcher
.set_current_resource_refnum(&mut runner.bus, 9);
runner
.dispatcher
.insert_resource_backing_data_for_test((9, kind, id), vec![1]);
assert!(
runner.idle_resident_resource(kind, id).is_none(),
"a higher-priority file may need a reload"
);
runner.dispatcher.with_resource_manager_mut(|manager| {
manager.resource_backing_data.remove(&(9, kind, id));
});
assert_eq!(runner.idle_resident_resource(kind, id), Some(proof.clone()));
runner
.dispatcher
.set_current_resource_refnum(&mut runner.bus, 5);
assert!(runner.idle_memory_guard(u32::MAX - 4, 10).is_none());
runner.dispatcher.set_handle_state_bits(handle, 0);
assert!(runner.idle_resident_resource(kind, id).is_none());
runner.dispatcher.set_handle_state_bits(handle, 0x20);
runner.dispatcher.untrack_handle_ptr(ptr);
assert!(runner.idle_resident_resource(kind, id).is_none());
runner.dispatcher.track_handle_ptr(ptr, handle);
runner.dispatcher.with_resource_manager_mut(|manager| {
manager.resident_resources.remove(&(5, kind, id));
});
assert!(runner.idle_resident_resource(kind, id).is_none());
runner.dispatcher.with_resource_manager_mut(|manager| {
manager.resident_resources.insert((5, kind, id));
});
runner.bus.write_long(handle, 0);
assert!(runner.idle_resident_resource(kind, id).is_none());
runner.bus.write_long(handle, ptr);
assert_eq!(runner.idle_resident_resource(kind, id), Some(proof.clone()));
let words = [
0x594F, 0xA975, 0x588F, 0x598F, 0x2F3C, 0x5354, 0x5223, 0x3F3C, 150, 0xA9A0, 0x588F,
0x6000, 0xFFE8,
];
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(100_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
let (_, running) = runner.run_steps_internal(
20_000,
Some(100),
0,
true,
false,
FrameFinalization::Deferred,
);
assert!(running);
assert!(
runner.idle_cycle_sleep.is_some(),
"stable resource cycle should park"
);
runner.dispatcher.untrack_handle_ptr(ptr);
assert!(
!runner.try_resume_proven_idle_cycle(Some(102)),
"host handle changes must revoke the proof"
);
runner.dispatcher.track_handle_ptr(ptr, handle);
assert_eq!(runner.idle_resident_resource(kind, id), Some(proof));
runner
.dispatcher
.install_trap_address(&mut runner.bus, 0xA9A0, 0x0030_0000)
.unwrap();
assert!(runner.idle_query_has_unsafe_dispatch(0xA9A0));
assert!(runner.idle_query_has_unsafe_dispatch(0xADA0));
}
#[test]
fn stable_menu_mutations_park_and_recheck_host_mirror() {
use crate::trap::menu::{IdleMenuMutation, Menu, MenuItem};
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let text = 0x0021_0000u32;
let handle = runner.bus.alloc(4);
let pointer = runner.bus.alloc(128);
let mut record = crate::menu_manager::new_standard_menu_record(100, 0, b"Edit");
record.pop();
record.extend_from_slice(&[4, b'U', b'n', b'd', b'o', 0, 0, 0, 0, 0]);
record[10..14].copy_from_slice(&0xFFFF_FFFDu32.to_be_bytes());
runner.bus.write_long(handle, pointer);
runner.bus.write_bytes(pointer, &record);
runner.bus.write_bytes(text, &[4, b'U', b'n', b'd', b'o']);
runner.dispatcher.menus.push(Menu {
id: 100,
title: "Edit".into(),
items: vec![MenuItem {
text: "Undo".into(),
icon: 0,
key_equiv: 0,
mark: 0,
style: 0,
enabled: false,
}],
enabled: true,
handle,
in_menu_bar: true,
hierarchical: false,
visible_in_menu_bar: true,
});
let disabled = IdleMenuMutation::Disable(1);
let set_text = IdleMenuMutation::SetText(1, b"Undo".to_vec());
assert!(runner
.dispatcher
.idle_menu_proof(&runner.bus, handle, disabled.clone())
.is_some());
assert!(runner
.dispatcher
.idle_menu_proof(&runner.bus, handle, set_text.clone())
.is_some());
assert!(runner
.dispatcher
.idle_menu_proof(
&runner.bus,
handle,
IdleMenuMutation::SetText(1, b"Redo".to_vec())
)
.is_none());
runner.dispatcher.menus[0].items[0].text = "Stale".into();
assert!(runner
.dispatcher
.idle_menu_proof(&runner.bus, handle, disabled.clone())
.is_none());
runner.dispatcher.menus[0].items[0].text = "Undo".into();
runner.bus.write_long(pointer + 10, 0xFFFF_FFFF);
assert!(runner
.dispatcher
.idle_menu_proof(&runner.bus, handle, disabled.clone())
.is_none());
runner.bus.write_long(pointer + 10, 0xFFFF_FFFD);
let mut words = vec![
0x594F,
0xA975,
0x588F,
0x2F3C,
(handle >> 16) as u16,
handle as u16,
0x3F3C,
1,
0xA93A,
0x2F3C,
(handle >> 16) as u16,
handle as u16,
0x3F3C,
1,
0x4879,
(text >> 16) as u16,
text as u16,
0xA947,
0x6000,
];
words.push((-(words.len() as i32 * 2) as i16) as u16);
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(100_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
let (_, running) = runner.run_steps_internal(
20_000,
Some(100),
0,
true,
false,
FrameFinalization::Deferred,
);
assert!(running);
assert!(
runner.idle_cycle_sleep.is_some(),
"stable menu loop should park"
);
runner.dispatcher.menus[0].items[0].enabled = true;
assert!(
!runner.try_resume_proven_idle_cycle(Some(102)),
"host menu changes must revoke the proof"
);
runner
.dispatcher
.install_trap_address(&mut runner.bus, 0xA93A, 0x0030_0000)
.unwrap();
assert!(runner.idle_query_has_unsafe_dispatch(0xA93A));
assert!(runner.idle_query_has_unsafe_dispatch(0xAD3A));
runner
.dispatcher
.install_trap_address(&mut runner.bus, 0xA947, 0x0030_0100)
.unwrap();
assert!(runner.idle_query_has_unsafe_dispatch(0xA947));
assert!(runner.idle_query_has_unsafe_dispatch(0xAD47));
}
#[test]
fn deferred_idle_probe_guards_slice_exit_state_and_pending_events() {
fn arm() -> FixtureRunner {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
runner.bus.write_word(code, 0x4E71); runner.bus.write_word(code + 2, 0x4E71);
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.dispatcher.set_sent_open_app_event_for_test(true);
assert!(!runner.try_exact_idle_cycle_fastfwd(code, 101, Some(100)));
assert!(!runner.try_exact_idle_cycle_fastfwd(code, 101, Some(100)));
assert!(runner.idle_cycle_probe.is_some());
runner
}
let mut runner = arm();
runner
.dispatcher
.current_port
.with_mut(|port| *port = 0x0020_0000);
let slice_host = IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.idle_cycle_probe.as_mut().unwrap().slice_host = Some(slice_host);
let (_, running) =
runner.run_steps_internal(1, Some(100), 0, true, false, FrameFinalization::Deferred);
assert!(running);
assert!(
runner.idle_cycle_probe.is_some(),
"unchanged intermediate state must survive a deferred boundary"
);
runner
.dispatcher
.current_port
.with_mut(|port| *port = 0x0020_0100);
runner.run_steps_internal(1, Some(100), 0, true, false, FrameFinalization::Deferred);
assert!(
runner.idle_cycle_probe.is_none(),
"frontend host changes must cancel the proof"
);
let mut pending = arm();
let slice_host = IdleCycleHostSnapshot::capture(&pending.dispatcher);
pending.idle_cycle_probe.as_mut().unwrap().slice_host = Some(slice_host);
pending
.dispatcher
.event_queue
.push_back(crate::event_queue::QueuedEvent {
what: 1,
message: 0,
when: 0,
where_v: 10,
where_h: 20,
modifiers: 0,
});
pending.run_steps_internal(1, Some(100), 0, true, false, FrameFinalization::Deferred);
assert!(
pending.idle_cycle_probe.is_none(),
"a newly pending event must cancel the proof"
);
let launch = arm();
launch
.dispatcher
.apple_event_launch_state
.reset_for_launch(true);
assert!(!launch
.dispatcher
.apple_event_launch_state
.is_open_application_event_sent());
assert!(launch.idle_slice_has_pending_events());
assert!(
!launch
.dispatcher
.apple_event_launch_state
.is_open_application_event_sent(),
"the guard must not claim the launch event"
);
assert!(
launch.dispatcher.event_queue.is_empty(),
"the guard must not enqueue events"
);
let mut stale = arm();
stale
.dispatcher
.flushed_update_events
.push_back(crate::event_queue::QueuedEvent {
what: 6,
message: 0x0030_0000,
when: 0,
where_v: 0,
where_h: 0,
modifiers: 0,
});
assert!(!stale.idle_slice_has_pending_events());
assert_eq!(
stale.dispatcher.flushed_update_events.len(),
1,
"the guard must not prune stale update markers"
);
}
#[test]
fn real_setport_cycle_can_close_across_single_instruction_slices() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
let code = 0x0002_0000u32;
let original = 0x0020_0000u32;
let temporary = 0x0020_0100u32;
runner
.dispatcher
.current_port
.with_mut(|port| *port = original);
runner
.bus
.write_long(crate::memory::globals::addr::THE_PORT, original);
let mut words = vec![
0x594F,
0xA975,
0x588F,
0x4879,
(temporary >> 16) as u16,
temporary as u16,
0xA873,
0x4879,
(original >> 16) as u16,
original as u16,
0xA873,
0x6000,
];
words.push((-(words.len() as i32 * 2) as i16) as u16);
for (i, word) in words.into_iter().enumerate() {
runner.bus.write_word(code + i as u32 * 2, word);
}
runner.m68k.cpu.write_reg(Register::PC, code);
runner.m68k.cpu.write_reg(Register::A7, 0x0010_0000);
runner.bus.write_long(0x016A, 100);
runner.set_guest_tick_for_test(100);
runner.set_instructions_per_tick(100_000);
runner.dispatcher.set_sent_open_app_event_for_test(true);
let mut saw_temporary_probe = false;
for _ in 0..4_000 {
let (_, running) = runner.run_gui_cpu_slice_until_host_work(1, 100);
assert!(running);
saw_temporary_probe |=
runner.idle_cycle_probe.is_some() && *runner.dispatcher.current_port == temporary;
if runner.idle_cycle_sleep.is_some() {
break;
}
}
assert!(
saw_temporary_probe,
"the real SetPort must cross a deferred boundary"
);
assert!(
runner.idle_cycle_sleep.is_some(),
"restored port cycle should close and park"
);
assert_eq!(*runner.dispatcher.current_port, original);
}