use super::*;
pub(crate) fn test_menu_resource(menu_id: i16, title: &[u8]) -> Vec<u8> {
test_menu_resource_with_mdef(menu_id, 0, title)
}
pub(crate) fn test_menu_resource_with_mdef(menu_id: i16, mdef_id: i16, title: &[u8]) -> Vec<u8> {
let mut data = vec![0; 14];
data[0..2].copy_from_slice(&menu_id.to_be_bytes());
data[6..8].copy_from_slice(&mdef_id.to_be_bytes());
data[10..14].copy_from_slice(&u32::MAX.to_be_bytes());
data.push(title.len() as u8);
data.extend_from_slice(title);
data.push(0);
data
}
pub(crate) fn test_menu_color_entry(menu_id: i16, item: i16, seed: u8) -> [u8; 30] {
let mut entry = [seed; 30];
entry[0..2].copy_from_slice(&menu_id.to_be_bytes());
entry[2..4].copy_from_slice(&item.to_be_bytes());
entry
}
pub(crate) fn test_menu_color_resource(entries: &[[u8; 30]]) -> Vec<u8> {
let mut data = i16::try_from(entries.len()).unwrap().to_be_bytes().to_vec();
for entry in entries {
data.extend_from_slice(entry);
}
data
}
pub(crate) fn install_test_menu(
loaded: &mut PpcLoadedApp,
scratch: u32,
menu_id: i16,
title: &[u8],
item_specs: &[u8],
) -> u32 {
let mut free_handle_blocks = loaded.free_handle_blocks();
loaded.memory.add_region(scratch, vec![0; 0x200]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, scratch, title));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x80,
item_specs,
));
let menu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu_id,
scratch,
);
assert_ne!(menu, 0);
if !item_specs.is_empty() {
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
scratch + 0x80,
i16::MAX,
),
PPC_NO_ERR,
);
}
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
0,
),
PPC_NO_ERR,
);
menu
}
pub(crate) fn install_test_popup_menu(
loaded: &mut PpcLoadedApp,
scratch: u32,
menu_id: i16,
title: &[u8],
item_specs: &[u8],
) -> u32 {
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu = install_test_menu(loaded, scratch, menu_id, title, item_specs);
let current_menu_list = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
current_menu_list,
menu_id,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
-1,
),
PPC_NO_ERR,
);
menu
}
pub(crate) fn draw_current_test_menu_bar(loaded: &mut PpcLoadedApp) -> bool {
let menu_list = ppc_current_menu_list(&mut loaded.memory);
let menu_color_bytes =
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded));
ppc_draw_menu_bar_with_colors(
&mut loaded.memory,
&loaded.gworlds,
menu_list,
&loaded.screen_clut,
MenuColorTable::new(&menu_color_bytes),
)
}
pub(crate) struct CrossAbiMenuSelectFixture {
pub(crate) app: PpcLoadedApp,
pub(crate) root_menu: u32,
pub(crate) root_record: u32,
pub(crate) mdef_entry: u32,
pub(crate) callback_marker: u32,
pub(crate) title_h: i16,
}
pub(crate) fn cross_abi_menu_select_fixture() -> CrossAbiMenuSelectFixture {
const ROOT_MENU_ID: i16 = 140;
const CHILD_MENU_ID: i16 = 141;
const TARGET_ITEM: i16 = 2;
const MDEF_HANDLE: u32 = PPC_DATA_BASE + 0x7000;
const MDEF_ENTRY: u32 = PPC_DATA_BASE + 0x7100;
const CALLBACK_MARKER: u32 = PPC_DATA_BASE + 0x7200;
const CALLBACK_VALUE: u32 = 0x68c0_ab1e;
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let root_menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
ROOT_MENU_ID,
b"File",
b"Custom child;Disabled after callback",
);
let child_menu = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1400,
CHILD_MENU_ID,
b"Child",
b"Choice",
);
loaded.cpu.gpr[3] = root_menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x1b;
ppc_set_item_cmd(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
loaded.cpu.gpr[5] = CHILD_MENU_ID as u32;
ppc_set_item_mark(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
let root_record = loaded.memory.read_u32_be(root_menu).unwrap();
let child_record = loaded.memory.read_u32_be(child_menu).unwrap();
loaded.memory.write_u16_be(child_record + 2, 72).unwrap();
loaded.memory.write_u16_be(child_record + 4, 32).unwrap();
loaded.memory.add_region(MDEF_HANDLE, vec![0; 4]);
loaded.memory.add_region(CALLBACK_MARKER, vec![0; 4]);
let mut mdef = Vec::new();
mdef.extend_from_slice(&0x2f3cu16.to_be_bytes()); mdef.extend_from_slice(&root_menu.to_be_bytes());
mdef.extend_from_slice(&0x3f3cu16.to_be_bytes()); mdef.extend_from_slice(&(TARGET_ITEM as u16).to_be_bytes());
mdef.extend_from_slice(&0xa93au16.to_be_bytes()); mdef.extend_from_slice(&0x23fcu16.to_be_bytes()); mdef.extend_from_slice(&CALLBACK_VALUE.to_be_bytes());
mdef.extend_from_slice(&CALLBACK_MARKER.to_be_bytes());
mdef.extend_from_slice(&0x4e74u16.to_be_bytes()); mdef.extend_from_slice(&0x0012u16.to_be_bytes());
loaded.memory.add_region(MDEF_ENTRY, mdef.clone());
loaded.memory.write_u32_be(MDEF_HANDLE, MDEF_ENTRY).unwrap();
loaded
.memory
.write_u32_be(child_record + 6, MDEF_HANDLE)
.unwrap();
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Cross-ABI menu fixture".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 512,
name: Vec::new(),
data: mdef.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: MDEF_HANDLE,
});
assert!(draw_current_test_menu_bar(&mut loaded));
let title_h = STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2;
loaded.cpu.gpr[3] = (u32::from(10u16) << 16) | u32::from(title_h as u16);
CrossAbiMenuSelectFixture {
app: loaded,
root_menu,
root_record,
mdef_entry: MDEF_ENTRY,
callback_marker: CALLBACK_MARKER,
title_h,
}
}
#[test]
fn menu_accessors_parse_item_count_text_and_command() {
let menu_handle = 0x1000;
let menu = 0x1100;
let output = 0x1200;
let menu_list_handle = 0x1300;
let menu_list = 0x1400;
let mut memory = PpcSectionMem::new();
memory.add_region(menu_handle, vec![0; 4]);
memory.add_region(menu, vec![0; 64]);
memory.add_region(output, vec![0; 256]);
memory.add_region(menu_list_handle, vec![0; 4]);
memory.add_region(menu_list, vec![0; 18]);
memory.write_u32_be(menu_handle, menu).unwrap();
memory.write_u16_be(menu, 128).unwrap();
memory.write_u32_be(menu + 10, 0b111).unwrap();
memory.write_u32_be(menu_list_handle, menu_list).unwrap();
memory.write_u16_be(menu_list, 6).unwrap();
memory.write_u32_be(menu_list + 6, menu_handle).unwrap();
memory.write_u8(menu + 14, 4).unwrap();
memory.write_bytes(menu + 15, b"Test").unwrap();
memory.write_u8(menu + 19, 3).unwrap();
memory.write_bytes(menu + 20, b"Run").unwrap();
memory.write_u8(menu + 24, b'R').unwrap();
memory.write_u8(menu + 27, 4).unwrap();
memory.write_bytes(menu + 28, b"Quit").unwrap();
memory.write_u8(menu + 33, b'Q').unwrap();
memory.write_u8(menu + 36, 0).unwrap();
assert_eq!(ppc_count_menu_items(&mut memory, menu_handle), 2);
let unterminated_handle = 0x1500;
let unterminated_menu = 0x1600;
memory.add_region(unterminated_handle, vec![0; 4]);
memory.add_region(unterminated_menu, vec![0; 24]);
memory
.write_u32_be(unterminated_handle, unterminated_menu)
.unwrap();
memory
.write_u32_be(unterminated_menu + 10, u32::MAX)
.unwrap();
memory.write_u8(unterminated_menu + 14, 0).unwrap();
memory.write_u8(unterminated_menu + 15, 4).unwrap();
memory.write_bytes(unterminated_menu + 16, b"Open").unwrap();
memory
.write_bytes(unterminated_menu + 20, &[0, b'O', 0, 0])
.unwrap();
assert_eq!(
ppc_count_menu_items(&mut memory, unterminated_handle),
0,
"both adapters must reject the same unterminated MenuInfo sequence"
);
let mut cpu = PpcCpu::new();
cpu.gpr[3] = menu_handle;
cpu.gpr[4] = 2;
cpu.gpr[5] = output;
ppc_get_menu_item_text(&cpu, &mut memory);
assert_eq!(memory.read_u8(output), Some(4));
assert_eq!(
ppc_memory_read_bytes(&mut memory, output + 1, 4),
Some(b"Quit".to_vec())
);
ppc_get_item_cmd(&cpu, &mut memory);
assert_eq!(memory.read_u16_be(output), Some(u16::from(b'Q')));
assert_eq!(
ppc_menu_key(&mut memory, menu_list_handle, b'r')
.map_or(0, MenuKeySelection::packed_result),
(128 << 16) | 1
);
cpu.gpr[5] = 0x1b;
let handles = [PpcHandleRecord {
handle: menu_handle,
ptr: menu,
size: 64,
capacity: 64,
}];
ppc_set_item_cmd(&cpu, &mut memory, &handles);
cpu.gpr[5] = output;
ppc_get_item_cmd(&cpu, &mut memory);
assert_eq!(memory.read_u16_be(output), Some(0x1b));
}
#[test]
fn menu_event_resolves_command_key_events_only() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"MenuEvent")).unwrap();
install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Game",
b"Start/S",
);
let event = PPC_DATA_BASE + 0x2000;
loaded.memory.add_region(event, vec![0; 16]);
loaded.memory.write_u16_be(event, 3).unwrap();
loaded.memory.write_u32_be(event + 2, u32::from(b's')).unwrap();
loaded.memory.write_u16_be(event + 14, 0x0100).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
loaded.memory.write_u16_be(event + 14, 0).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn native_insert_menu_preserves_regular_and_hierarchical_partitions() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
let regular_title = scratch;
let hierarchical_title = scratch + 0x20;
let regular_items = scratch + 0x40;
let hierarchical_items = scratch + 0x60;
loaded.memory.add_region(scratch, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
regular_title,
b"File"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
hierarchical_title,
b"Recent"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
regular_items,
b"Open/O"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
hierarchical_items,
b"Document/D"
));
let regular = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
regular_title,
);
let hierarchical = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
hierarchical_title,
);
assert_ne!(regular, 0);
assert_ne!(hierarchical, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
regular,
regular_items,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
hierarchical,
hierarchical_items,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
regular,
0,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
hierarchical,
-1,
),
PPC_NO_ERR
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
assert_ne!(menu_list_handle, 0);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(menu_list_handle)
);
let menu_list = loaded.memory.read_u32_be(menu_list_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_list), Some(6));
assert_eq!(loaded.memory.read_u32_be(menu_list + 6), Some(regular));
assert_eq!(
loaded.memory.read_u16_be(menu_list + 10),
Some(STANDARD_MENU_BAR_FIRST_TITLE_LEFT as u16)
);
assert_eq!(loaded.memory.read_u16_be(menu_list + 12), Some(6));
assert_eq!(loaded.memory.read_u32_be(menu_list + 14), Some(0));
assert_eq!(
loaded.memory.read_u32_be(menu_list + 18),
Some(hierarchical)
);
assert_eq!(loaded.memory.read_u16_be(menu_list + 22), Some(0));
assert_eq!(
loaded
.handles()
.iter()
.find(|record| record.handle == menu_list_handle)
.map(|record| record.size),
Some(24)
);
let definition = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle).unwrap();
assert_eq!(
definition.regular,
vec![PpcMenuListEntry {
handle: regular,
value: STANDARD_MENU_BAR_FIRST_TITLE_LEFT,
}]
);
assert_eq!(
definition.hierarchical,
vec![PpcMenuListEntry {
handle: hierarchical,
value: 0,
}]
);
let snapshot = ppc_guest_menu_snapshot(&mut loaded.memory, menu_list_handle);
assert_eq!(snapshot.menus.len(), 2);
assert!(!snapshot.menus[0].hierarchical);
assert!(snapshot.menus[0].visible_in_menu_bar);
assert!(snapshot.menus[1].hierarchical);
assert!(!snapshot.menus[1].visible_in_menu_bar);
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 200),
hierarchical
);
assert_eq!(
ppc_menu_key(&mut loaded.memory, menu_list_handle, b'd')
.map_or(0, MenuKeySelection::packed_result),
(200 << 16) | 1
);
let regular_command =
ppc_menu_item_attribute_address(&mut loaded.memory, regular, 1, 1).unwrap();
loaded.memory.write_u8(regular_command, b'D').unwrap();
assert_eq!(
ppc_menu_key(&mut loaded.memory, menu_list_handle, b'd')
.map_or(0, MenuKeySelection::packed_result),
(128 << 16) | 1,
"regular menus must be searched before the hierarchical partition"
);
loaded.memory.write_u8(regular_command, b'O').unwrap();
let command = ppc_menu_item_attribute_address(&mut loaded.memory, regular, 1, 1).unwrap();
let mark = ppc_menu_item_attribute_address(&mut loaded.memory, regular, 1, 2).unwrap();
loaded.memory.write_u8(command, 0x1B).unwrap();
loaded.memory.write_u8(mark, 200).unwrap();
assert_eq!(
ppc_submenu_handle_for_item(&mut loaded.memory, menu_list_handle, regular, 1),
Some(hierarchical),
"submenu resolution must find the matching hierarchical entry"
);
loaded.memory.write_u16_be(menu_list + 2, 80).unwrap();
loaded.memory.write_u16_be(menu_list + 10, 40).unwrap();
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 39),
None
);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 40),
Some((regular, 40)),
"PPC title hits must use the live guest menuLeft"
);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 79),
Some((regular, 40))
);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list_handle, 80),
None
);
loaded
.memory
.write_u16_be(menu_list + 2, definition.last_right as u16)
.unwrap();
loaded
.memory
.write_u16_be(menu_list + 10, definition.regular[0].value as u16)
.unwrap();
let first_non_title_h = definition.last_right.saturating_add(1);
assert_eq!(
ppc_menu_handle_at_title_point(
&mut loaded.memory,
menu_list_handle,
first_non_title_h as u16 as u32,
),
None
);
let menu_bar_bytes = 20 * ppc_main_screen_row_bytes();
assert!(loaded
.memory
.write_bytes(PPC_MAIN_SCREEN_BASE, &vec![0x55; menu_bar_bytes as usize])
.is_some());
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
menu_list_handle,
&loaded.screen_clut,
));
let with_hierarchical =
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_bytes)
.unwrap();
let regular_only = ppc_alloc_menu_list_definition_handle(
&PpcMenuListDefinition {
last_right: definition.last_right,
regular: definition.regular.clone(),
..PpcMenuListDefinition::default()
},
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(regular_only, 0);
assert_eq!(
ppc_submenu_handle_for_item(&mut loaded.memory, regular_only, regular, 1),
None,
"a detached or regular-only ID match must not resolve as a submenu"
);
assert!(loaded
.memory
.write_bytes(PPC_MAIN_SCREEN_BASE, &vec![0x55; menu_bar_bytes as usize])
.is_some());
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
regular_only,
&loaded.screen_clut,
));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_bytes,),
Some(with_hierarchical)
);
let before_duplicate =
ppc_menu_list_definition(&mut loaded.memory, menu_list_handle).unwrap();
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
hierarchical,
0,
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, menu_list_handle),
Some(before_duplicate),
"reinserting a current menu must be a no-op"
);
}
#[test]
fn native_draw_menu_bar_uses_live_shared_title_geometry() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let menu_list = loaded.memory.read_u32_be(menu_list_handle).unwrap();
loaded.memory.write_u16_be(menu_list + 2, 90).unwrap();
loaded.memory.write_u16_be(menu_list + 6 + 4, 50).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let black = ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut)
.expect("black screen pixel");
let mut contains_black = |left: i16, right: i16| {
(2..18).any(|y| {
(left..right).any(|x| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(x), i32::from(y)),
) == Some(black)
})
})
};
assert!(
!contains_black(
STANDARD_MENU_BAR_FIRST_TITLE_LEFT + STANDARD_MENU_BAR_TITLE_ORIGIN_INSET,
40,
),
"drawing must not retain the independently reconstructed title origin"
);
assert!(
contains_black(57, 80),
"drawing must place title artwork from the live menuLeft"
);
}
#[test]
fn native_draw_hilite_and_flash_menu_bar_use_live_shared_menu_colors() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
let set_rgb = |entry: &mut [u8; MENU_COLOR_ENTRY_SIZE], offset: usize, rgb: [u16; 3]| {
for (channel, value) in rgb.into_iter().enumerate() {
let channel_offset = offset + channel * 2;
entry[channel_offset..channel_offset + 2].copy_from_slice(&value.to_be_bytes());
}
};
let bar_background = [0xffff, 0x1111, 0x1111];
let inherited_title = [0x1111, 0xffff, 0x1111];
let live_title = [0x1111, 0x1111, 0xffff];
let title_background = [0xffff, 0xffff, 0xffff];
let mut bar = test_menu_color_entry(0, 0, 0);
set_rgb(&mut bar, 4, inherited_title);
set_rgb(&mut bar, 22, bar_background);
let mut title = test_menu_color_entry(128, 0, 0);
set_rgb(&mut title, 4, inherited_title);
set_rgb(&mut title, 10, title_background);
let color_bytes = [bar.as_slice(), title.as_slice()].concat();
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(color_handle, 0);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&color_bytes,
),
PPC_NO_ERR,
);
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let bar_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(bar_background),
&loaded.screen_clut,
)
.unwrap();
let inherited_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(inherited_title),
&loaded.screen_clut,
)
.unwrap();
let live_pixel =
ppc_physical_screen_color_pixel(front, ppc_menu_rgb(live_title), &loaded.screen_clut)
.unwrap();
let title_background_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(title_background),
&loaded.screen_clut,
)
.unwrap();
assert_ne!(bar_pixel, inherited_pixel);
assert_ne!(bar_pixel, live_pixel);
assert_ne!(bar_pixel, title_background_pixel);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (120, 5)),
Some(bar_pixel),
"DrawMenuBar did not use the menu-bar entry RGB4",
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let region = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle)
.unwrap()
.regular_title_regions()
.into_iter()
.next()
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(region.left - 1), 2)),
Some(title_background_pixel),
"DrawMenuBar did not use the title entry RGB2 for its title cell",
);
let title_pixel = (1..19)
.flat_map(|y| (region.left..region.right).map(move |x| (x, y)))
.find(|&(x, y)| {
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(x), i32::from(y)))
== Some(inherited_pixel)
})
.expect("inherited green title ink");
let color_data = loaded.memory.read_u32_be(color_handle).unwrap();
for (channel, value) in live_title.into_iter().enumerate() {
loaded
.memory
.write_u16_be(
color_data + MENU_COLOR_ENTRY_SIZE as u32 + 4 + channel as u32 * 2,
value,
)
.unwrap();
}
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(title_pixel.0), i32::from(title_pixel.1)),
),
Some(live_pixel),
"DrawMenuBar did not reread the guest-mutated title entry",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(title_pixel.0), i32::from(title_pixel.1)),
),
Some(title_background_pixel),
"HiliteMenu did not reverse the live title foreground",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(region.left - 1), 2),),
Some(live_pixel),
"HiliteMenu did not reverse the live title background",
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
let menu_bar_bytes = front.row_bytes * 20;
let normal =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (120, 5)),
Some(inherited_pixel),
"FlashMenuBar did not reverse live RGB4 through default RGB1",
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(title_pixel.0), i32::from(title_pixel.1)),
),
Some(live_pixel),
"FlashMenuBar changed a title-specific RGB1 pixel",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (i32::from(region.left - 1), 2)),
Some(title_background_pixel),
"FlashMenuBar changed a title-specific RGB2 pixel",
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal),
"two live-color FlashMenuBar calls did not restore the menu bar",
);
}
#[test]
fn native_draw_menu_bar_dims_disabled_titles_with_shared_gray_policy() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let city = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1400, 129, b"City", b"Map");
ppc_set_menu_item_enabled(
&mut loaded.memory,
&test_handle_records!(loaded),
city,
0,
false,
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let regions = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle)
.unwrap()
.regular_title_regions();
assert_eq!(regions.len(), 2);
let baseline = i32::from(ppc_menu_bar_title_baseline(20));
let title_glyph_pixels = |title: &[u8], origin_x: i16| {
let mut cursor = i32::from(origin_x);
let mut pixels = Vec::new();
for byte in title {
let (glyph, data) = get_glyph(
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
char::from(*byte),
)
.unwrap();
for row in 0..glyph.height as usize {
for column in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + column;
if index < data.len() && data[index] >= 128 {
pixels.push((
cursor + i32::from(glyph.origin_x) + column as i32,
baseline + i32::from(glyph.origin_y) + row as i32,
));
}
}
}
cursor += i32::from(glyph.advance);
}
assert!(!pixels.is_empty());
pixels
};
let file_pixels = title_glyph_pixels(b"File", regions[0].title_origin());
let city_pixels = title_glyph_pixels(b"City", regions[1].title_origin());
for depth in [1, 8] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let gray = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(MenuColorTable::dimmed([0; 3], [u16::MAX; 3])),
&loaded.screen_clut,
)
.unwrap();
let read = |memory: &mut PpcSectionMem, point: &(i32, i32)| {
ppc_quickdraw_read_pixel(memory, front, *point).unwrap()
};
assert!(
file_pixels
.iter()
.all(|point| read(&mut loaded.memory, point) == black),
"{depth}bpp enabled title did not remain solid black",
);
if depth == 8 {
assert_ne!(gray, black);
assert_ne!(gray, white);
assert!(
city_pixels
.iter()
.all(|point| read(&mut loaded.memory, point) == gray),
"8bpp disabled title did not use the GetGray midpoint",
);
} else {
let city_ink = city_pixels
.iter()
.map(|point| read(&mut loaded.memory, point))
.collect::<Vec<_>>();
assert!(city_ink.contains(&black));
assert!(city_ink.contains(&white));
}
}
}
#[test]
fn native_draw_menu_bar_uses_the_shared_rounded_corner_mask() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let mut rounded_corner_pixels = Vec::new();
for_each_standard_menu_bar_corner_pixel(
ppc_u32_to_i16_saturating(front.width),
|x, y| rounded_corner_pixels.push((x, y)),
);
let right_start = i32::try_from(front.width).unwrap() - 6;
for y in 0..5 {
for x in (0..6).chain(right_start..i32::try_from(front.width).unwrap()) {
let expected = if rounded_corner_pixels.contains(&(x as i16, y as i16)) {
black
} else {
white
};
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (x, y)),
Some(expected),
"{depth}bpp rounded corner mask pixel ({x}, {y})",
);
}
}
}
}
#[test]
fn native_delete_menu_prefers_hierarchical_id_collisions() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 0x40]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch,
b"Regular"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x20,
b"Submenu"
));
let regular = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
scratch,
);
let hierarchical = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
scratch + 0x20,
);
for (handle, before_id) in [(regular, 0), (hierarchical, -1)] {
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
handle,
before_id,
),
PPC_NO_ERR
);
}
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 200),
hierarchical,
"GetMenuHandle must resolve the hierarchical collision first"
);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_list_handle,
200,
),
PPC_NO_ERR
);
let after_hierarchical_delete =
ppc_menu_list_definition(&mut loaded.memory, menu_list_handle).unwrap();
assert_eq!(
after_hierarchical_delete
.regular_handles()
.collect::<Vec<_>>(),
vec![regular]
);
assert!(after_hierarchical_delete.hierarchical.is_empty());
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 200),
regular
);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_list_handle,
200,
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, menu_list_handle),
Some(Vec::new())
);
}
#[test]
fn native_insert_menu_does_not_evict_entries_from_a_full_partition() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 0x40]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch,
b"Existing"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x20,
b"Insert"
));
let existing = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
200,
scratch,
);
let insertion = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x20,
);
let mut regular = vec![
PpcMenuListEntry {
handle: 0xdead_0000,
value: 0,
};
MAX_MENU_LIST_ENTRIES - 1
];
regular.push(PpcMenuListEntry {
handle: existing,
value: 0,
});
let full = PpcMenuListDefinition {
regular,
..PpcMenuListDefinition::default()
};
let current = ppc_alloc_menu_list_definition_handle(
&full,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
insertion,
200,
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(full)
);
}
#[test]
fn quickdraw_compatibility_menu_item_icon_and_style_accessors_round_trip() {
let scratch = PPC_DATA_BASE + 0x1000;
for (symbol, operation, initial, replacement, attribute_offset) in [
(b"GetItemIcon".as_slice(), PpcQuickDrawCompatibilityOperation::GetItemIcon, 7u8, 0u8, 0u32),
(b"SetItemIcon".as_slice(), PpcQuickDrawCompatibilityOperation::SetItemIcon, 7u8, 11u8, 0u32),
(b"GetItemStyle".as_slice(), PpcQuickDrawCompatibilityOperation::GetItemStyle, 3u8, 0u8, 3u32),
(b"SetItemStyle".as_slice(), PpcQuickDrawCompatibilityOperation::SetItemStyle, 3u8, 0x25u8, 3u32),
] {
let pef = synthetic_pef_with_import(symbol);
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::QuickDrawCompatibility(operation),
);
let item = if attribute_offset == 0 {
b"Item^7".as_slice()
} else {
b"Item<B<I".as_slice()
};
let menu = install_test_menu(&mut loaded, scratch, 128, b"File", item);
let output = scratch + 0x300;
loaded.memory.add_region(output, vec![0xa5; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = if symbol.starts_with(b"Get") {
output
} else {
u32::from(replacement)
};
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let address =
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, attribute_offset)
.unwrap();
if symbol.starts_with(b"Get") {
assert_eq!(loaded.memory.read_u8(output), Some(initial));
} else {
assert_eq!(loaded.memory.read_u8(address), Some(replacement));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[4] = 99;
if symbol.starts_with(b"Get") {
loaded.memory.write_u8(output, 0xa5).unwrap();
loaded.cpu.gpr[5] = output;
}
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
if symbol.starts_with(b"Get") {
assert_eq!(loaded.memory.read_u8(output), Some(0));
} else {
assert_eq!(loaded.memory.read_u8(address), Some(replacement));
}
}
}
#[test]
fn menu_bar_title_baseline_tracks_the_live_menu_bar_height() {
let metrics = crate::quickdraw::text::get_font_metrics(0, 12);
for height in [12, 20, 30] {
let baseline = ppc_menu_bar_title_baseline(height);
let top = baseline - metrics.ascent;
let bottom = height - baseline - metrics.descent;
assert!(
(top - bottom).abs() <= 1,
"title must be vertically centered"
);
}
assert_eq!(ppc_menu_bar_system_mark_top(12), 0);
assert_eq!(ppc_menu_bar_system_mark_top(20), 3);
assert_eq!(ppc_menu_bar_system_mark_top(30), 8);
}
#[test]
fn hilite_menu_selects_one_title_and_zero_restores_the_bar_at_supported_depths() {
let pef = synthetic_pef_with_import(b"HiliteMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let title = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(title, vec![0; 16]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, title, b"File"));
let menu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
title,
);
assert_ne!(menu, 0);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
0,
),
PPC_NO_ERR
);
let title_glyph_pixels = {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, 'F').unwrap();
let mut pixels = Vec::new();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
pixels.push((
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
));
}
}
}
assert!(!pixels.is_empty());
pixels
};
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.memory.write_u16_be(PPC_THE_MENU_ADDR, 0).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
assert_eq!(front.depth, depth);
let menu_bar_bytes = front.row_bytes * 20;
let normal =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let title_origin = (
i32::from(
STANDARD_MENU_BAR_FIRST_TITLE_LEFT + STANDARD_MENU_BAR_TITLE_ORIGIN_INSET,
),
i32::from(ppc_menu_bar_title_baseline(20)),
);
let normal_title_ink = title_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(title_origin.0 + dx, title_origin.1 + dy),
) == Some(black)
})
.count();
assert_eq!(
normal_title_ink,
title_glyph_pixels.len(),
"{depth}bpp menu title glyph did not draw in black",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
let highlighted =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
assert_ne!(highlighted, normal, "{depth}bpp title did not highlight");
let highlighted_title_ink = title_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(title_origin.0 + dx, title_origin.1 + dy),
) == Some(white)
})
.count();
assert_eq!(
highlighted_title_ink,
title_glyph_pixels.len(),
"{depth}bpp highlighted menu title glyph did not reverse to white",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(highlighted),
"{depth}bpp repeated HiliteMenu changed the title"
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HiliteMenu);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal),
"{depth}bpp HiliteMenu(0) did not restore the menu bar"
);
}
}
#[test]
fn native_flash_menu_bar_matches_whole_bar_and_title_semantics_at_supported_depths() {
let pef = synthetic_pef_with_import(b"FlashMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1400, 129, b"Edit", b"Cut");
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
let regions = ppc_menu_list_definition(&mut loaded.memory, menu_list_handle)
.unwrap()
.regular_title_regions();
assert_eq!(regions.len(), 2);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.memory.write_u16_be(PPC_THE_MENU_ADDR, 0).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let menu_bar_bytes = front.row_bytes * 20;
let normal =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
let file_cell = (i32::from(regions[0].left.saturating_add(3)), 2);
let edit_cell = (i32::from(regions[1].left.saturating_add(3)), 2);
let bar_point = (200, 5);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, file_cell),
Some(white),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, edit_cell),
Some(white),
);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, bar_point),
Some(black),
"{depth}bpp FlashMenuBar(0) did not reverse the bar background",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 0)),
Some(black),
"{depth}bpp FlashMenuBar(0) did not preserve the corner mask",
);
let whole_bar_flipped =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes).unwrap();
assert_ne!(whole_bar_flipped, normal);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal.clone()),
"{depth}bpp two whole-bar flashes did not restore the framebuffer",
);
loaded.cpu.gpr[3] = 999;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.cpu.gpr[3], 999);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(whole_bar_flipped),
"{depth}bpp unknown menu ID did not flash the complete bar",
);
loaded.cpu.gpr[3] = 999;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal.clone()),
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, file_cell),
Some(black),
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, edit_cell),
Some(white),
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal.clone()),
"{depth}bpp flashing the selected title did not toggle it off",
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(129));
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, file_cell),
Some(white),
"{depth}bpp previous title was not restored",
);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, edit_cell),
Some(black),
"{depth}bpp requested title was not highlighted",
);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FlashMenuBar);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_bytes),
Some(normal),
"{depth}bpp title switching did not restore the original bar",
);
}
}
#[test]
fn tracked_menu_draws_standard_item_chrome_and_dims_disabled_rows() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Checked!\x12;Command/C;Disabled/C!\x12(;-;Parent/\x1b!\xc9",
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let command_text_advance = ppc_text_bytes_advance_for_font(
b"Command",
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
);
assert!(
tracking.popup_width >= command_text_advance.saturating_add(53),
"command-key column overlaps item text"
);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
let gray = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(MenuColorTable::dimmed([0; 3], [u16::MAX; 3])),
&loaded.screen_clut,
)
.unwrap();
let glyph_pixels = |ch| {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, ch).unwrap();
let mut pixels = Vec::new();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
pixels.push((
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
));
}
}
}
pixels
};
let assert_glyph_color =
|memory: &mut PpcSectionMem, origin: (i32, i32), ch: char, pixel: u16| {
let glyph = glyph_pixels(ch);
assert!(!glyph.is_empty());
assert!(glyph.iter().all(|(dx, dy)| {
ppc_quickdraw_read_pixel(memory, front, (origin.0 + dx, origin.1 + dy))
== Some(pixel)
}));
};
let row_top =
|item: i16| tracking.popup_top + ppc_tracked_menu_item_offset(&tracking, item);
let command_layout = standard_menu_item_layout(
(
tracking.popup_left,
tracking.popup_left + tracking.popup_width,
),
(row_top(2), ppc_tracked_menu_item_height(&tracking, 2)),
StandardMenuIconKind::None,
false,
{
let metrics = get_font_metrics(PPC_QD_TEXT_FONT_DEFAULT, PPC_QD_TEXT_SIZE_SYSTEM);
(metrics.ascent, metrics.descent)
},
true,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(command_layout.text_left),
i32::from(command_layout.text_baseline),
),
'C',
black,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 3),
i32::from(row_top(1) + 11),
),
'\u{2713}',
black,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25),
i32::from(row_top(2) + 11),
),
'\u{2318}',
black,
);
let command_symbol_advance = i32::from(
get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, '\u{2318}')
.unwrap()
.0
.advance,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25) + command_symbol_advance,
i32::from(row_top(2) + 11),
),
'C',
black,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 15),
i32::from(row_top(3) + 11),
),
'D',
gray,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 3),
i32::from(row_top(3) + 11),
),
'\u{2713}',
gray,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25),
i32::from(row_top(3) + 11),
),
'\u{2318}',
gray,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + tracking.popup_width - 25) + command_symbol_advance,
i32::from(row_top(3) + 11),
),
'C',
gray,
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left + 10),
i32::from(row_top(4) + 2),
),
),
Some(gray)
);
let hierarchy_ink = (0..7i16)
.flat_map(|dx| (-3..=3).map(move |dy| (dx, dy)))
.filter(|(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left + tracking.popup_width - 12 + *dx),
i32::from(row_top(5) + 8 + *dy),
),
) == Some(black)
})
.count();
assert!(hierarchy_ink >= 7, "hierarchical indicator did not draw");
let disabled_hover = PpcInputSnapshot {
mouse_button: true,
mouse_v: row_top(3) + 4,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_menu_tracking_item(&mut loaded.memory, &tracking, disabled_hover),
0
);
let selected = PpcInputSnapshot {
mouse_button: true,
mouse_v: row_top(1) + 4,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
selected,
);
assert_glyph_color(
&mut loaded.memory,
(
i32::from(tracking.popup_left + 3),
i32::from(row_top(1) + 11),
),
'\u{2713}',
white,
);
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
},
),
Some(0)
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
}
#[test]
fn native_popup_draws_from_the_live_shared_menu_color_table() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu =
install_test_popup_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 300, b"Popup", b"Color");
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
let set_rgb = |entry: &mut [u8; MENU_COLOR_ENTRY_SIZE], offset: usize, rgb: [u16; 3]| {
for (channel, value) in rgb.into_iter().enumerate() {
let channel_offset = offset + channel * 2;
entry[channel_offset..channel_offset + 2].copy_from_slice(&value.to_be_bytes());
}
};
let menu_background = [0xffff, 0x1111, 0x1111];
let item_name = [0x1111, 0x1111, 0xffff];
let mut title = test_menu_color_entry(300, 0, 0);
set_rgb(&mut title, 22, menu_background);
let mut item = test_menu_color_entry(300, 1, 0);
set_rgb(&mut item, 10, item_name);
set_rgb(&mut item, 22, menu_background);
let color_bytes = [title.as_slice(), item.as_slice()].concat();
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(color_handle, 0);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&color_bytes,
),
PPC_NO_ERR,
);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PopUpMenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 80;
loaded.cpu.gpr[6] = 0;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let background_pixel = ppc_physical_screen_color_pixel(
front,
ppc_menu_rgb(menu_background),
&loaded.screen_clut,
)
.unwrap();
let name_pixel =
ppc_physical_screen_color_pixel(front, ppc_menu_rgb(item_name), &loaded.screen_clut)
.unwrap();
assert_ne!(background_pixel, name_pixel);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left + tracking.popup_width - 3),
i32::from(tracking.popup_top + 2),
),
),
Some(background_pixel),
);
let metrics = get_font_metrics(PPC_QD_TEXT_FONT_DEFAULT, PPC_QD_TEXT_SIZE_SYSTEM);
let layout = standard_menu_item_layout(
(
tracking.popup_left,
tracking.popup_left + tracking.popup_width,
),
(tracking.content_top, tracking.item_appearances[0].height),
StandardMenuIconKind::None,
false,
(metrics.ascent, metrics.descent),
false,
);
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, 'C').unwrap();
let (dx, dy) = (0..glyph.height as usize)
.flat_map(|row| (0..glyph.width as usize).map(move |column| (column, row)))
.find(|(column, row)| {
data.get(glyph.data_offset + row * glyph.width as usize + column)
.is_some_and(|alpha| *alpha >= 128)
})
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(layout.text_left) + i32::from(glyph.origin_x) + dx as i32,
i32::from(layout.text_baseline) + i32::from(glyph.origin_y) + dy as i32,
),
),
Some(name_pixel),
);
}
#[test]
fn tracked_menu_renders_each_standard_text_style() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Menu;Menu;Menu;Menu;Menu;Menu;Menu;Menu",
);
let styles = [
0,
QuickDrawTextStyle::BOLD_BIT,
QuickDrawTextStyle::ITALIC_BIT,
QuickDrawTextStyle::UNDERLINE_BIT,
QuickDrawTextStyle::OUTLINE_BIT,
QuickDrawTextStyle::SHADOW_BIT,
QuickDrawTextStyle::CONDENSE_BIT,
QuickDrawTextStyle::EXTEND_BIT,
];
for (item, style) in (1i16..).zip(styles) {
let address =
ppc_menu_item_attribute_address(&mut loaded.memory, menu, item, 3).unwrap();
loaded.memory.write_u8(address, style).unwrap();
}
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let appearances = ppc_menu_item_appearances(&mut loaded.memory, menu, &[], 0);
assert_eq!(
appearances
.iter()
.map(|item| item.height)
.collect::<Vec<_>>(),
vec![16, 16, 16, 16, 16, 21, 16, 16],
);
let state = ppc_begin_tracked_menu_with_appearances(
&mut loaded.memory,
front,
MenuTrackingKind::MenuBar,
menu,
11,
20,
20,
120,
ppc_menu_appearance_height(&appearances),
0,
appearances,
)
.unwrap();
ppc_draw_tracked_menu(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
StandardMenuPaneKind::PullDown,
&state,
0,
);
let pixels_for_item = |memory: &mut PpcSectionMem, item: i16| {
let top = state.popup_top + ppc_tracked_menu_item_offset(&state, item);
let mut pixels = Vec::with_capacity(16 * 48);
for y in 0..16i32 {
for x in 0..48i32 {
pixels.push(
ppc_quickdraw_read_pixel(
memory,
front,
(i32::from(state.popup_left + 18) + x, i32::from(top) + y),
)
.unwrap(),
);
}
}
pixels
};
let plain = pixels_for_item(&mut loaded.memory, 1);
for item in 2..=8 {
assert_ne!(
pixels_for_item(&mut loaded.memory, item),
plain,
"style bit for item {item} did not change its rendered pixels",
);
}
for item in 1..=8 {
let top = state.popup_top + ppc_tracked_menu_item_offset(&state, item);
assert_eq!(
ppc_menu_tracking_item(
&mut loaded.memory,
&state,
PpcInputSnapshot {
mouse_button: true,
mouse_v: top + ppc_tracked_menu_item_height(&state, item) / 2,
mouse_h: state.popup_left + 20,
..PpcInputSnapshot::default()
},
),
item,
);
}
}
#[test]
fn tracked_menu_omits_trailing_separator_rows() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Apple",
b"About;-",
);
let appearances = ppc_menu_item_appearances(&mut loaded.memory, menu, &[], 0);
assert_eq!(appearances.len(), 1);
assert_eq!(ppc_menu_appearance_height(&appearances), 16);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(16));
}
#[test]
fn native_calc_menu_size_uses_shared_macos_8_1_width_policy() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Alpha;Parent/\x1b",
);
let parent_width = ppc_text_bytes_advance_for_font(
b"Parent",
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
);
assert_eq!(
parent_width,
TrapDispatcher::fb_measure_string("Parent", 0, 12),
"PPC and 68k adapters should resolve the same bundled font metric",
);
assert_eq!(
ppc_menu_item(&mut loaded.memory, menu, 2).and_then(|(address, length)| {
ppc_memory_read_bytes(&mut loaded.memory, address + 1, u32::from(length))
}),
Some(b"Parent".to_vec()),
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(
loaded.memory.read_u16_be(menu_ptr + 2),
Some((parent_width + 64) as u16),
);
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(32));
}
#[test]
fn native_calc_menu_size_caps_oversized_menu_height_from_profile_geometry() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let description = (0..40).map(|_| "A").collect::<Vec<_>>().join(";");
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
description.as_bytes(),
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(560));
}
#[test]
fn native_calc_menu_size_calls_powerpc_custom_mdef_size_message() {
let pef = synthetic_pef_with_import(b"CalcMenuSize");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Custom",
b"Ignored",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
let callback_rtoc = PPC_DATA_BASE + 0x7300;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
BLR,
],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
loaded.cpu.gpr[3] = menu;
run_test_import(&mut loaded, PpcImportDispatcherTarget::CalcMenuSize);
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(45));
assert!(loaded
.process_memory_manager
.0
.borrow()
.native_ptr_records()
.iter()
.all(|record| record.ptr != loaded.cpu.gpr[5]));
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn nested_native_mdef_preserves_outer_by_reference_arguments() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"CalcMenuSize")).unwrap();
let outer = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 140, b"Outer", b"A");
let inner = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x2000, 141, b"Inner", b"B");
let marker = PPC_DATA_BASE + 0x7800;
loaded.memory.add_region(marker, vec![0; 4]);
let outer_code = [
0x9421_ffa0, 0x7c08_02a6, 0x9001_0064, 0x90a1_0038, 0x3920_1122, 0xb125_0000, 0x3c60_0000 | (inner >> 16),
0x6063_0000 | (inner & 0xffff),
0x3d80_0000 | (PPC_IMPORT_TRAP_BASE >> 16),
0x618c_0000 | (PPC_IMPORT_TRAP_BASE & 0xffff),
0x7d89_03a6, 0x4e80_0421, 0x80a1_0038, 0xa125_0000, 0x3d40_0000 | (marker >> 16),
0x614a_0000 | (marker & 0xffff),
0x912a_0000, 0x8001_0064, 0x7c08_03a6, 0x3821_0060, BLR,
];
let inner_code = [0x3920_3344, 0xb125_0000, BLR];
for (index, menu, code) in [
(0, outer, outer_code.as_slice()),
(1, inner, inner_code.as_slice()),
] {
let storage = PPC_DATA_BASE + 0x7000 + index * 0x400;
loaded.memory.add_region(storage, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
storage + 0x100,
storage + 0x180,
PPC_CODE_BASE + 0x4000 + index * 0x100,
0,
0x0000_ff80,
code,
);
loaded
.memory
.write_u32_be(storage, storage + 0x100)
.unwrap();
let record = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u32_be(record + 6, storage).unwrap();
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = outer;
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(probe.handled_import_count, 2);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
assert!(loaded.guest_calls().is_empty());
assert_eq!(
loaded.memory.read_u32_be(marker),
Some(0x1122),
"nested MDEF scratch must not alias its caller"
);
}
#[test]
fn nested_classic_mdef_adapters_keep_live_workspaces_disjoint() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"CalcMenuSize")).unwrap();
let menu = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 140, b"Custom", b"A");
let handle = PPC_DATA_BASE + 0x7000;
let descriptor = handle + 0x100;
loaded.memory.add_region(handle, vec![0; 4]);
install_test_m68k_callback(
&mut loaded,
descriptor,
PPC_CODE_BASE + 0x4000,
MenuDefinitionInvocation::PASCAL_PROC_INFO,
0,
&[0x4e74, 18],
);
loaded.memory.write_u32_be(handle, descriptor).unwrap();
let record = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u32_be(record + 6, handle).unwrap();
let manager_handle = loaded.process_memory_manager.0.clone();
let mut manager = manager_handle.borrow_mut();
let initial_count = manager.native_ptr_records().len();
let heap = manager.native_heap_state().unwrap();
let mut cursor = heap.heap_cursor;
let invocation = MenuDefinitionInvocation {
message: crate::menu_manager::MenuDefinitionMessage::Size,
menu_handle: menu,
menu_rect: (1, 2, 3, 4),
hit_point: 0,
which_item: 0,
};
let mut intervals = Vec::new();
for index in 0..2 {
let action = ppc_dispatch_native_menu_definition(
&mut loaded.cpu,
Some(manager.native_mut()),
&mut loaded.memory,
&mut cursor,
heap.heap_limit,
&loaded.process_file_system.vfs_resources,
&mut loaded.toolbox_startup,
invocation,
PPC_HALT_PC,
)
.unwrap();
assert!(matches!(action, PpcImportAction::Halt));
let pending = loaded.toolbox_startup.execution.calls().activate_m68k().unwrap();
loaded
.memory
.write_u32_be(pending.initial_sp - 100, 0x1122 + index)
.unwrap();
intervals.push(pending);
}
let outer = intervals[0];
let inner = intervals[1];
assert_ne!(outer.entry, inner.entry);
assert!(outer.final_sp <= inner.entry || inner.final_sp <= outer.entry);
assert_eq!(
loaded.memory.read_u32_be(outer.initial_sp - 100),
Some(0x1122)
);
assert_eq!(
loaded.memory.read_u32_be(inner.initial_sp - 100),
Some(0x1123)
);
assert_eq!(manager.native_ptr_records().len(), initial_count + 2);
for (index, pending) in intervals.into_iter().rev().enumerate() {
assert!(loaded
.toolbox_startup.execution.calls()
.complete_m68k_operation_for_powerpc(
pending.return_pc,
pending.final_sp,
None,
&mut loaded.cpu,
&mut loaded.memory,
manager.native_mut(),
));
assert_eq!(
manager.native_ptr_records().len(),
initial_count + 1 - index
);
}
assert!(loaded.toolbox_startup.execution.calls().is_empty());
assert_eq!(loaded.toolbox_startup.mixed_mode_m68k.storage_pair(), (0, 0));
}
#[test]
fn native_custom_mdef_adapter_marshals_shared_choose_invocation() {
let pef = synthetic_pef_with_import(b"CalcMenuSize");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Custom",
b"Ignored",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
let callback_rtoc = PPC_DATA_BASE + 0x7300;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
callback_rtoc,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[BLR],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
let invocation = MenuDefinitionInvocation {
message: crate::menu_manager::MenuDefinitionMessage::Choose,
menu_handle: menu,
menu_rect: (20, 30, 120, 180),
hit_point: 0x0050_0060,
which_item: 4,
};
let final_pc = 0x1234_5678;
let manager_handle = loaded.process_memory_manager.0.clone();
let mut manager = manager_handle.borrow_mut();
let heap = manager.native_heap_state().unwrap();
let mut cursor = heap.heap_cursor;
let action = ppc_dispatch_native_menu_definition(
&mut loaded.cpu,
Some(manager.native_mut()),
&mut loaded.memory,
&mut cursor,
heap.heap_limit,
&loaded.process_file_system.vfs_resources,
&mut loaded.toolbox_startup,
invocation,
final_pc,
)
.expect("native custom MDEF should be callable");
assert!(matches!(action, PpcImportAction::Continue));
assert_eq!(loaded.cpu.pc, callback_entry);
assert_eq!(loaded.cpu.gpr[2], callback_rtoc);
assert_eq!(loaded.toolbox_startup.execution.calls().len(), 1);
let scratch = loaded.cpu.gpr[5];
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, scratch, 10),
Some(invocation.scratch_bytes().to_vec())
);
assert_eq!(
&loaded.cpu.gpr[3..8],
&[1, menu, scratch, invocation.hit_point, scratch + 8,]
);
loaded.cpu.pc = PPC_GUEST_CALL_RETURN_PC;
assert!(loaded
.toolbox_startup.execution.calls()
.complete_powerpc_resuming_operation(
&mut loaded.cpu,
manager.native_mut(),
|operation, result| {
let crate::guest_call::ManagerContinuation::Menu(
crate::guest_call::MenuManagerContinuation::Definition(operation),
) = operation
else {
panic!("MDEF continuation");
};
operation.complete(&mut loaded.memory);
result
},
));
assert_eq!(loaded.cpu.pc, final_pc);
assert!(manager
.native_ptr_records()
.iter()
.all(|record| record.ptr != scratch));
}
#[test]
fn configured_native_startup_keeps_empty_menu_ownership_pristine() {
let pef = synthetic_pef_with_import(b"InitMenus");
for screen_depth in [1, 2, 4, 8, 16] {
let mut loaded = load_pef_application_with_config(
&pef,
PpcLoadConfig {
screen_depth,
..PpcLoadConfig::default()
},
)
.unwrap();
assert!(
loaded.toolbox_startup.execution.calls().is_pristine(),
"depth {screen_depth}"
);
let mut context = crate::process_context::ProcessContext::default();
loaded.attach_unconverted_process_services(&mut context);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_pristine());
assert!(context.menu_tracking().is_none());
}
}
#[test]
fn nested_native_menu_select_preserves_outer_tracking_and_return() {
for (nested_point, nested_result) in
[(u32::MAX, 0), ((10u32 << 16) | 12, (131u32 << 16) | 1)]
{
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
131,
b"Custom",
b"Opaque definition data",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u16_be(menu_ptr + 2, 80).unwrap();
loaded.memory.write_u16_be(menu_ptr + 4, 32).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
let marker = PPC_DATA_BASE + 0x7800;
loaded.memory.add_region(marker, vec![0; 8]);
loaded.memory.write_u32_be(marker + 4, u32::MAX).unwrap();
let mut code = vec![
0x9421_ffa0, 0x7c08_02a6, 0x9001_0064, 0x90e1_0038, 0x3d20_0000 | (marker >> 16),
0x6129_0000 | (marker & 0xffff),
0x8109_0000, 0x2c08_0000, 0, 0x3900_0001,
0x9109_0000,
0x3c60_0000 | (nested_point >> 16),
0x6063_0000 | (nested_point & 0xffff),
0x3d80_0000 | (PPC_IMPORT_TRAP_BASE >> 16),
0x618c_0000 | (PPC_IMPORT_TRAP_BASE & 0xffff),
0x7d89_03a6,
0x4e80_0421,
0x3d20_0000 | (marker >> 16),
0x6129_0000 | (marker & 0xffff),
0x9069_0004, 0x80e1_0038,
0x3900_0001,
0xb107_0000, 0x8001_0064,
0x7c08_03a6,
0x3821_0060,
BLR,
];
code[8] = 0x4082_0000 | ((20 - 8) * 4);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&code,
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = 0x1234_0000);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x1234_1000);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let restored_start = front.base_addr + 20 * front.row_bytes;
let restored_len = front.row_bytes * (front.height - 20);
let before =
ppc_memory_read_bytes(&mut loaded.memory, restored_start, restored_len).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = (10u32 << 16) | 12;
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..16 {
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.unsupported_import_index, None);
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
}
assert_eq!(
loaded.memory.read_u32_be(marker + 4),
Some(nested_result),
"nested selection result"
);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC, "outer caller return");
assert_eq!(loaded.cpu.gpr[3], (131u32 << 16) | 1, "outer selection");
assert!(loaded.guest_calls().is_empty());
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, restored_start, restored_len),
Some(before),
"nested menus restore the original pixels"
);
}
}
#[test]
fn native_menu_select_retains_custom_mdef_draw_and_choose_until_release() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
131,
b"Custom",
b"Opaque definition data",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
loaded.memory.write_u16_be(menu_ptr + 2, 80).unwrap();
loaded.memory.write_u16_be(menu_ptr + 4, 32).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[d_form_u(14, 8, 0, 2), d_form_u(44, 8, 7, 0), BLR],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
let return_address = loaded.cpu.lr;
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = 0x1234_0000);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x1234_1000);
loaded.cpu.gpr[3] = (10u32 << 16) | 12;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.which_item(),
2
);
assert_eq!(*loaded.current_gworld, PPC_MAIN_GWORLD);
assert_eq!(*loaded.current_gdevice, PPC_MAIN_GDEVICE);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before.clone())
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(256);
assert_eq!(
probe.handled_import_count, 0,
"retained custom tracking bypasses public entry"
);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.flash_remaining,
6
);
let mut phases = vec![6];
for _ in 0..64 {
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.handled_import_count, 0, "retained custom tracking bypasses public entry");
let remaining = loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map_or(0, |state| state.flash_remaining);
if phases.last() != Some(&remaining) {
phases.push(remaining);
}
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert_eq!(phases, [6, 5, 4, 3, 2, 1, 0]);
assert_eq!(loaded.cpu.gpr[3], (131u32 << 16) | 2);
assert_eq!(loaded.cpu.lr, return_address);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().definition,
None
);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_menu(),
None
);
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
let mut restored = Vec::new();
for y in 0..i32::from(tracking.saved_height) {
for x in 0..i32::from(tracking.saved_width) {
restored.push(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left) + x,
i32::from(tracking.popup_top) + y,
),
)
.unwrap(),
);
}
}
assert_eq!(restored, *tracking.saved_pixels);
}
#[test]
fn native_menu_select_routes_hierarchical_child_through_its_custom_mdef() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
let root = install_test_menu(&mut loaded, scratch, 140, b"File", b"Custom child");
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x100,
b"Child",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x180,
b"Opaque definition data",
));
let child = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
141,
scratch + 0x100,
);
assert_ne!(child, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
child,
scratch + 0x180,
i16::MAX,
),
PPC_NO_ERR,
);
loaded.cpu.gpr[3] = root;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x1B;
ppc_set_item_cmd(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
loaded.cpu.gpr[5] = 141;
ppc_set_item_mark(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
child,
-1,
),
PPC_NO_ERR,
);
let child_ptr = loaded.memory.read_u32_be(child).unwrap();
loaded.memory.write_u16_be(child_ptr + 2, 72).unwrap();
loaded.memory.write_u16_be(child_ptr + 4, 32).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let callback_entry = PPC_CODE_BASE + 0x4000;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[d_form_u(14, 8, 0, 2), d_form_u(44, 8, 7, 0), BLR],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(child_ptr + 6, mdef_handle)
.unwrap();
let return_address = loaded.cpu.lr;
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = 0x1234_0000);
loaded
.current_gdevice
.with_mut(|current_gdevice| *current_gdevice = 0x1234_1000);
loaded.cpu.gpr[3] = (10u32 << 16) | 12;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let root_rect = loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.dropdown_rect();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: root_rect.0 + 8,
mouse_h: root_rect.1 + 16,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(512);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let child_rect = tracking.submenus[0].dropdown_rect();
assert_eq!(child_rect.3 - child_rect.1, 72);
assert_eq!(child_rect.2 - child_rect.0, 32);
assert_eq!(
tracking.active_definition_pane(),
Some(MenuDefinitionPane::Submenu(0))
);
assert_eq!(tracking.active_definition().unwrap().menu_handle(), child);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(512);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert!(loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.submenus
.is_empty());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().caller_isa(),
Some(GuestIsa::PowerPc)
);
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: root_rect.0 + 8,
mouse_h: root_rect.1 + 16,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(512);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.active_definition_pane(),
Some(MenuDefinitionPane::Submenu(0))
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: child_rect.0 + 8,
mouse_h: child_rect.1 + 8,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.which_item(),
2
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: child_rect.0 + 8,
mouse_h: child_rect.1 + 8,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
loaded
.toolbox_startup
.execution
.with_menu_state_mut(|state| {
assert_eq!(state.flash_result, (141u32 << 16) | 2);
state.flash_remaining = 1;
state.flash_deadline = state.flash_tick.unwrap_or(0);
})
.unwrap();
let probe = loaded.run_with_hle_imports(256);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (141u32 << 16) | 2);
assert_eq!(loaded.cpu.lr, return_address);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().caller_isa(),
None
);
assert_eq!(*loaded.current_gworld, 0x1234_0000);
assert_eq!(*loaded.current_gdevice, 0x1234_1000);
}
#[test]
fn native_popup_menu_select_runs_custom_popup_draw_and_choose_sequence() {
for (top, left, requested_item) in [
(40i16, 30i16, 4i16),
(-40, -30, -1),
(i16::MIN, i16::MAX, 0),
] {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
132,
b"Custom",
b"Opaque definition data",
);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
let mdef_handle = PPC_DATA_BASE + 0x7000;
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
loaded.memory.add_region(mdef_handle, vec![0; 4]);
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(14, 8, 0, 40),
d_form_u(44, 8, 5, 0),
d_form_u(14, 8, 0, 30),
d_form_u(44, 8, 5, 2),
d_form_u(14, 8, 0, 72),
d_form_u(44, 8, 5, 4),
d_form_u(14, 8, 0, 110),
d_form_u(44, 8, 5, 6),
d_form_u(14, 8, 0, 2),
d_form_u(44, 8, 7, 0),
BLR,
],
);
loaded.memory.write_u32_be(mdef_handle, descriptor).unwrap();
loaded
.memory
.write_u32_be(menu_ptr + 6, mdef_handle)
.unwrap();
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 0x1234_0000 | u32::from(top as u16);
loaded.cpu.gpr[5] = 0x5678_0000 | u32::from(left as u16);
loaded.cpu.gpr[6] = 0x9ABC_0000 | u32::from(requested_item as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 52,
mouse_h: 45,
..PpcInputSnapshot::default()
});
for _ in 0..32 {
if loaded.cpu.pc == PPC_CODE_BASE + 0x4000 {
break;
}
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(1);
assert_eq!(probe.unsupported_import_index, None);
}
assert_eq!(loaded.cpu.pc, PPC_CODE_BASE + 0x4000);
assert_eq!(loaded.cpu.gpr[3], 3);
assert_eq!(loaded.cpu.gpr[4], menu);
assert_eq!(
loaded.cpu.gpr[6],
(u32::from(top as u16) << 16) | u32::from(left as u16)
);
assert_eq!(
loaded.memory.read_u16_be(loaded.cpu.gpr[7]),
Some(requested_item as u16)
);
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(512);
assert_eq!(probe.handled_import_count, 0, "retained custom tracking bypasses public entry");
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.which_item(),
2
);
assert_eq!(
loaded
.toolbox_startup
.active_menu_definition()
.unwrap()
.menu_rect(),
(40, 30, 72, 110)
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 52,
mouse_h: 45,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(512);
assert_eq!(probe.handled_import_count, 0, "retained custom tracking bypasses public entry");
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.flash_remaining,
6
);
let mut phases = vec![6];
for _ in 0..64 {
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(512);
assert_eq!(
probe.handled_import_count, 0,
"retained custom tracking bypasses public entry"
);
let remaining = loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map_or(0, |state| state.flash_remaining);
if phases.last() != Some(&remaining) {
phases.push(remaining);
}
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert_eq!(phases, [6, 5, 4, 3, 2, 1, 0]);
assert_eq!(loaded.cpu.gpr[3], (132u32 << 16) | 2);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().definition,
None
);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_popup(),
None
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
}
}
#[test]
fn tracked_menu_resolves_icon_precedence_and_variable_rows_at_supported_depths() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let _menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Normal^1;Reduced^2/\x1d;Small^3/\x1e;Color^4;Script^5/\x1c",
);
loaded.set_current_resource_refnum(5);
let record = |res_type: [u8; 4], res_id: i16, data: Vec<u8>| PpcVfsResourceRecord {
ref_num: 5,
path: "Menu Icons".to_owned(),
res_type: u32::from_be_bytes(res_type),
res_id,
name: Vec::new(),
data: data.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
};
let mut normal_icon = vec![0; 128];
normal_icon[0] = 0x80;
let mut reduced_icon = vec![0; 128];
reduced_icon[0] = 0x80;
let mut small_icon = vec![0; 32];
small_icon[0] = 0x80;
loaded.process_file_system.extend_vfs_resources([
record(*b"ICON", 257, normal_icon),
record(*b"ICON", 258, reduced_icon),
record(*b"SICN", 259, small_icon),
record(*b"ICON", 260, vec![0xff; 128]),
record(*b"cicn", 260, test_one_bit_cicon()),
record(*b"cicn", 261, test_one_bit_cicon()),
]);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
ppc_track_menu_while_held_with_resources(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(
tracking
.item_appearances
.iter()
.map(|item| item.height)
.collect::<Vec<_>>(),
vec![34, 16, 16, 16, 16],
);
assert!(matches!(
tracking.item_appearances[0].icon,
Some(PpcTrackedMenuIcon::Icon { reduced: false, .. })
));
assert!(matches!(
tracking.item_appearances[1].icon,
Some(PpcTrackedMenuIcon::Icon { reduced: true, .. })
));
assert!(matches!(
tracking.item_appearances[2].icon,
Some(PpcTrackedMenuIcon::SmallIcon(_))
));
assert!(matches!(
tracking.item_appearances[3].icon,
Some(PpcTrackedMenuIcon::CIcon(_))
));
assert_eq!(
tracking.item_appearances[4].icon_kind,
StandardMenuIconKind::None,
"$1C makes the icon byte a script code even when a matching cicn exists",
);
assert_eq!(tracking.item_appearances[4].icon, None);
assert_eq!(tracking.popup_height, 98);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
for item in 1..=3 {
let top = tracking.popup_top + ppc_tracked_menu_item_offset(&tracking, item);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 2), i32::from(top)),
),
Some(black),
"{depth}bpp item {item} icon did not draw",
);
assert_eq!(
ppc_menu_tracking_item(
&mut loaded.memory,
&tracking,
PpcInputSnapshot {
mouse_button: true,
mouse_v: top + ppc_tracked_menu_item_height(&tracking, item) / 2,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
},
),
item,
);
}
if depth > 1 {
let red = ppc_physical_screen_color_pixel(
front,
PpcRgbColor {
red: 0xffff,
green: 0,
blue: 0,
},
&loaded.screen_clut,
)
.unwrap();
let top = tracking.popup_top + ppc_tracked_menu_item_offset(&tracking, 4);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 2), i32::from(top)),
),
Some(red),
"{depth}bpp cicn pixel did not map through its embedded ColorTable",
);
}
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
},
),
Some(0),
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before),
"{depth}bpp icon menu did not restore its save-under",
);
}
}
#[test]
fn tracked_submenu_aligns_after_a_variable_height_icon_row() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
install_test_menu(
&mut loaded,
scratch,
128,
b"File",
b"Icon^1;Parent/\x1b!\xc9",
);
loaded.memory.add_region(scratch + 0x200, vec![0; 0x200]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x200,
b"Recent",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x280,
b"Child",
));
let submenu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x200,
);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
submenu,
scratch + 0x280,
i16::MAX,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
submenu,
-1,
),
PPC_NO_ERR,
);
loaded.set_current_resource_refnum(5);
let mut icon = vec![0; 128];
icon[0] = 0x80;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: 5,
path: "Menu Icons".to_owned(),
res_type: u32::from_be_bytes(*b"ICON"),
res_id: 257,
name: Vec::new(),
data: icon.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
ppc_track_menu_while_held_with_resources(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
let root = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(root.item_appearances[0].height, 34);
let parent_top = root.popup_top + root.item_appearances[0].height;
ppc_track_menu_while_held_with_resources(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: parent_top + 8,
mouse_h: root.popup_left + 20,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let child = tracking.submenus.first().expect("submenu did not open");
assert_eq!(tracking.highlighted_item, 2);
assert_eq!(child.popup_top, parent_top);
}
#[test]
fn menu_tracking_round_trips_unaligned_popup_boundaries_at_supported_depths() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Open/O!\x12;Disabled(;-;Parent/\x1b!\xc9",
);
let item_glyph_pixels = {
let (glyph, data) = get_glyph(PPC_QD_TEXT_FONT_DEFAULT, 12, 'O').unwrap();
let mut pixels = Vec::new();
for row in 0..glyph.height as usize {
for col in 0..glyph.width as usize {
let index = glyph.data_offset + row * glyph.width as usize + col;
if index < data.len() && data[index] >= 128 {
pixels.push((
i32::from(glyph.origin_x) + col as i32,
i32::from(glyph.origin_y) + row as i32,
));
}
}
}
assert!(!pixels.is_empty());
pixels
};
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
assert_eq!(front.depth, depth);
let active_len = usize::try_from(front.row_bytes * front.height).unwrap();
let pattern = (0..active_len)
.map(|index| {
(index as u8)
.wrapping_mul(37)
.wrapping_add((depth as u8).wrapping_mul(11))
^ 0xa5
})
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(tracking.front_buffer, Some(front.into()));
assert_eq!(tracking.popup_left, STANDARD_MENU_BAR_FIRST_TITLE_LEFT);
assert_eq!(tracking.saved_width, tracking.popup_width + 1);
assert_eq!(tracking.saved_height, tracking.popup_height + 1);
assert_eq!(
tracking.saved_pixels.len(),
usize::try_from(i32::from(tracking.saved_width) * i32::from(tracking.saved_height))
.unwrap(),
);
if depth < 8 {
let pixels_per_byte = 8 / depth;
assert_ne!(
u32::try_from(tracking.popup_left).unwrap() % pixels_per_byte,
0,
"{depth}bpp popup did not exercise an unaligned packed boundary",
);
}
let opened = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
assert_ne!(opened, before, "{depth}bpp popup did not draw");
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left.saturating_add(1)),
i32::from(tracking.popup_top),
),
),
Some(white),
"{depth}bpp attached pull-down should not draw a separate top border",
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(tracking.popup_left),
i32::from(tracking.popup_top),
),
),
Some(black),
"{depth}bpp attached pull-down should retain its left frame",
);
let item_origin = (
i32::from(tracking.popup_left.saturating_add(15)),
i32::from(tracking.popup_top.saturating_add(11)),
);
let normal_item_ink = item_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(item_origin.0 + dx, item_origin.1 + dy),
) == Some(black)
})
.count();
assert_eq!(
normal_item_ink,
item_glyph_pixels.len(),
"{depth}bpp popup item glyph did not draw in black",
);
let selected = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_menu_tracking_item(&mut loaded.memory, &tracking, selected),
1,
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
selected,
);
let highlighted = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
assert_ne!(
highlighted, opened,
"{depth}bpp item highlight did not draw",
);
let highlighted_item_ink = item_glyph_pixels
.iter()
.filter(|&&(dx, dy)| {
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(item_origin.0 + dx, item_origin.1 + dy),
) == Some(white)
})
.count();
assert_eq!(
highlighted_item_ink,
item_glyph_pixels.len(),
"{depth}bpp highlighted popup item glyph did not reverse to white",
);
let cancelled = PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
cancelled,
),
Some(0),
);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(before),
"{depth}bpp cancellation did not round-trip the full framebuffer",
);
}
}
#[test]
fn menu_tracking_opens_selects_and_restores_hierarchical_submenu() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
install_test_menu(
&mut loaded,
scratch,
128,
b"File",
b"Parent/\x1b!\xc9;Cancel",
);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x100,
b"Recent",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x180,
b"First/F;Disabled(;Second/S",
));
let submenu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x100,
);
assert_ne!(submenu, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
submenu,
scratch + 0x180,
i16::MAX,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
submenu,
-1,
),
PPC_NO_ERR,
);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let active_len = usize::try_from(front.row_bytes * front.height).unwrap();
let pattern = (0..active_len)
.map(|index| (index as u8).wrapping_mul(29).wrapping_add(depth as u8))
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let root = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let parent_hover = PpcInputSnapshot {
mouse_button: true,
mouse_v: root.popup_top + 8,
mouse_h: root.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
parent_hover,
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let child = tracking.submenus.first().expect("submenu did not open");
assert_eq!(tracking.highlighted_item, 1);
assert_eq!(child.menu_handle, submenu);
assert_eq!(child.parent_item, 1);
assert_eq!(
child.popup_left,
tracking.popup_left + tracking.popup_width - 4
);
assert_eq!(child.popup_top, tracking.popup_top + 7);
let disabled_hover = PpcInputSnapshot {
mouse_button: true,
mouse_v: child.popup_top + 16 + 8,
mouse_h: child.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
disabled_hover,
);
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.and_then(|state| state.submenus.first())
.map(|child| child.highlighted_item),
Some(0),
);
let selected = PpcInputSnapshot {
mouse_v: child.popup_top + 8,
mouse_h: child.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
..selected
},
);
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
selected,
),
Some((201 << 16) | 1),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(201));
let highlighted = ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
)
.unwrap();
assert_ne!(
highlighted, before,
"{depth}bpp root title was not highlighted"
);
assert!(draw_current_test_menu_bar(&mut loaded));
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(highlighted),
"{depth}bpp DrawMenuBar lost the root title for submenu TheMenu",
);
let menu_list = ppc_current_menu_list(&mut loaded.memory);
ppc_set_menu_title_highlight(
&mut loaded.memory,
&loaded.gworlds,
menu_list,
0,
&loaded.screen_clut,
false,
);
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(before.clone()),
"{depth}bpp submenu selection did not restore the framebuffer",
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
parent_hover,
);
assert!(loaded
.toolbox_startup
.execution.menu()
.as_ref()
.is_some_and(|state| !state.submenus.is_empty()));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: 10,
mouse_h: i16::MAX,
..PpcInputSnapshot::default()
},
),
Some(0),
);
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
front.base_addr,
u32::try_from(active_len).unwrap(),
),
Some(before),
"{depth}bpp submenu cancellation did not restore the framebuffer",
);
}
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let menu_list = ppc_current_menu_list(&mut loaded.memory);
let parent_menu = ppc_menu_list_definition(&mut loaded.memory, menu_list)
.unwrap()
.regular_handles()
.next()
.unwrap();
let mut parent =
ppc_begin_menu_bar_tracking(&mut loaded.memory, front, parent_menu, 400).unwrap();
parent.popup_left = ppc_u32_to_i16_saturating(front.width).saturating_sub(10);
let flipped =
ppc_begin_submenu_tracking(&mut loaded.memory, menu_list, front, &parent, 1).unwrap();
assert_eq!(
flipped.popup_left,
ppc_u32_to_i16_saturating(front.width) - flipped.popup_width - 8,
);
ppc_restore_tracked_menu(&mut loaded.memory, Some(front.into()), &flipped);
}
#[test]
fn menu_tracking_selects_nested_submenus_and_restores_every_depth() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
install_test_menu(
&mut loaded,
scratch,
128,
b"Game",
b"Options/\x1b!\xc9;Cancel",
);
loaded.memory.add_region(scratch + 0x200, vec![0; 0x400]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x200,
b"Options",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x280,
b"Speed/\x1b!\xca;Plain",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x300,
b"Speed",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x380,
b"Cycle/\x1b!\xc9;Fast/F",
));
let options = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
201,
scratch + 0x200,
);
let speed = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
202,
scratch + 0x300,
);
for (menu, items) in [(options, scratch + 0x280), (speed, scratch + 0x380)] {
assert_ne!(menu, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
items,
i16::MAX,
),
PPC_NO_ERR,
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
-1,
),
PPC_NO_ERR,
);
}
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
for (selected, expected_root) in [(128, 128), (201, 128), (202, 128), (999, 0)] {
assert_eq!(
ppc_root_menu_id_for_selection(&mut loaded.memory, menu_list_handle, selected,),
expected_root,
);
}
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let active_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(active_len).unwrap())
.map(|index| (index as u8).wrapping_mul(43).wrapping_add(depth as u8))
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, active_len).unwrap();
let track = |loaded: &mut PpcLoadedApp, point: (i16, i16)| {
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: point.0,
mouse_h: point.1,
..PpcInputSnapshot::default()
},
);
};
track(&mut loaded, (10, 12));
let root = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
track(&mut loaded, (root.popup_top + 8, root.popup_left + 20));
let first = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(first.submenus.len(), 1);
assert_eq!(first.submenus[0].menu_handle, options);
let options_pane = first.submenus[0].clone();
track(
&mut loaded,
(options_pane.popup_top + 8, options_pane.popup_left + 20),
);
let nested = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(nested.submenus.len(), 2);
assert_eq!(nested.submenus[0].highlighted_item, 1);
assert_eq!(nested.submenus[1].menu_handle, speed);
track(
&mut loaded,
(
options_pane.popup_top + 16 + 8,
options_pane.popup_left + 20,
),
);
let switched = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(switched.submenus.len(), 1);
assert_eq!(switched.submenus[0].highlighted_item, 2);
track(
&mut loaded,
(options_pane.popup_top + 8, options_pane.popup_left + 20),
);
let reopened = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(reopened.submenus.len(), 2);
let speed_pane = reopened.submenus[1].clone();
track(
&mut loaded,
(speed_pane.popup_top + 8, speed_pane.popup_left + 20),
);
let cycle = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(cycle.submenus.len(), 2, "circular submenu grew the chain");
assert_eq!(cycle.submenus[1].highlighted_item, 1);
assert_eq!(
ppc_tracked_menu_selection(&mut loaded.memory, &cycle),
None,
"hierarchical parent became selectable",
);
let leaf = PpcInputSnapshot {
mouse_v: speed_pane.popup_top + 16 + 8,
mouse_h: speed_pane.popup_left + 20,
..PpcInputSnapshot::default()
};
track(&mut loaded, (leaf.mouse_v, leaf.mouse_h));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
leaf,
),
Some((202 << 16) | 2),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(202));
let menu_list = ppc_current_menu_list(&mut loaded.memory);
ppc_set_menu_title_highlight(
&mut loaded.memory,
&loaded.gworlds,
menu_list,
0,
&loaded.screen_clut,
false,
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, active_len),
Some(before),
"{depth}bpp nested menu did not restore every saved pane",
);
}
loaded.cpu.gpr[3] = u32::from(b'f');
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuKey);
assert_eq!(loaded.cpu.gpr[3], (202 << 16) | 2);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(202));
loaded
.toolbox_startup
.pending_native_menu_selection
.stage((202, 2));
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuSelect);
assert_eq!(loaded.cpu.gpr[3], (202 << 16) | 2);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(202));
}
#[test]
fn short_menu_bar_system_mark_does_not_bleed_below_the_bar() {
let pef = synthetic_pef_with_import(b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, &[0x14], b"");
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded
.memory
.write_u16_be(PPC_MBAR_HEIGHT_ADDR, 12)
.unwrap();
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let active_len = usize::try_from(front.row_bytes * front.height).unwrap();
let sentinel = (0..active_len)
.map(|index| (index as u8).wrapping_mul(13) ^ 0x5a)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &sentinel)
.unwrap();
let below_bar = front.base_addr + front.row_bytes * 12;
let below_bar_len = front.row_bytes * front.height.saturating_sub(12);
let below_bar_before =
ppc_memory_read_bytes(&mut loaded.memory, below_bar, below_bar_len).unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, below_bar, below_bar_len),
Some(below_bar_before),
"{depth}bpp system mark painted below MBarHeight=12",
);
let [red, green, blue] = crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0];
let outline = ppc_physical_screen_color_pixel(
front,
PpcRgbColor { red, green, blue },
&loaded.screen_clut,
)
.unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(
i32::from(
STANDARD_MENU_BAR_FIRST_TITLE_LEFT
+ STANDARD_MENU_BAR_TITLE_ORIGIN_INSET
+ 1,
),
0,
),
),
Some(outline),
"{depth}bpp system mark did not draw at its clipped top",
);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (0, 11)),
Some(black),
"{depth}bpp short menu bar lost its bottom border",
);
}
}
#[test]
fn menu_tracking_uses_the_live_main_set_port_pix_destination() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let scratch = PPC_DATA_BASE + 0x20_000;
let live_pixmap_handle = scratch;
let live_pixmap = scratch + 0x10;
let live_pixels = scratch + 0x100;
let live_width = 128u32;
let live_height = 96u32;
let live_row_bytes = live_width;
loaded.memory.add_region(scratch, vec![0; 0x4000]);
loaded
.memory
.write_u32_be(live_pixmap_handle, live_pixmap)
.unwrap();
ppc_write_pixmap(
&mut loaded.memory,
live_pixmap,
live_pixels,
live_row_bytes,
0,
0,
live_height as i16,
live_width as i16,
8,
)
.unwrap();
loaded
.memory
.write_u32_be(live_pixmap + 42, PPC_MAIN_CTABLE_HANDLE)
.unwrap();
let cached = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(cached.base_addr, PPC_MAIN_SCREEN_BASE);
let cached_len = cached.row_bytes * cached.height;
loaded
.memory
.write_bytes(cached.base_addr, &vec![0x3c; cached_len as usize])
.unwrap();
let cached_before =
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len).unwrap();
let live_len = live_row_bytes * live_height;
let live_pattern = (0..live_len as usize)
.map(|index| (index as u8).wrapping_mul(29) ^ 0x96)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(live_pixels, &live_pattern)
.unwrap();
ppc_set_port_bits(
&mut loaded.memory,
PPC_MAIN_GWORLD,
live_pixmap_handle,
true,
);
let live =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
assert_eq!(
live,
PpcFrontBuffer {
base_addr: live_pixels,
row_bytes: live_row_bytes,
width: live_width,
height: live_height,
depth: 8,
},
);
assert!(draw_current_test_menu_bar(&mut loaded));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len),
Some(cached_before.clone()),
"DrawMenuBar touched the stale cached main framebuffer",
);
let live_before =
ppc_memory_read_bytes(&mut loaded.memory, live.base_addr, live_len).unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(tracking.front_buffer, Some(live.into()));
let selected = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left + 20,
..PpcInputSnapshot::default()
};
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
selected,
);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, live.base_addr, live_len),
Some(live_before.clone()),
"tracked popup did not draw into the live main PixMap",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len),
Some(cached_before.clone()),
"tracked popup touched the stale cached main framebuffer",
);
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
},
),
Some(0),
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, live.base_addr, live_len),
Some(live_before),
"live main PixMap did not round-trip after cancellation",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, cached.base_addr, cached_len),
Some(cached_before),
"cancellation touched the stale cached main framebuffer",
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
}
#[test]
fn hle_import_runner_get_new_mbar_rejects_a_truncated_declared_menu_sequence() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 1001,
name: Vec::new(),
data: vec![0, 2, 0, 128].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 1001;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn hle_import_runner_builds_and_draws_mbar_resources() {
fn menu_resource(menu_id: i16, title: &[u8]) -> Vec<u8> {
let mut data = vec![0; 14];
data[0..2].copy_from_slice(&menu_id.to_be_bytes());
data[10..14].copy_from_slice(&u32::MAX.to_be_bytes());
data.push(title.len() as u8);
data.extend_from_slice(title);
data.push(0);
data
}
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 1000,
name: Vec::new(),
data: vec![0, 2, 0, 128, 0, 129].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 128,
name: Vec::new(),
data: menu_resource(128, &[0x14]).into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: {
let mut data = menu_resource(129, b"File");
data.pop();
data.extend_from_slice(&[4, b'O', b'p', b'e', b'n', 0, 0, 0, 0, 0]);
data
}.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 1000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let menu_list_handle = loaded.cpu.gpr[3];
ppc_set_current_menu_list(&mut loaded.memory, menu_list_handle);
let menu_list = loaded.memory.read_u32_be(menu_list_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_list), Some(12));
assert_eq!(loaded.memory.read_u16_be(menu_list + 4), Some(1000));
let file_menu = ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 128);
assert_ne!(file_menu, 0);
assert_ne!(
ppc_get_menu_handle(&mut loaded.memory, menu_list_handle, 129),
0
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetMenu;
loaded.cpu.gpr[3] = 128;
let get_menu_probe = loaded.run_with_hle_imports(64);
assert_eq!(get_menu_probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], file_menu);
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
menu_list_handle,
&loaded.screen_clut,
));
let white = ppc_rgb_color_to_8bpp_index(PPC_RGB_WHITE);
let black = ppc_rgb_color_to_8bpp_index(PPC_RGB_BLACK);
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE), Some(black));
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE + 5), Some(white));
let mark_outline = pict::closest_clut_index(
crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0][0],
crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0][1],
crate::ui_art::RETRO_COMPUTER_MENU_MARK_PALETTE[0][2],
&loaded.screen_clut,
);
assert_eq!(
loaded
.memory
.read_u8(PPC_MAIN_SCREEN_BASE + 3 * ppc_main_screen_row_bytes() + 19),
Some(mark_outline)
);
assert_eq!(standard_menu_title_advance(&[0x14]), 11);
let snapshot = loaded.guest_menu_snapshot();
assert_eq!(snapshot.menus.len(), 2);
assert_eq!(snapshot.menus[0].title, "Systemless");
assert_eq!(snapshot.menus[1].title, "File");
assert_eq!(snapshot.menus[1].items[0].text, "Open");
assert!(loaded.queue_native_menu_selection(129, 1));
assert_eq!(
loaded.toolbox_startup.pending_native_menu_selection,
Some((129, 1))
);
let popup_probe = PPC_MAIN_SCREEN_BASE + 20 * ppc_main_screen_row_bytes() + 35;
let popup_before = loaded.memory.read_u8(popup_probe).unwrap();
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
42,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 42,
..PpcInputSnapshot::default()
},
);
assert!(loaded.toolbox_startup.execution.menu().is_some());
assert_ne!(loaded.memory.read_u8(popup_probe), Some(popup_before));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_v: 23,
mouse_h: 42,
..PpcInputSnapshot::default()
},
),
Some((129 << 16) | 1)
);
assert_eq!(loaded.memory.read_u8(popup_probe), Some(popup_before));
assert_eq!(
loaded
.memory
.read_u8(PPC_MAIN_SCREEN_BASE + 19 * ppc_main_screen_row_bytes()),
Some(black)
);
assert!((3..19).any(|y| {
(42..100).any(|x| {
loaded
.memory
.read_u8(PPC_MAIN_SCREEN_BASE + y * ppc_main_screen_row_bytes() + x)
== Some(black)
})
}));
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
}
#[test]
fn menu_tracking_rejects_disabled_items_and_dividers_and_clears_cancellation() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(scratch, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch,
b"File"
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x20,
b"Open;Disabled(;\x2d"
));
let menu_handle = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
scratch,
);
assert_ne!(menu_handle, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_handle,
scratch + 0x20,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu_handle,
0,
),
PPC_NO_ERR
);
let menu_list_handle = ppc_current_menu_list(&mut loaded.memory);
assert!(ppc_draw_menu_bar(
&mut loaded.memory,
&loaded.gworlds,
menu_list_handle,
&loaded.screen_clut,
));
let menu_bar_len = u32::from(loaded.memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap())
* ppc_main_screen_row_bytes();
let unhighlighted_bar =
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len).unwrap();
for (label, item) in [("disabled item", 2i16), ("divider", 3i16)] {
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let input = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + (item - 1) * 16 + 4,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
let background_point = (i32::from(input.mouse_h), i32::from(input.mouse_v));
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let background = ppc_quickdraw_read_pixel(&mut loaded.memory, front, background_point);
assert_eq!(
ppc_menu_tracking_item(&mut loaded.memory, tracking, input),
0,
"{label} became the tracked selection"
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
input,
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, background_point),
background,
"{label} was drawn highlighted"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
input,
),
Some(0),
"{label} was returned as a menu choice"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len),
Some(unhighlighted_bar.clone()),
"{label} cancellation left the title highlighted"
);
}
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let outside = PpcInputSnapshot {
mouse_v: tracking.popup_top + 8,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
outside,
),
Some(0)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len),
Some(unhighlighted_bar.clone())
);
ppc_track_menu_while_held(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
12,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: 12,
..PpcInputSnapshot::default()
},
);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let enabled = PpcInputSnapshot {
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
assert_eq!(
ppc_finish_menu_bar_tracking(
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
&mut loaded.toolbox_startup,
enabled,
),
Some((128u32 << 16) | 1)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_SCREEN_BASE, menu_bar_len),
Some(unhighlighted_bar),
"a valid choice did not retain its documented title highlight"
);
}
#[test]
fn import_bindings_classify_menu_bar_imports() {
for lib in ["InterfaceLib", "AppearanceLib", "CarbonLib"] {
assert_eq!(
dispatcher_target_for_import(lib, "GetMenuBar"),
PpcImportDispatcherTarget::GetMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenubar"),
PpcImportDispatcherTarget::GetMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "GetNewMBar"),
PpcImportDispatcherTarget::GetNewMBar
);
assert_eq!(
dispatcher_target_for_import(lib, "getnewmbar"),
PpcImportDispatcherTarget::GetNewMBar
);
assert_eq!(
dispatcher_target_for_import(lib, "ClearMenuBar"),
PpcImportDispatcherTarget::ClearMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "clearmenubar"),
PpcImportDispatcherTarget::ClearMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMenuBar"),
PpcImportDispatcherTarget::SetMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "setmenubar"),
PpcImportDispatcherTarget::SetMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMenuHandle"),
PpcImportDispatcherTarget::GetMenuHandle
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenuhandle"),
PpcImportDispatcherTarget::GetMenuHandle
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMHandle"),
PpcImportDispatcherTarget::GetMenuHandle
);
assert_eq!(
dispatcher_target_for_import(lib, "getmhandle"),
PpcImportDispatcherTarget::GetMenuHandle
);
assert_eq!(
dispatcher_target_for_import(lib, "DrawMenuBar"),
PpcImportDispatcherTarget::DrawMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "drawmenubar"),
PpcImportDispatcherTarget::DrawMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "FlashMenuBar"),
PpcImportDispatcherTarget::FlashMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "flashmenubar"),
PpcImportDispatcherTarget::FlashMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMenuFlash"),
PpcImportDispatcherTarget::SetMenuFlash
);
assert_eq!(
dispatcher_target_for_import(lib, "setmenuflash"),
PpcImportDispatcherTarget::SetMenuFlash
);
assert_eq!(
dispatcher_target_for_import(lib, "LMSetMenuFlash"),
PpcImportDispatcherTarget::SetMenuFlash
);
assert_eq!(
dispatcher_target_for_import(lib, "lmsetmenuflash"),
PpcImportDispatcherTarget::SetMenuFlash
);
assert_eq!(
dispatcher_target_for_import(lib, "LMGetMenuFlash"),
PpcImportDispatcherTarget::LMGetMenuFlash
);
assert_eq!(
dispatcher_target_for_import(lib, "lmgetmenuflash"),
PpcImportDispatcherTarget::LMGetMenuFlash
);
assert_eq!(
dispatcher_target_for_import(lib, "LMGetMenuList"),
PpcImportDispatcherTarget::LMGetMenuList
);
assert_eq!(
dispatcher_target_for_import(lib, "lmgetmenulist"),
PpcImportDispatcherTarget::LMGetMenuList
);
assert_eq!(
dispatcher_target_for_import(lib, "LMSetMenuHook"),
PpcImportDispatcherTarget::LMSetMenuHook
);
assert_eq!(
dispatcher_target_for_import(lib, "lmsetmenuhook"),
PpcImportDispatcherTarget::LMSetMenuHook
);
assert_eq!(
dispatcher_target_for_import(lib, "InvalMenuBar"),
PpcImportDispatcherTarget::InvalMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "invalmenubar"),
PpcImportDispatcherTarget::InvalMenuBar
);
assert_eq!(
dispatcher_target_for_import(lib, "HiliteMenu"),
PpcImportDispatcherTarget::HiliteMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "hilitemenu"),
PpcImportDispatcherTarget::HiliteMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "HMGetHelpMenuHandle"),
PpcImportDispatcherTarget::HMGetHelpMenuHandle
);
assert_eq!(
dispatcher_target_for_import(lib, "hmgethelpmenuhandle"),
PpcImportDispatcherTarget::HMGetHelpMenuHandle
);
assert_eq!(
dispatcher_target_for_import(lib, "HMGetBalloons"),
PpcImportDispatcherTarget::HMGetBalloons
);
assert_eq!(
dispatcher_target_for_import(lib, "hmgetballoons"),
PpcImportDispatcherTarget::HMGetBalloons
);
assert_eq!(
dispatcher_target_for_import(lib, "HMIsBalloon"),
PpcImportDispatcherTarget::HMIsBalloon
);
assert_eq!(
dispatcher_target_for_import(lib, "HMSetBalloons"),
PpcImportDispatcherTarget::HMSetBalloons
);
assert_eq!(
dispatcher_target_for_import(lib, "InitMenus"),
PpcImportDispatcherTarget::InitMenus
);
assert_eq!(
dispatcher_target_for_import(lib, "initmenus"),
PpcImportDispatcherTarget::InitMenus
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMBarHeight"),
PpcImportDispatcherTarget::GetMBarHeight
);
assert_eq!(
dispatcher_target_for_import(lib, "getmbarheight"),
PpcImportDispatcherTarget::GetMBarHeight
);
assert_eq!(
dispatcher_target_for_import(lib, "LMGetMBarHeight"),
PpcImportDispatcherTarget::GetMBarHeight
);
assert_eq!(
dispatcher_target_for_import(lib, "lmgetmbarheight"),
PpcImportDispatcherTarget::GetMBarHeight
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMBarHeight"),
PpcImportDispatcherTarget::SetMBarHeight
);
assert_eq!(
dispatcher_target_for_import(lib, "setmbarheight"),
PpcImportDispatcherTarget::SetMBarHeight
);
assert_eq!(
dispatcher_target_for_import(lib, "LMSetMBarHeight"),
PpcImportDispatcherTarget::SetMBarHeight
);
assert_eq!(
dispatcher_target_for_import(lib, "lmsetmbarheight"),
PpcImportDispatcherTarget::SetMBarHeight
);
}
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetDefltStack"),
PpcImportDispatcherTarget::LMGetDefltStack
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMGetCurStackBase"),
PpcImportDispatcherTarget::LMGetCurStackBase
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "AppendResMenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "AddResMenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "InsertResMenu"),
PpcImportDispatcherTarget::InsertResMenu
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "MenuChoice"),
PpcImportDispatcherTarget::MenuChoice
);
}
#[test]
fn native_inval_menu_bar_defers_and_coalesces_one_draw_until_an_event_scan() {
let pef = synthetic_pef_with_import(b"InvalMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
assert!(ppc_quickdraw_write_pixel(
&mut loaded.memory,
front,
(100, 5),
PPC_RGB_BLACK,
));
let dirty = ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5));
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvalMenuBar);
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvalMenuBar);
assert!(loaded.event_queue.menu_bar_is_invalid());
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 0);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5)),
dirty,
"InvalMenuBar must not draw synchronously"
);
let event = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(event, vec![0xaa; 16]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::OSEventAvail);
assert!(
loaded.event_queue.menu_bar_is_invalid(),
"low-level OS event scans must not consume Toolbox redraw work"
);
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 0);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = event;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert!(!loaded.event_queue.menu_bar_is_invalid());
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 1);
assert_ne!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5)),
dirty,
"the next Toolbox event scan must perform DrawMenuBar"
);
assert!(ppc_quickdraw_write_pixel(
&mut loaded.memory,
front,
(100, 5),
PPC_RGB_BLACK,
));
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = event;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::GetNextEvent(PpcEventPollOperation::GetNextEvent),
);
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 1);
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, (100, 5)),
dirty,
"the deferred redraw must be consumed exactly once"
);
run_test_import(&mut loaded, PpcImportDispatcherTarget::InvalMenuBar);
run_test_import(&mut loaded, PpcImportDispatcherTarget::DrawMenuBar);
assert!(!loaded.event_queue.menu_bar_is_invalid());
assert_eq!(loaded.toolbox_startup.menu_bar_draw_count, 2);
}
#[test]
fn process_owner_shares_one_retained_menu_continuation_between_adapters() {
let (prepared, mut classic_cpu, mut classic_bus) = setup_with_port();
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut native = load_pef_application(&pef).unwrap();
let mut context = ProcessContext::default();
let mut classic = TrapDispatcher::new_with_migrated_handles(context.migrated_handles());
classic
.scrap
.set_clipboard_writable(prepared.scrap.clipboard_writable_for_test());
let (base, row_bytes, width, height, depth) = prepared.screen_mode;
classic.set_screen_mode_for_test(base, row_bytes, width, height, depth);
classic.read_tick_count(&classic_bus);
classic.attach_unconverted_process_services(&mut context);
let plan = native
.preflight_migrated_services(&context, classic_bus.read_long(0x016a))
.unwrap();
native.commit_migrated_services(&context, plan);
native.attach_unconverted_process_services(&mut context);
let mut tracking = crate::menu_manager::test_process_menu_tracking(0x0012_3456);
tracking.highlighted_item = 2;
context.set_menu_tracking(Some(tracking));
classic.menu_tracking.with_context_mut(|menu_context| {
menu_context.call = Some(MenuTrackingCall {
request: MenuTrackingRequest::MenuSelect { initial_point: 0 },
origin: MenuTrackingOrigin::M68k {
stack_pointer: TEST_SP,
return_address: 0x1234,
},
});
});
let native_front = native.current_front_buffer().unwrap();
context
.with_menu_tracking_mut(|tracking| tracking.front_buffer = Some(native_front.into()))
.unwrap();
assert_eq!(
classic
.menu_tracking
.as_ref()
.map(|tracking| (tracking.menu_handle, tracking.highlighted_item)),
Some((0x0012_3456, 2))
);
assert_eq!(
context
.menu_tracking()
.map(|tracking| (tracking.menu_handle, tracking.highlighted_item)),
Some((0x0012_3456, 2))
);
native.cpu.gpr[3] = 0;
run_test_import(&mut native, PpcImportDispatcherTarget::MenuSelect);
assert!(native.is_constructed_from_migrated_handles(&context.migrated_handles()));
native
.toolbox_startup
.execution
.with_menu_state_mut(|tracking| tracking.highlighted_item = 4)
.unwrap();
assert_eq!(classic.menu_tracking.as_ref().unwrap().highlighted_item, 4);
assert_eq!(
context
.menu_tracking()
.map(|tracking| tracking.highlighted_item),
Some(4)
);
let call = ppc_menu_select_call(&native.cpu, 0);
native
.toolbox_startup
.execution
.with_menu_context_mut(|context| context.call = Some(call));
context
.with_menu_tracking_mut(|tracking| tracking.front_buffer = None)
.unwrap();
classic_cpu.write_reg(Register::A7, TEST_SP);
classic_bus.write_long(TEST_SP, 0);
classic_bus.write_long(TEST_SP + 4, u32::MAX);
assert!(classic
.dispatch_menu(true, 0x13D, &mut classic_cpu, &mut classic_bus)
.unwrap()
.is_ok());
assert_eq!(classic_bus.read_long(TEST_SP + 4), 0);
assert_eq!(
context.menu_tracking().map(|tracking| tracking.menu_handle),
Some(0x0012_3456),
"the classic slice must retain the process-owned continuation"
);
context.take_menu_tracking();
assert!(classic.menu_tracking.is_none());
assert!(native.toolbox_startup.execution.menu().is_none());
assert!(native.is_constructed_from_migrated_handles(&context.migrated_handles()));
}
#[test]
fn native_menu_flash_accessors_use_the_live_low_memory_word() {
let pef = synthetic_pef_with_import(b"SetMenuFlash");
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH),
Some(crate::memory::globals::DEFAULT_MENU_FLASH_COUNT)
);
loaded.cpu.gpr[3] = 0xcafe_0001;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuFlash);
assert_eq!(loaded.cpu.gpr[3], 0xcafe_0001);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::MENU_FLASH),
Some(1)
);
loaded.cpu.gpr[3] = 0xdead_beef;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LMGetMenuFlash);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, u16::MAX)
.unwrap();
run_test_import(&mut loaded, PpcImportDispatcherTarget::LMGetMenuFlash);
assert_eq!(loaded.cpu.gpr[3], u32::MAX);
}
#[test]
fn lm_set_menu_hook_updates_the_callback_read_by_menu_select() {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "LMSetMenuHook"),
PpcImportDispatcherTarget::LMSetMenuHook
);
let pef = synthetic_pef_with_import(b"LMSetMenuHook");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x0123_4568;
run_test_import(&mut loaded, PpcImportDispatcherTarget::LMSetMenuHook);
assert_eq!(loaded.memory.read_u32_be(0x0a30), Some(0x0123_4568));
assert_eq!(loaded.cpu.gpr[3], 0x0123_4568);
}
#[test]
fn native_insert_and_append_res_menu_share_resource_name_policy() {
let pef = synthetic_pef_with_import(b"InsertResMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"Apple",
b"Existing;Tail",
);
let current = *loaded.process_file_system.current_resource_file;
let record = |ref_num, res_id, name: &[u8], byte| PpcVfsResourceRecord {
ref_num,
path: format!("Resources {ref_num}"),
res_type: u32::from_be_bytes(*b"DRVR"),
res_id,
name: name.to_vec(),
data: vec![byte].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
};
loaded.process_file_system.extend_vfs_resources([
record(current, 103, b"Zulu", 1),
record(current, 104, b"Alpha", 2),
record(current, 105, b".Hidden", 3),
record(current, 106, b"Existing", 4),
record(2, 103, b"Shadowed", 5),
record(2, 107, b"Beta", 6),
]);
loaded.policy.set_res_load(false);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"DRVR");
loaded.cpu.gpr[5] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertResMenu);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap();
assert_eq!(
items
.items
.iter()
.map(|item| item.text.as_slice())
.collect::<Vec<_>>(),
[
b"Existing".as_slice(),
b"Alpha".as_slice(),
b"Beta".as_slice(),
b"Zulu".as_slice(),
b"Tail".as_slice(),
]
);
for item in &items.items[1..4] {
assert!(item.enabled);
assert_eq!(
(item.icon, item.command, item.mark, item.style),
(0, 0, 0, 0)
);
}
assert!(loaded.policy.res_load());
for resource in &loaded.process_file_system.vfs_resources {
if resource.name == b"Shadowed" {
assert_eq!(
resource.handle, 0,
"closer type/ID must shadow this resource"
);
} else {
assert_ne!(resource.handle, 0, "matching resources must be loaded");
assert_ne!(loaded.memory.read_u32_be(resource.handle), Some(0));
}
}
loaded.process_file_system.push_vfs_resource(record(2, 108, b"Gamma", 7));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"DRVR");
run_test_import(&mut loaded, PpcImportDispatcherTarget::AppendResMenu);
assert_eq!(
ppc_menu_items_from_memory(&mut loaded.memory, menu)
.unwrap()
.items
.iter()
.map(|item| item.text.as_slice())
.collect::<Vec<_>>(),
[
b"Existing".as_slice(),
b"Alpha".as_slice(),
b"Beta".as_slice(),
b"Zulu".as_slice(),
b"Tail".as_slice(),
b"Gamma".as_slice(),
]
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_append_res_menu_gives_fond_names_precedence_and_adds_builtin_fonts() {
let pef = synthetic_pef_with_import(b"AppendResMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 129, b"Font", b"");
let current = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num: current,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"FONT"),
res_id: 7,
name: b"Custom Face".to_vec(),
data: vec![1].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num: current,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"FOND"),
res_id: 8,
name: b"Custom Face".to_vec(),
data: vec![2].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"FONT");
run_test_import(&mut loaded, PpcImportDispatcherTarget::AppendResMenu);
let names = ppc_menu_items_from_memory(&mut loaded.memory, menu)
.unwrap()
.items
.into_iter()
.map(|item| item.text)
.collect::<Vec<_>>();
assert_eq!(
names
.iter()
.filter(|name| name.as_slice() == b"Custom Face")
.count(),
1,
"the FOND name must suppress the later FONT duplicate"
);
for expected in [b"Chicago".as_slice(), b"Geneva", b"Monaco", b"New York"] {
assert!(names.iter().any(|name| name == expected));
}
assert!(!names.iter().any(|name| name == b"Application"));
assert!(loaded
.vfs_resources
.iter()
.all(|resource| resource.handle != 0));
}
#[test]
fn hle_import_runner_menu_choice_returns_menu_disable_without_side_effects() {
let pef = synthetic_pef_with_import(b"MenuChoice");
let mut loaded = load_pef_application(&pef).unwrap();
let original_sp = loaded.cpu.gpr[1];
for expected in [0, (128u32 << 16) | 3, (201u32 << 16) | 0xffff] {
loaded
.memory
.write_u32_be(crate::memory::globals::addr::MENU_DISABLE, expected)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0xdead_beef;
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], expected);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_DISABLE),
Some(expected),
);
}
}
#[test]
fn native_menuselect_disabled_item_updates_live_menuchoice_result() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open/O");
ppc_set_menu_item_enabled(
&mut loaded.memory,
&test_handle_records!(loaded),
menu,
1,
false,
);
assert!(draw_current_test_menu_bar(&mut loaded));
let title_h = STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2;
loaded.cpu.gpr[3] = (u32::from(10u16) << 16) | u32::from(title_h as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: title_h,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(loaded.toolbox_startup.execution.menu().is_none());
let expected = menu_choice_value(128, 1);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_DISABLE),
Some(expected),
);
loaded.cpu.gpr[3] = 0xDEAD_BEEF;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuChoice);
assert_eq!(loaded.cpu.gpr[3], expected);
}
#[test]
fn hm_get_help_menu_handle_clears_output_and_returns_not_initialized() {
let pef = synthetic_pef_with_import(b"HMGetHelpMenuHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(menu_handle_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = menu_handle_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(menu_handle_ptr), Some(0));
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_HM_HELP_MANAGER_NOT_INITED)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_HM_HELP_MANAGER_NOT_INITED)
);
}
#[test]
fn hm_set_balloons_updates_powerpc_help_setting() {
let pef = synthetic_pef_with_import(b"HMSetBalloons");
let mut loaded = load_pef_application(&pef).unwrap();
for (requested, expected) in [(1, 1), (0, 0)] {
loaded.cpu.gpr[3] = requested;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMSetBalloons);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMGetBalloons);
assert_eq!(loaded.cpu.gpr[3], expected);
}
}
#[test]
fn get_menu_bar_returns_an_ordered_caller_owned_snapshot() {
let pef = synthetic_pef_with_import(b"GetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu_handles = [0x1111_0000, 0x2222_0000];
let current = ppc_alloc_menu_list_handle(
&menu_handles,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
let stack_pointer = loaded.cpu.gpr[1];
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let snapshot = loaded.cpu.gpr[3];
assert_ne!(snapshot, 0);
assert_ne!(snapshot, current);
assert_eq!(loaded.cpu.gpr[1], stack_pointer);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, snapshot),
Some(menu_handles.to_vec())
);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, current),
Some(menu_handles.to_vec())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn get_menu_bar_returns_a_non_nil_empty_snapshot_without_a_current_list() {
let pef = synthetic_pef_with_import(b"GetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let snapshot = loaded.cpu.gpr[3];
assert_ne!(snapshot, 0);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, snapshot),
Some(Vec::new())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn set_menu_bar_installs_a_copy_independent_of_the_source_handle() {
let pef = synthetic_pef_with_import(b"SetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu_handles = [0x1111_0000, 0x2222_0000];
let source = ppc_alloc_menu_list_handle(
&menu_handles,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(source, 0);
loaded.cpu.gpr[3] = source;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let installed = ppc_current_menu_list(&mut loaded.memory);
assert_ne!(installed, 0);
assert_ne!(installed, source);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, installed),
Some(menu_handles.to_vec())
);
loaded.memory.write_u32_be(source, 0).unwrap();
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, installed),
Some(menu_handles.to_vec())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn clear_menu_bar_empties_and_preserves_the_current_menu_list() {
let pef = synthetic_pef_with_import(b"ClearMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let current = ppc_alloc_menu_list_handle(
&[0x1111_0000, 0x2222_0000],
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
ppc_menu_list_handles(&mut loaded.memory, current),
Some(Vec::new())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_menu_bar_snapshot_clear_and_restore_round_trips_both_partitions() {
let pef = synthetic_pef_with_import(b"GetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let original = PpcMenuListDefinition {
last_right: 87,
mb_res_id: 0x108,
regular: vec![
PpcMenuListEntry {
handle: 0x1111_0000,
value: 11,
},
PpcMenuListEntry {
handle: 0x2222_0000,
value: 43,
},
],
menu_title_save: 0x3333_0000,
hierarchical: vec![PpcMenuListEntry {
handle: 0x4444_0000,
value: 0,
}],
};
let current = ppc_alloc_menu_list_definition_handle(
&original,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(current, 0);
ppc_set_current_menu_list(&mut loaded.memory, current);
loaded
.memory
.write_u32_be(crate::memory::globals::addr::MENU_LIST, current)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let saved = loaded.cpu.gpr[3];
assert_ne!(saved, 0);
assert_ne!(saved, current);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, saved),
Some(original.clone())
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::ClearMenuBar;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(current)
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(PpcMenuListDefinition {
mb_res_id: original.mb_res_id,
..PpcMenuListDefinition::default()
})
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, saved),
Some(original.clone()),
"ClearMenuBar must not mutate a caller-owned snapshot"
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SetMenuBar;
loaded.cpu.gpr[3] = saved;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(original.clone())
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, saved),
Some(original)
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_init_menus_publishes_and_reinitializes_a_stable_menu_list() {
let pef = synthetic_pef_with_import(b"InitMenus");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.toolbox_startup.host_menu_bar_hidden = true;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded.toolbox_startup.menus_initialized);
let current = ppc_current_menu_list(&mut loaded.memory);
assert_ne!(current, 0);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(current)
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(PpcMenuListDefinition::default())
);
assert_eq!(
loaded
.handles()
.iter()
.find(|record| record.handle == current)
.map(|record| record.size),
Some(12)
);
let nonstandard = PpcMenuListDefinition {
last_right: 75,
mb_res_id: 0x108,
regular: vec![PpcMenuListEntry {
handle: 0x1111_0000,
value: 11,
}],
menu_title_save: 0x2222_0000,
hierarchical: vec![PpcMenuListEntry {
handle: 0x3333_0000,
value: 0,
}],
};
assert_eq!(
ppc_replace_menu_list_definition(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
current,
&nonstandard,
),
PPC_NO_ERR
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(ppc_current_menu_list(&mut loaded.memory), current);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_LIST),
Some(current)
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, current),
Some(PpcMenuListDefinition::default())
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn native_newmenu_installs_one_callable_standard_mdef_handle() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let title_ptr = PPC_DATA_BASE + 0x6000;
loaded.memory.add_region(title_ptr, vec![0; 32]);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
title_ptr,
b"File"
));
loaded.cpu.gpr[3] = 128;
loaded.cpu.gpr[4] = title_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewMenu);
let first_menu = loaded.cpu.gpr[3];
let first_menu_ptr = loaded.memory.read_u32_be(first_menu).unwrap();
let standard_mdef = loaded.memory.read_u32_be(first_menu_ptr + 6).unwrap();
assert_ne!(standard_mdef, 0);
assert_eq!(
ppc_menu_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
standard_mdef
),
Some(STANDARD_MENU_DEFINITION_SHIM.to_vec())
);
loaded.cpu.gpr[3] = 129;
loaded.cpu.gpr[4] = title_ptr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::NewMenu);
let second_menu_ptr = loaded.memory.read_u32_be(loaded.cpu.gpr[3]).unwrap();
assert_eq!(
loaded.memory.read_u32_be(second_menu_ptr + 6),
Some(standard_mdef),
"NewMenu must reuse the loaded standard MDEF resource Handle"
);
assert_eq!(
loaded
.vfs_resources
.iter()
.filter(|resource| {
resource.res_type == u32::from_be_bytes(*b"MDEF") && resource.res_id == 0
})
.count(),
1
);
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
}
#[test]
fn native_getmenu_loads_and_resolves_mdefs_when_resload_is_disabled() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.policy.set_res_load(false);
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 128,
name: Vec::new(),
data: test_menu_resource(128, b"File").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: test_menu_resource_with_mdef(129, 256, b"Custom").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: vec![0x4e, 0x75].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let standard_menu = loaded.cpu.gpr[3];
let standard_menu_ptr = loaded.memory.read_u32_be(standard_menu).unwrap();
let standard_mdef = loaded.memory.read_u32_be(standard_menu_ptr + 6).unwrap();
assert_eq!(
ppc_menu_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
standard_mdef
),
Some(STANDARD_MENU_DEFINITION_SHIM.to_vec())
);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let custom_menu = loaded.cpu.gpr[3];
let custom_menu_ptr = loaded.memory.read_u32_be(custom_menu).unwrap();
let custom_mdef = loaded.memory.read_u32_be(custom_menu_ptr + 6).unwrap();
let custom_resource = loaded
.vfs_resources
.iter()
.find(|resource| {
resource.res_type == u32::from_be_bytes(*b"MDEF") && resource.res_id == 256
})
.unwrap();
assert_eq!(custom_mdef, custom_resource.handle);
assert_eq!(
ppc_menu_handle_bytes(
&mut loaded.memory,
&test_handle_records!(loaded),
custom_mdef
),
Some(vec![0x4e, 0x75])
);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
assert_eq!(loaded.cpu.gpr[3], custom_menu);
assert_eq!(
loaded.memory.read_u32_be(custom_menu_ptr + 6),
Some(custom_mdef),
"a repeated GetMenu must preserve both resource Handle identities"
);
assert_eq!(loaded.test_resource_error(), PPC_NO_ERR);
}
#[test]
fn native_getmenu_sizes_a_new_custom_menu_through_its_mdef() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
BLR,
],
);
let descriptor_bytes =
ppc_memory_read_bytes(&mut loaded.memory, descriptor, 0x100).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: test_menu_resource_with_mdef(129, 256, b"Custom").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let menu_handle = loaded.cpu.gpr[3];
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
assert!(loaded
.process_memory_manager
.0
.borrow()
.native_ptr_records()
.iter()
.all(|record| record.ptr != loaded.cpu.gpr[5]));
}
#[test]
fn native_getmenu_sizes_through_a_classic_resource_mdef() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
let mdef = vec![
0x20, 0x6f, 0x00, 0x10, 0x20, 0x50, 0x31, 0x7c, 0x00, 0x7b, 0x00, 0x02, 0x31, 0x7c,
0x00, 0x2d, 0x00, 0x04, 0x4e, 0x74, 0x00, 0x12,
];
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 129,
name: Vec::new(),
data: test_menu_resource_with_mdef(129, 256, b"Classic").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: mdef.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 129;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
let menu = loaded.memory.read_u32_be(loaded.cpu.gpr[3]).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
assert!(loaded.guest_calls().is_empty());
assert_eq!(loaded.toolbox_startup.mixed_mode_m68k.storage_pair(), (0, 0));
}
#[test]
fn native_getmenu_returns_nil_when_the_compiled_mdef_is_missing() {
let pef = synthetic_pef_with_import(b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 130,
name: Vec::new(),
data: test_menu_resource_with_mdef(130, 300, b"Missing").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = 130;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.test_resource_error(), PPC_RES_NOT_FOUND_ERR);
}
#[test]
fn native_init_getmenu_and_clear_share_live_menu_color_state() {
let pef = synthetic_pef_with_import(b"InitMenus");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.toolbox_startup.host_menu_bar_hidden = true;
let ref_num = *loaded.process_file_system.current_resource_file;
let menu_bar = test_menu_color_entry(0, 0, 0x11);
let old_title = test_menu_color_entry(128, 0, 0x22);
let new_title = test_menu_color_entry(128, 0, 0x33);
let item = test_menu_color_entry(128, 2, 0x44);
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 0,
name: Vec::new(),
data: test_menu_color_resource(&[menu_bar, old_title]).into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 128,
name: Vec::new(),
data: test_menu_resource(128, b"File").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 128,
name: Vec::new(),
data: test_menu_color_resource(&[new_title, item]).into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
run_test_import(&mut loaded, PpcImportDispatcherTarget::InitMenus);
let color_handle = loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO)
.unwrap();
assert_ne!(color_handle, 0);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[menu_bar.as_slice(), old_title.as_slice()].concat()
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenu);
assert_ne!(loaded.cpu.gpr[3], 0);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[menu_bar.as_slice(), new_title.as_slice(), item.as_slice()].concat()
);
run_test_import(&mut loaded, PpcImportDispatcherTarget::ClearMenuBar);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO),
Some(color_handle),
"ClearMenuBar must preserve the manager-owned MenuCInfo handle"
);
assert!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded))
.is_empty()
);
}
#[test]
fn native_getnewmbar_rebuilds_menu_color_state_from_loaded_menus() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let ref_num = *loaded.process_file_system.current_resource_file;
let stale = test_menu_color_entry(999, 1, 0x11);
let file = test_menu_color_entry(601, 0, 0x22);
let edit = test_menu_color_entry(602, 2, 0x33);
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_ne!(color_handle, 0);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&stale,
),
PPC_NO_ERR
);
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource(601, b"File").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 601,
name: Vec::new(),
data: test_menu_color_resource(&[file]).into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource(602, b"Edit").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"mctb"),
res_id: 602,
name: Vec::new(),
data: test_menu_color_resource(&[edit]).into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetNewMBar);
assert_ne!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_C_INFO),
Some(color_handle)
);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[file.as_slice(), edit.as_slice()].concat()
);
let standard_mdef = loaded
.vfs_resources
.iter()
.find(|resource| {
resource.res_type == u32::from_be_bytes(*b"MDEF") && resource.res_id == 0
})
.map(|resource| resource.handle)
.unwrap();
assert_ne!(standard_mdef, 0);
for menu_id in [601, 602] {
let menu_handle = loaded
.vfs_resources
.iter()
.find(|resource| {
resource.res_type == u32::from_be_bytes(*b"MENU") && resource.res_id == menu_id
})
.map(|resource| resource.handle)
.unwrap();
let menu_ptr = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(
loaded.memory.read_u32_be(menu_ptr + 6),
Some(standard_mdef),
"GetNewMBar must route every MENU through GetMenu MDEF resolution"
);
}
}
#[test]
fn native_getnewmbar_sizes_each_custom_menu_before_returning_the_list() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
BLR,
],
);
let descriptor_bytes =
ppc_memory_read_bytes(&mut loaded.memory, descriptor, 0x100).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource_with_mdef(601, 256, b"First").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource_with_mdef(602, 256, b"Second").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetNewMBar;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let list_handle = loaded.cpu.gpr[3];
let menu_handles = ppc_menu_list_definition(&mut loaded.memory, list_handle)
.unwrap()
.handles()
.collect::<Vec<_>>();
assert_eq!(menu_handles.len(), 2);
for menu_handle in menu_handles {
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
}
assert!(!loaded.guest_calls().has_menu_bar_builds());
}
#[test]
fn native_getnewmbar_resumes_internally_after_classic_mdefs() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let descriptor_bytes = vec![
0x20, 0x6f, 0x00, 0x10, 0x20, 0x50, 0x31, 0x7c, 0x00, 0x7b, 0x00, 0x02, 0x31, 0x7c,
0x00, 0x2d, 0x00, 0x04, 0x4e, 0x74, 0x00, 0x12,
];
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource_with_mdef(601, 256, b"First").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource_with_mdef(602, 256, b"Second").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetNewMBar);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
assert!(loaded.guest_calls().is_empty());
let list_handle = loaded.cpu.gpr[3];
let menu_handles = ppc_menu_list_definition(&mut loaded.memory, list_handle)
.unwrap()
.handles()
.collect::<Vec<_>>();
assert_eq!(menu_handles.len(), 2);
for menu_handle in menu_handles {
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
}
assert!(!loaded.guest_calls().has_menu_bar_builds());
}
#[test]
fn nested_getnewmbar_keeps_each_build_and_its_return_separate() {
let pef = synthetic_pef_with_import(b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
let marker = PPC_DATA_BASE + 0x7800;
loaded.memory.add_region(marker, vec![0; 4]);
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
PPC_CODE_BASE + 0x4000,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(
PPC_PROCINFO_SIZE_NONE,
&[
PPC_PROCINFO_SIZE_TWO,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
PPC_PROCINFO_SIZE_FOUR,
],
),
&[
0x9421_ffa0, 0x7c08_02a6, 0x9001_0064, 0x9081_0038, 0x3860_0385, 0x3d80_0000 | (PPC_IMPORT_TRAP_BASE >> 16),
0x618c_0000 | (PPC_IMPORT_TRAP_BASE & 0xffff),
0x7d89_03a6, 0x4e80_0421, 0x3d40_0000 | (marker >> 16),
0x614a_0000 | (marker & 0xffff),
0x906a_0000, 0x8081_0038,
d_form_u(32, 6, 4, 0),
d_form_u(14, 7, 0, 123),
d_form_u(44, 7, 6, 2),
d_form_u(14, 7, 0, 45),
d_form_u(44, 7, 6, 4),
0x8001_0064,
0x7c08_03a6,
0x3821_0060,
BLR,
],
);
let descriptor_bytes = ppc_memory_read_bytes(&mut loaded.memory, descriptor, 0x100).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 901,
name: Vec::new(),
data: vec![0, 0].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MBAR"),
res_id: 900,
name: Vec::new(),
data: vec![0, 2, 2, 89, 2, 90].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 601,
name: Vec::new(),
data: test_menu_resource_with_mdef(601, 256, b"First").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 602,
name: Vec::new(),
data: test_menu_resource_with_mdef(602, 256, b"Second").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MDEF"),
res_id: 256,
name: Vec::new(),
data: descriptor_bytes.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 900;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetNewMBar;
let probe = loaded.run_with_hle_imports(256);
assert_eq!(probe.handled_import_count, 3);
assert_eq!(probe.unsupported_import_index, None);
let inner = loaded.memory.read_u32_be(marker).unwrap();
assert_ne!(
inner, 0,
"nested GetNewMBar must produce its own menu-list handle"
);
assert_eq!(
ppc_menu_list_definition(&mut loaded.memory, inner)
.unwrap()
.handles()
.count(),
0
);
assert!(loaded.guest_calls().is_empty());
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
let list_handle = loaded.cpu.gpr[3];
let menu_handles = ppc_menu_list_definition(&mut loaded.memory, list_handle)
.unwrap()
.handles()
.collect::<Vec<_>>();
assert_eq!(menu_handles.len(), 2);
for menu_handle in menu_handles {
let menu = loaded.memory.read_u32_be(menu_handle).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu + 2), Some(123));
assert_eq!(loaded.memory.read_u16_be(menu + 4), Some(45));
}
assert!(!loaded.guest_calls().has_menu_bar_builds());
}
#[test]
fn native_menu_deletion_filters_the_shared_menu_color_table() {
let pef = synthetic_pef_with_import(b"DeleteMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let menu_handle = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x6000,
128,
b"File",
b"One;Two",
);
let title = test_menu_color_entry(128, 0, 0x11);
let item_one = test_menu_color_entry(128, 1, 0x22);
let item_two = test_menu_color_entry(128, 2, 0x33);
let unrelated = test_menu_color_entry(129, 0, 0x44);
let color_handle = ppc_ensure_menu_color_table_handle(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
);
assert_eq!(
ppc_replace_menu_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
color_handle,
&[
title.as_slice(),
item_one.as_slice(),
item_two.as_slice(),
unrelated.as_slice(),
]
.concat(),
),
PPC_NO_ERR
);
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 2;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
[title.as_slice(), item_one.as_slice(), unrelated.as_slice()].concat()
);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenu);
assert_eq!(
ppc_menu_color_table_bytes(&mut loaded.memory, &test_handle_records!(loaded)),
unrelated
);
}
#[test]
fn native_menu_manager_mutates_items_dimensions_and_the_current_menu_list() {
let pef = synthetic_pef_with_import(b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let mut free_handle_blocks = loaded.free_handle_blocks();
let scratch = PPC_DATA_BASE + 0x1000;
let title = scratch;
let definitions = scratch + 0x40;
let replacement = scratch + 0x80;
loaded.memory.add_region(scratch, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, title, b"Game"));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
definitions,
b"Start/S;Disabled(;About/A",
));
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
replacement,
b"New Game"
));
let menu = ppc_new_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
128,
title,
);
assert_ne!(menu, 0);
assert_eq!(
ppc_insert_menu_items(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
definitions,
i16::MAX,
),
PPC_NO_ERR
);
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 3);
assert!(ppc_menu_item_enabled(&mut loaded.memory, menu, 1));
assert!(!ppc_menu_item_enabled(&mut loaded.memory, menu, 2));
let mut cpu = PpcCpu::new();
cpu.gpr[3] = menu;
cpu.gpr[4] = 1;
cpu.gpr[5] = replacement;
assert_eq!(
ppc_set_menu_item_text(
&cpu,
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
),
PPC_NO_ERR
);
assert_eq!(
ppc_menu_item(&mut loaded.memory, menu, 1).and_then(|(address, length)| {
ppc_memory_read_bytes(&mut loaded.memory, address + 1, u32::from(length))
}),
Some(b"New Game".to_vec())
);
assert_eq!(
ppc_delete_menu_item(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu,
2,
),
PPC_NO_ERR
);
ppc_calc_menu_size(&mut loaded.memory, menu);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 2);
assert!(loaded.memory.read_u16_be(menu_ptr + 2).unwrap() >= 32);
assert_eq!(loaded.memory.read_u16_be(menu_ptr + 4), Some(32));
assert_eq!(
ppc_insert_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&mut free_handle_blocks,
menu,
0,
),
PPC_NO_ERR
);
let menu_list = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_get_menu_handle(&mut loaded.memory, menu_list, 128,),
menu
);
assert_eq!(
ppc_delete_menu(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
menu_list,
128,
),
PPC_NO_ERR
);
assert_eq!(ppc_get_menu_handle(&mut loaded.memory, menu_list, 128,), 0);
}
#[test]
fn popup_control_selected_title_reads_live_programmatic_menu_items() {
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"NewMenu")).unwrap();
install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
305,
b"Theme",
b"Classic;High Contrast;-;Night Operations",
);
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
assert_eq!(
ppc_popup_control_selected_text(
&mut loaded.memory,
&loaded.process_file_system.vfs_resources,
current_resource_refnum,
305,
1,
),
b"Classic"
);
assert_eq!(
ppc_popup_control_selected_text(
&mut loaded.memory,
&loaded.process_file_system.vfs_resources,
current_resource_refnum,
305,
4,
),
b"Night Operations"
);
}
#[test]
fn popup_control_display_title_clips_to_fixed_width() {
let title = b"Night Operations: Deep Field Archive";
let clipped = ppc_popup_control_display_title(
title,
52,
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
);
assert!(clipped.ends_with(b"..."));
assert_ne!(clipped, title);
assert!(
ppc_text_bytes_advance_for_font(
&clipped,
PPC_QD_TEXT_FONT_DEFAULT,
PPC_QD_TEXT_SIZE_SYSTEM,
) <= 52,
"fixed-width popup title must fit the reserved content width"
);
}
#[test]
fn hle_import_runner_popup_menu_select_tracks_flashes_and_preserves_abi() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
300,
b"Popup",
b"Red;Orange",
);
let front =
ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).expect("main buffer");
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(37) ^ 0xa5)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x2468)
.unwrap();
let menu_bar_len = 20 * front.row_bytes;
let menu_bar_before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_len).unwrap();
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 2;
let original_sp = loaded.cpu.gpr[1];
let original_args = [loaded.cpu.gpr[4], loaded.cpu.gpr[5], loaded.cpu.gpr[6]];
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.pc, PPC_GUEST_CALL_RETURN_PC);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.cpu.gpr[3], menu_handle);
assert_eq!(
[loaded.cpu.gpr[4], loaded.cpu.gpr[5], loaded.cpu.gpr[6]],
original_args
);
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
let parked_lr = loaded.cpu.lr;
assert_eq!(tracking.kind, MenuTrackingKind::PopUp);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_popup(),
Some(MenuTrackingCall {
request: MenuTrackingRequest::PopUp(PopupMenuRequest {
menu_handle,
anchor: (100, 50),
requested_item: 2,
}),
origin: MenuTrackingOrigin::PowerPc { stack_pointer: original_sp, return_address: parked_lr },
})
);
assert_eq!(tracking.popup_left, 50);
assert_eq!(tracking.popup_top + 16, 100);
assert_eq!(tracking.highlighted_item, 2);
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
let white =
ppc_physical_screen_color_pixel(front, PPC_RGB_WHITE, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 4), 100),
),
Some(black),
"requested item did not begin at Top"
);
assert_eq!(
ppc_quickdraw_read_pixel(
&mut loaded.memory,
front,
(i32::from(tracking.popup_left + 4), 99),
),
Some(white),
"row above requested item was also highlighted"
);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before.clone())
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x2468));
let item_one = PpcInputSnapshot {
mouse_button: true,
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
loaded.set_input_snapshot(item_one);
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.lr, parked_lr);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.unwrap()
.highlighted_item,
1
);
let item_two_release = PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 16 + 4,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
};
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 1)
.unwrap();
loaded.set_input_snapshot(item_two_release);
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let flash = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
assert_eq!(flash.flash_remaining, 2);
assert_eq!(flash.highlighted_item, 2);
assert_eq!(flash.flash_result, (300u32 << 16) | 2);
let flash_probe = (
i32::from(tracking.popup_left + 4),
i32::from(tracking.popup_top + 16 + 4),
);
let mut flash_pixels =
vec![ppc_quickdraw_read_pixel(&mut loaded.memory, front, flash_probe).unwrap()];
let mut final_probe = None;
for _ in 0..32 {
let tick = loaded.current_tick().wrapping_add(1);
loaded.set_tick_count(tick);
let probe = loaded.run_with_hle_imports(64);
if loaded.toolbox_startup.execution.menu().is_some() {
flash_pixels.push(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, flash_probe).unwrap(),
);
} else {
final_probe = Some(probe);
break;
}
}
let final_probe = final_probe.expect("popup flash completed");
assert!(matches!(
final_probe.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(loaded.cpu.gpr[3], (300u32 << 16) | 2);
assert!(flash_pixels.contains(&black));
assert!(flash_pixels.contains(&white));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, menu_bar_len),
Some(menu_bar_before)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x2468));
}
#[test]
fn hle_import_runner_popup_menu_select_no_hit_paths_are_atomic() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
300,
b"Popup",
b"First;Second",
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len).unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x1357)
.unwrap();
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 1;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_v: 100,
mouse_h: 50,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before)
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x1357));
let mut miss = load_pef_application(&pef).unwrap();
let regular_menu =
install_test_menu(&mut miss, PPC_DATA_BASE + 0x1000, 304, b"Regular", b"First");
let front = ppc_front_buffer_for_gworld(&miss.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut miss.memory, front.base_addr, framebuffer_len).unwrap();
for (label, menu_handle) in [
("invalid handle", 0xdead_beef),
("menu outside hierarchical list", regular_menu),
] {
miss.cpu.pc = miss.entry_pc;
miss.cpu.lr = PPC_HALT_PC;
miss.cpu.gpr[3] = menu_handle;
miss.cpu.gpr[4] = 100;
miss.cpu.gpr[5] = 50;
miss.cpu.gpr[6] = 1;
miss.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 100,
mouse_h: 50,
..PpcInputSnapshot::default()
});
let probe = miss.run_with_hle_imports(64);
assert!(
matches!(probe.result, PpcRunResult::Halted { .. }),
"{label}"
);
assert_eq!(miss.cpu.gpr[3], 0, "{label}");
assert!(miss.toolbox_startup.execution.menu().is_none(), "{label}");
assert_eq!(
ppc_memory_read_bytes(&mut miss.memory, front.base_addr, framebuffer_len),
Some(before.clone()),
"{label}"
);
}
for (label, item_specs) in [
("disabled item", b"First;Disabled(".as_slice()),
("separator", b"First;-".as_slice()),
] {
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
301,
b"Popup",
item_specs,
);
let front = ppc_front_buffer_for_gworld(&loaded.gworlds, PPC_MAIN_GWORLD).unwrap();
let framebuffer_len = front.row_bytes * front.height;
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x1357)
.unwrap();
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 1;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 16 + 4,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(
matches!(probe.result, PpcRunResult::Halted { .. }),
"{label}"
);
assert_eq!(loaded.cpu.gpr[3], 0, "{label}");
assert!(loaded.toolbox_startup.execution.menu().is_none(), "{label}");
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before),
"{label}"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x1357));
}
}
#[test]
fn hle_import_runner_popup_menu_select_round_trips_supported_depths_and_clamps() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
302,
b"Popup",
b"One;Two;Three",
);
loaded.toolbox_startup.host_menu_bar_hidden = true;
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(29).wrapping_add(depth as u8) ^ 0x96)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
loaded
.memory
.write_u16_be(PPC_THE_MENU_ADDR, 0x55aa)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::PopUpMenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = i16::MAX as u32;
loaded.cpu.gpr[5] = i16::MAX as u32;
loaded.cpu.gpr[6] = 3;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(tracking.kind, MenuTrackingKind::PopUp);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_popup(),
Some(ppc_popup_menu_call(&loaded.cpu))
);
assert_eq!(
i32::from(tracking.popup_left) + i32::from(tracking.saved_width),
i32::try_from(front.width).unwrap() - 3,
"{depth}bpp popup did not clamp its right shadow to the screen"
);
assert_eq!(
i32::from(tracking.popup_top) + i32::from(tracking.saved_height),
i32::try_from(front.height).unwrap(),
"{depth}bpp popup did not clamp its shadow to the screen"
);
assert_ne!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(pattern.clone()),
"{depth}bpp popup did not draw"
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 4,
mouse_h: tracking.popup_left - 1,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(pattern),
"{depth}bpp popup did not restore framebuffer and row padding"
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0x55aa));
}
}
#[test]
fn hle_import_runner_popup_menu_select_tracks_oversized_content_from_shared_layout() {
let pef = synthetic_pef_with_import(b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let description = (0..40).map(|_| "A").collect::<Vec<_>>().join(";");
let menu_handle = install_test_popup_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
303,
b"Popup",
description.as_bytes(),
);
loaded.toolbox_startup.host_menu_bar_hidden = true;
loaded.cpu.gpr[3] = menu_handle;
loaded.cpu.gpr[4] = 100;
loaded.cpu.gpr[5] = 120;
loaded.cpu.gpr[6] = 20;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 100,
mouse_h: 124,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
assert_eq!(tracking.popup_top, 4);
assert_eq!(tracking.popup_height, 576);
assert_eq!(tracking.content_top, -204);
assert_eq!(tracking.highlighted_item, 20);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::TOP_MENU_ITEM)
.map(|value| value as i16),
Some(-204),
);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::AT_MENU_BOTTOM)
.map(|value| value as i16),
Some(436),
);
let indicator_point = (
i32::from(tracking.popup_left + tracking.popup_width / 2),
i32::from(tracking.popup_top + 4),
);
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let black =
ppc_physical_screen_color_pixel(front, PPC_RGB_BLACK, &loaded.screen_clut).unwrap();
assert_eq!(
ppc_quickdraw_read_pixel(&mut loaded.memory, front, indicator_point),
Some(black),
"the hidden upper content must replace the first visible row with an indicator"
);
assert_eq!(
ppc_menu_tracking_item(
&mut loaded.memory,
tracking,
PpcInputSnapshot {
mouse_button: true,
mouse_v: 100,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
},
),
20,
);
let popup_left = tracking.popup_left;
for (mouse_v, expected_item, expected_top, expected_bottom) in [
(28, 15, -204, 436),
(12, 0, -204, 436),
(12, 0, -188, 452),
(3, 0, -172, 468),
] {
let action = ppc_dispatch_pop_up_menu_select(
&loaded.cpu,
&mut loaded.memory,
&loaded.gworlds,
&loaded.screen_clut,
MenuColorTable::new(&[]),
&mut loaded.toolbox_startup,
PpcInputSnapshot {
mouse_button: true,
mouse_v,
mouse_h: popup_left + 4,
..PpcInputSnapshot::default()
},
&loaded.process_file_system.vfs_resources,
*loaded.process_file_system.current_resource_file,
);
assert!(matches!(action, PpcImportAction::Yield(_)));
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
assert_eq!(tracking.highlighted_item, expected_item);
assert_eq!(tracking.content_top, expected_top);
assert_eq!(
loaded
.memory
.read_u16_be(crate::memory::globals::addr::AT_MENU_BOTTOM)
.map(|value| value as i16),
Some(expected_bottom),
);
}
}
pub(crate) fn native_menu_hook_fixture() -> (PpcLoadedApp, u32, u32) {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Open;Close",
);
let menu_record = loaded.memory.read_u32_be(menu).unwrap();
let descriptor = PPC_DATA_BASE + 0x7100;
let tvector = PPC_DATA_BASE + 0x7180;
let marker = PPC_DATA_BASE + 0x7400;
loaded.memory.add_region(marker, vec![0; 4]);
let mut set_port = compatibility_binding(
"InterfaceLib",
"SetPort",
PpcImportDispatcherTarget::SetPort,
);
set_port.symbol_index = 1;
set_port.trap_pc = PPC_IMPORT_TRAP_BASE + 4;
loaded
.memory
.add_region(PPC_IMPORT_TRAP_BASE + 4, vec![0; 4]);
loaded.imports.push(set_port);
loaded.import_count = 2;
let callback_entry = PPC_CODE_BASE + 0x4000;
install_test_powerpc_callback(
&mut loaded,
descriptor,
tvector,
callback_entry,
PPC_DATA_BASE + 0x7300,
test_stack_proc_info(PPC_PROCINFO_SIZE_NONE, &[]),
&[
0x7fe8_02a6,
d_form_u(15, 3, 0, (PPC_DSP_BACK_GWORLD >> 16) as u16),
d_form_u(24, 3, 3, PPC_DSP_BACK_GWORLD as u16),
0x4800_0000
| ((PPC_IMPORT_TRAP_BASE + 4).wrapping_sub(callback_entry + 3 * 4)
& 0x03ff_fffc)
| 1,
0x7fe8_03a6,
d_form_u(15, 7, 0, (menu_record >> 16) as u16),
d_form_u(24, 7, 7, menu_record as u16),
d_form_u(40, 10, 7, 2),
d_form_u(14, 10, 10, 1),
d_form_u(44, 10, 7, 2),
d_form_u(15, 8, 0, (marker >> 16) as u16),
d_form_u(24, 8, 8, marker as u16),
d_form_u(32, 9, 8, 0),
d_form_u(14, 9, 9, 1),
d_form_u(36, 9, 8, 0),
d_form_u(14, 3, 0, 77),
BLR,
],
);
loaded.memory.write_u32_be(0x0a30, descriptor).unwrap();
(loaded, marker, menu_record)
}
#[test]
fn native_menu_tracking_invokes_menu_hook_while_held() {
let (mut loaded, marker, menu_record) = native_menu_hook_fixture();
let original_menu_width = loaded.memory.read_u16_be(menu_record + 2).unwrap();
let original_sp = loaded.cpu.gpr[1];
let original_return = loaded.cpu.lr;
let original_port = (*loaded.current_gworld, *loaded.current_gdevice);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
let initial_point =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.cpu.gpr[3] = initial_point;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.toolbox_startup.execution.menu().is_some());
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_port,
Some(original_port),
);
assert_eq!(*loaded.current_gworld, PPC_DSP_BACK_GWORLD);
assert_ne!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(
loaded.memory.read_u32_be(marker).unwrap() > 0,
"MenuSelect must invoke MenuHook while held"
);
assert!(loaded.memory.read_u16_be(menu_record + 2).unwrap() > original_menu_width);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..8 {
let probe = loaded.run_with_hle_imports(128);
if matches!(probe.result, PpcRunResult::Halted { .. }) {
break;
}
}
assert_eq!(loaded.cpu.pc, original_return);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert_eq!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(loaded.guest_calls().is_empty());
assert!(loaded.toolbox_startup.execution.menu().is_none());
}
#[test]
fn refused_native_menu_hook_leaves_no_receipt_or_port_and_retries() {
let (mut loaded, marker, _) = native_menu_hook_fixture();
let descriptor = loaded.memory.read_u32_be(0x0a30).unwrap();
loaded.memory.write_u32_be(0x0a30, 0).unwrap();
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.guest_calls().depth(), 0);
assert_eq!(loaded.toolbox_startup.execution.menu().menu_hook_key(), None);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_port,
None
);
assert_eq!(loaded.memory.read_u32_be(marker), Some(0));
loaded.memory.write_u32_be(0x0a30, descriptor).unwrap();
loaded
.memory
.write_u32_be(descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE, 1)
.unwrap();
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.guest_calls().depth(), 0);
assert_eq!(loaded.toolbox_startup.execution.menu().menu_hook_key(), None);
assert_eq!(
loaded.toolbox_startup.execution.menu().context().native_port,
None
);
assert_eq!(loaded.memory.read_u32_be(marker), Some(0));
loaded
.memory
.write_u32_be(descriptor + PPC_ROUTINE_DESCRIPTOR_HEADER_SIZE, 0)
.unwrap();
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.memory.read_u32_be(marker).unwrap() > 0);
assert!(loaded
.toolbox_startup
.execution.menu()
.context()
.native_port
.is_some());
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 500,
mouse_h: 500,
..PpcInputSnapshot::default()
});
for _ in 0..8 {
if matches!(
loaded.run_with_hle_imports(128).result,
PpcRunResult::Halted { .. }
) {
break;
}
}
assert!(loaded.guest_calls().is_empty());
assert!(loaded.toolbox_startup.execution.menu().is_none());
}
#[test]
fn native_menu_hook_host_selection_restores_port_and_retires_its_root() {
let (mut loaded, marker, _) = native_menu_hook_fixture();
let original_port = (*loaded.current_gworld, *loaded.current_gdevice);
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.memory.read_u32_be(marker).unwrap() > 0);
assert!(loaded
.toolbox_startup
.pending_native_menu_selection
.stage((128, 1)));
for _ in 0..8 {
if matches!(
loaded.run_with_hle_imports(128).result,
PpcRunResult::Halted { .. }
) {
break;
}
}
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert_eq!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn native_menu_hook_flash_completion_restores_port_and_retires_its_root() {
let (mut loaded, marker, _) = native_menu_hook_fixture();
let original_port = (*loaded.current_gworld, *loaded.current_gdevice);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 1)
.unwrap();
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
for _ in 0..4 {
let probe = loaded.run_with_hle_imports(128);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
}
assert!(loaded.memory.read_u32_be(marker).unwrap() > 0);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let flash_start = loaded.current_tick();
for elapsed in 0..16 {
loaded.set_tick_count(flash_start.wrapping_add(elapsed));
if matches!(
loaded.run_with_hle_imports(128).result,
PpcRunResult::Halted { .. }
) {
break;
}
}
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert_eq!(
(*loaded.current_gworld, *loaded.current_gdevice),
original_port
);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_empty());
}
#[test]
fn native_menu_wait_resumes_without_repeating_public_import() {
for popup in [false, true] {
let symbol: &[u8] = if popup {
b"PopUpMenuSelect"
} else {
b"MenuSelect"
};
let pef = synthetic_pef_with_import(symbol);
let mut loaded = load_pef_application(&pef).unwrap();
let install = if popup { install_test_popup_menu } else { install_test_menu };
let menu = install(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Open;Close",
);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
loaded.cpu.lr = PPC_HALT_PC;
let original_sp = loaded.cpu.gpr[1];
loaded.cpu.gpr[3] =
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16);
if popup {
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 20;
loaded.cpu.gpr[5] = 12;
loaded.cpu.gpr[6] = 1;
}
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 28,
mouse_h: 20,
..PpcInputSnapshot::default()
});
let first = loaded.run_with_hle_imports(64);
assert_eq!(first.handled_import_count, 1);
assert!(loaded.toolbox_startup.execution.menu().is_some(), "popup={popup}, result={:?}, r3={:08x}", first.result, loaded.cpu.gpr[3]);
let tracking = loaded.toolbox_startup.execution.menu().as_ref().unwrap();
let pointer = (tracking.popup_top + 4, tracking.popup_left + 4);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: pointer.0,
mouse_h: pointer.1,
..PpcInputSnapshot::default()
});
let waiting = loaded.run_with_hle_imports(64);
assert_eq!(
waiting.handled_import_count, 0,
"waiting resumes the operation, not its public import"
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: pointer.0,
mouse_h: pointer.1,
..PpcInputSnapshot::default()
});
let released = loaded.run_with_hle_imports(64);
assert_eq!(released.handled_import_count, 0);
assert_eq!(loaded.cpu.pc, PPC_HALT_PC);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(loaded.cpu.gpr[3], (128 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert!(loaded.guest_calls().is_empty());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = if popup {
menu
} else {
(10u32 << 16) | u32::from((STANDARD_MENU_BAR_FIRST_TITLE_LEFT + 2) as u16)
};
let fresh = loaded.run_with_hle_imports(64);
assert_eq!(fresh.handled_import_count, 1);
}
}
#[test]
fn hle_import_runner_menu_select_initial_release_uses_retained_rows() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(
&mut loaded,
PPC_DATA_BASE + 0x1000,
128,
b"File",
b"Icon row;Second",
);
let icon = ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 0).unwrap();
loaded.memory.write_u8(icon, 1).unwrap();
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
let title_left = STANDARD_MENU_BAR_FIRST_TITLE_LEFT;
let front =
ppc_live_front_buffer_for_gworld(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.unwrap();
let expected =
ppc_begin_menu_bar_tracking(&mut loaded.memory, front, menu, title_left).unwrap();
assert_eq!(expected.item_appearances[0].height, 34);
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = (10u32 << 16) | u32::from((title_left + 2) as u16);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: expected.popup_top + 20,
mouse_h: expected.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (128u32 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
}
#[test]
fn hle_import_runner_menu_select_switches_titles_and_restores_supported_depths() {
let pef = synthetic_pef_with_import(b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let file_menu =
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1000, 128, b"File", b"Open");
let edit_menu =
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1400, 129, b"Edit", b"Cut");
let disabled_menu =
install_test_menu(&mut loaded, PPC_DATA_BASE + 0x1800, 130, b"View", b"Zoom");
ppc_set_menu_item_enabled(
&mut loaded.memory,
&test_handle_records!(loaded),
disabled_menu,
0,
false,
);
let file_left = STANDARD_MENU_BAR_FIRST_TITLE_LEFT;
let edit_left = file_left
.saturating_add(standard_menu_title_advance(b"File"))
.saturating_add(STANDARD_MENU_BAR_TITLE_SPACING);
let disabled_left = edit_left
.saturating_add(standard_menu_title_advance(b"Edit"))
.saturating_add(STANDARD_MENU_BAR_TITLE_SPACING);
let point = |v: i16, h: i16| (u32::from(v as u16) << 16) | u32::from(h as u16);
let menu_list = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(
ppc_menu_handle_at_title_point(&mut loaded.memory, menu_list, point(10, edit_left + 2),),
Some((edit_menu, edit_left)),
);
assert_eq!(
ppc_menu_handle_at_title_point(
&mut loaded.memory,
menu_list,
point(10, disabled_left + 2),
),
Some((disabled_menu, disabled_left)),
"a disabled title remains available for examination",
);
for depth in [1, 2, 4, 8, 16] {
loaded.cpu.gpr[3] = PPC_MAIN_GDEVICE;
loaded.cpu.gpr[4] = depth;
loaded.cpu.gpr[5] = 1;
loaded.cpu.gpr[6] = u32::from(depth != 1);
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetDepth);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let front = ppc_live_front_buffer_for_gworld(
&mut loaded.memory,
&loaded.gworlds,
PPC_MAIN_GWORLD,
)
.unwrap();
let framebuffer_len = front.row_bytes * front.height;
let pattern = (0..usize::try_from(framebuffer_len).unwrap())
.map(|index| (index as u8).wrapping_mul(31).wrapping_add(depth as u8) ^ 0x6d)
.collect::<Vec<_>>();
loaded
.memory
.write_bytes(front.base_addr, &pattern)
.unwrap();
assert!(draw_current_test_menu_bar(&mut loaded));
let before =
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len)
.unwrap();
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = point(10, file_left + 2);
let original_sp = loaded.cpu.gpr[1];
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: file_left + 2,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(file_menu),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(128));
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: edit_left + 2,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(edit_menu),
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(129));
for (mouse_h, expected_menu, expected_id) in [
(file_left + 2, file_menu, 128),
(edit_left + 2, edit_menu, 129),
] {
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(expected_menu),
);
assert_eq!(
loaded.memory.read_u16_be(PPC_THE_MENU_ADDR),
Some(expected_id),
);
}
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: disabled_left + 2,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.menu_handle),
Some(disabled_menu),
"{depth}bpp disabled title did not open",
);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(130));
let disabled_tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
assert_eq!(
disabled_tracking.highlighted_item, 0,
"{depth}bpp disabled menu item became highlighted",
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: disabled_tracking.popup_top + 8,
mouse_h: disabled_tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.cpu.gpr[1], original_sp);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
assert_eq!(
loaded
.memory
.read_u32_be(crate::memory::globals::addr::MENU_DISABLE),
Some(menu_choice_value(130, 1)),
"{depth}bpp disabled menu did not expose its raw hovered row",
);
loaded.cpu.gpr[3] = 0xDEAD_BEEF;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuChoice);
assert_eq!(
loaded.cpu.gpr[3],
menu_choice_value(130, 1),
"{depth}bpp MenuChoice did not return the disabled menu row",
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, front.base_addr, framebuffer_len),
Some(before),
"{depth}bpp switched dropdowns did not restore the framebuffer",
);
}
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::MenuSelect;
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = point(10, file_left + 2);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: file_left + 2,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: edit_left + 2,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
let switched = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 1)
.unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: switched.popup_top + 6,
mouse_h: switched.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::CycleLimit { .. }));
assert_eq!(
loaded
.toolbox_startup
.execution.menu()
.as_ref()
.map(|state| state.flash_remaining),
Some(2)
);
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: 0,
mouse_h: 0,
..PpcInputSnapshot::default()
});
loaded
.toolbox_startup
.execution
.with_menu_state_mut(|state| state.flash_deadline = state.flash_tick.unwrap_or(0))
.unwrap();
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
loaded
.toolbox_startup
.execution
.with_menu_state_mut(|state| state.flash_deadline = state.flash_tick.unwrap_or(0))
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (129u32 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(129));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = point(10, file_left + 2);
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 0)
.unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: true,
mouse_v: 10,
mouse_h: file_left + 2,
..PpcInputSnapshot::default()
});
assert!(matches!(
loaded.run_with_hle_imports(64).result,
PpcRunResult::CycleLimit { .. }
));
let tracking = loaded.toolbox_startup.execution.menu().snapshot().unwrap();
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_button: false,
mouse_v: tracking.popup_top + 6,
mouse_h: tracking.popup_left + 4,
..PpcInputSnapshot::default()
});
let probe = loaded.run_with_hle_imports(64);
assert!(matches!(probe.result, PpcRunResult::Halted { .. }));
assert_eq!(loaded.cpu.gpr[3], (128u32 << 16) | 1);
assert!(loaded.toolbox_startup.execution.menu().is_none());
}
#[test]
fn hle_import_runner_handles_menu_bar_height_accessors() {
let pef = synthetic_pef_with_import(b"GetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 20);
let pef = synthetic_pef_with_import(b"LMSetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 37;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR), Some(37));
}
#[test]
fn carbon_menu_item_accessors_bind_weak_imports() {
for (symbol, target) in [
(b"EnableMenuItem".as_slice(), PpcImportDispatcherTarget::EnableMenuItem),
(b"DisableMenuItem".as_slice(), PpcImportDispatcherTarget::DisableMenuItem),
] {
let weak_pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"CarbonLib",
symbol,
0x82,
&[sm_index_reloc(0x30, 0)],
));
let mut weak_loaded = load_pef_application(&weak_pef).unwrap();
assert_eq!(weak_loaded.imports[0].dispatcher_target, target);
assert_ne!(weak_loaded.imports[0].address, 0);
assert_eq!(
weak_loaded.memory.read_u32_be(PPC_DATA_BASE),
Some(weak_loaded.imports[0].address)
);
let pef = synthetic_pef_with_library_import(b"CarbonLib", symbol);
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
}
}
#[test]
fn menu_bar_lifecycle_and_lowmem_commands_dispatch_with_canonical_evaluation() {
for lib in [b"CarbonLib".as_slice(), b"AppearanceLib".as_slice()] {
{
let pef = synthetic_pef_with_library_import(lib, b"InitMenus");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert!(loaded.toolbox_startup.menus_initialized);
assert_ne!(ppc_current_menu_list(&mut loaded.memory), 0);
assert_eq!(loaded.memory.read_u16_be(PPC_THE_MENU_ADDR), Some(0));
}
{
let pef = synthetic_pef_with_library_import(lib, b"InvalMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert!(loaded.event_queue.menu_bar_is_invalid());
let pef = synthetic_pef_with_library_import(lib, b"DrawMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.event_queue.invalidate_menu_bar();
assert!(loaded.event_queue.menu_bar_is_invalid());
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert!(!loaded.event_queue.menu_bar_is_invalid());
}
{
let pef = synthetic_pef_with_library_import(lib, b"SetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 25;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR), Some(25));
let pef = synthetic_pef_with_library_import(lib, b"GetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 20);
let pef = synthetic_pef_with_library_import(lib, b"GetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.write_u16_be(PPC_MBAR_HEIGHT_ADDR, 25).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 25);
let pef = synthetic_pef_with_library_import(lib, b"LMGetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.write_u16_be(PPC_MBAR_HEIGHT_ADDR, 22).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 22);
let pef = synthetic_pef_with_library_import(lib, b"LMSetMBarHeight");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 30;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR), Some(30));
}
{
let pef = synthetic_pef_with_library_import(lib, b"SetMenuFlash");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 5;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
loaded.memory.read_u16_be(crate::memory::globals::addr::MENU_FLASH),
Some(5)
);
let pef = synthetic_pef_with_library_import(lib, b"LMGetMenuFlash");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.memory
.write_u16_be(crate::memory::globals::addr::MENU_FLASH, 7)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 7);
let pef = synthetic_pef_with_library_import(lib, b"LMSetMenuFlash");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(
loaded.memory.read_u16_be(crate::memory::globals::addr::MENU_FLASH),
Some(2)
);
}
{
let pef = synthetic_pef_with_library_import(lib, b"LMGetMenuList");
let mut loaded = load_pef_application(&pef).unwrap();
ppc_set_current_menu_list(&mut loaded.memory, 0x55443322);
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 0x55443322);
}
{
let pef = synthetic_pef_with_library_import(lib, b"LMSetMenuHook");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x88776655;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.memory.read_u32_be(0x0a30), Some(0x88776655));
}
{
let pef = synthetic_pef_with_library_import(lib, b"GetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let snapshot = loaded.cpu.gpr[3];
assert_ne!(snapshot, 0);
let pef = synthetic_pef_with_library_import(lib, b"ClearMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pef = synthetic_pef_with_library_import(lib, b"SetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = snapshot;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pef = synthetic_pef_with_library_import(lib, b"SetMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.last_mem_error(), PPC_PARAM_ERR);
let pef = synthetic_pef_with_library_import(lib, b"GetNewMBar");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 0);
}
{
let pef = synthetic_pef_with_library_import(lib, b"GetMenuHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 101, b"\x04Test", b"");
loaded.cpu.gpr[3] = 101;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], menu);
let pef = synthetic_pef_with_library_import(lib, b"GetMHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 102, b"\x04Test", b"");
loaded.cpu.gpr[3] = 102;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], menu);
let pef = synthetic_pef_with_library_import(lib, b"GetMHandle");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 999;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], 0);
}
{
let pef = synthetic_pef_with_library_import(lib, b"HiliteMenu");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pef = synthetic_pef_with_library_import(lib, b"FlashMenuBar");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
}
{
let pef = synthetic_pef_with_library_import(lib, b"HMGetHelpMenuHandle");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pef = synthetic_pef_with_library_import(lib, b"HMGetBalloons");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
let pef = synthetic_pef_with_library_import(lib, b"HMIsBalloon");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
}
}
#[test]
fn import_bindings_classify_menu_creation_and_sizing_imports() {
for lib in ["InterfaceLib", "AppearanceLib", "CarbonLib"] {
assert_eq!(
dispatcher_target_for_import(lib, "NewMenu"),
PpcImportDispatcherTarget::NewMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "newmenu"),
PpcImportDispatcherTarget::NewMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "DisposeMenu"),
PpcImportDispatcherTarget::DisposeMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "disposemenu"),
PpcImportDispatcherTarget::DisposeMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "DisposMenu"),
PpcImportDispatcherTarget::DisposeMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "disposmenu"),
PpcImportDispatcherTarget::DisposeMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMenu"),
PpcImportDispatcherTarget::GetMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenu"),
PpcImportDispatcherTarget::GetMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "CalcMenuSize"),
PpcImportDispatcherTarget::CalcMenuSize
);
assert_eq!(
dispatcher_target_for_import(lib, "calcmenusize"),
PpcImportDispatcherTarget::CalcMenuSize
);
}
}
#[test]
fn menu_creation_disposal_loading_and_sizing_commands_dispatch_with_canonical_evaluation() {
for lib in [b"CarbonLib".as_slice(), b"AppearanceLib".as_slice()] {
{
let pef = synthetic_pef_with_library_import(lib, b"NewMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let title_addr = 0x60000;
loaded.memory.add_region(title_addr, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, title_addr, b"File"));
loaded.cpu.gpr[3] = 200;
loaded.cpu.gpr[4] = title_addr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let menu = loaded.cpu.gpr[3];
assert_ne!(menu, 0);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_ptr), Some(200));
}
{
let pef = synthetic_pef_with_library_import(lib, b"CalcMenuSize");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 201, b"\x04Edit", b"Cut;Copy;Paste");
loaded.cpu.gpr[3] = menu;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
let menu_width = loaded.memory.read_u16_be(menu_ptr + 2).unwrap() as i16;
let menu_height = loaded.memory.read_u16_be(menu_ptr + 4).unwrap() as i16;
assert!(menu_width > 0);
assert!(menu_height > 0);
let pef = synthetic_pef_with_library_import(lib, b"CalcMenuSize");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
}
{
let pef = synthetic_pef_with_library_import(lib, b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"MENU"),
res_id: 300,
name: Vec::new(),
data: test_menu_resource(300, b"Window").into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = 300;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let menu = loaded.cpu.gpr[3];
assert_ne!(menu, 0);
let menu_ptr = loaded.memory.read_u32_be(menu).unwrap();
assert_eq!(loaded.memory.read_u16_be(menu_ptr), Some(300));
let pef = synthetic_pef_with_library_import(lib, b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
let pef = synthetic_pef_with_library_import(lib, b"GetMenu");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 999;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
{
let pef = synthetic_pef_with_library_import(lib, b"DisposeMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 202, b"\x04Help", b"");
loaded.cpu.gpr[3] = menu;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(menu), Some(0));
let pef = synthetic_pef_with_library_import(lib, b"DisposeMenu");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pef = synthetic_pef_with_library_import(lib, b"DisposMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 203, b"\x04Help", b"");
loaded.cpu.gpr[3] = menu;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(menu), Some(0));
}
}
}
#[test]
fn import_bindings_classify_menu_item_insertion_and_deletion_imports() {
for lib in ["InterfaceLib", "AppearanceLib", "CarbonLib"] {
assert_eq!(
dispatcher_target_for_import(lib, "AppendMenu"),
PpcImportDispatcherTarget::AppendMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "appendmenu"),
PpcImportDispatcherTarget::AppendMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "InsertMenu"),
PpcImportDispatcherTarget::InsertMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "insertmenu"),
PpcImportDispatcherTarget::InsertMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "DeleteMenu"),
PpcImportDispatcherTarget::DeleteMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "deletemenu"),
PpcImportDispatcherTarget::DeleteMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "DelMenu"),
PpcImportDispatcherTarget::DeleteMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "delmenu"),
PpcImportDispatcherTarget::DeleteMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "InsertMenuItem"),
PpcImportDispatcherTarget::InsertMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "insertmenuitem"),
PpcImportDispatcherTarget::InsertMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "InsMenuItem"),
PpcImportDispatcherTarget::InsertMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "insmenuitem"),
PpcImportDispatcherTarget::InsertMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "DeleteMenuItem"),
PpcImportDispatcherTarget::DeleteMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "deletemenuitem"),
PpcImportDispatcherTarget::DeleteMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "DelMenuItem"),
PpcImportDispatcherTarget::DeleteMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "delmenuitem"),
PpcImportDispatcherTarget::DeleteMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "AppendResMenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "appendresmenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "AddResMenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "addresmenu"),
PpcImportDispatcherTarget::AppendResMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "InsertResMenu"),
PpcImportDispatcherTarget::InsertResMenu
);
assert_eq!(
dispatcher_target_for_import(lib, "insertresmenu"),
PpcImportDispatcherTarget::InsertResMenu
);
}
}
#[test]
fn menu_item_insertion_deletion_and_resource_commands_dispatch_with_canonical_evaluation() {
for lib in [b"CarbonLib".as_slice(), b"AppearanceLib".as_slice()] {
{
let pef = synthetic_pef_with_library_import(lib, b"AppendMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 201, b"\x04Edit", b"");
let items_ptr = 0x60100;
assert!(ppc_write_pstring_bytes(&mut loaded.memory, items_ptr, b"Cut;Copy;Paste"));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = items_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert_eq!(items.len(), 3);
assert_eq!(items[0].text, b"Cut");
assert_eq!(items[1].text, b"Copy");
assert_eq!(items[2].text, b"Paste");
}
{
let pef = synthetic_pef_with_library_import(lib, b"InsertMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 202, b"\x04Test", b"First;Third");
let item_ptr = 0x60100;
assert!(ppc_write_pstring_bytes(&mut loaded.memory, item_ptr, b"Second"));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = item_ptr;
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert_eq!(items.len(), 3);
assert_eq!(items[0].text, b"First");
assert_eq!(items[1].text, b"Second");
assert_eq!(items[2].text, b"Third");
let pef = synthetic_pef_with_library_import(lib, b"InsMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 203, b"\x04Test", b"First;Third");
let item_ptr = 0x60100;
assert!(ppc_write_pstring_bytes(&mut loaded.memory, item_ptr, b"Second"));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = item_ptr;
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert_eq!(items.len(), 3);
assert_eq!(items[1].text, b"Second");
}
{
let pef = synthetic_pef_with_library_import(lib, b"DeleteMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 204, b"\x04Test", b"A;B;C");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert_eq!(items.len(), 2);
assert_eq!(items[0].text, b"A");
assert_eq!(items[1].text, b"C");
let pef = synthetic_pef_with_library_import(lib, b"DelMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 205, b"\x04Test", b"A;B;C");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert_eq!(items.len(), 2);
assert_eq!(items[0].text, b"B");
assert_eq!(items[1].text, b"C");
}
{
let pef = synthetic_pef_with_library_import(lib, b"InsertMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 206, b"\x04Test", b"");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let current = ppc_current_menu_list(&mut loaded.memory);
let handles = ppc_menu_list_handles(&mut loaded.memory, current).unwrap();
assert!(handles.contains(&menu));
let pef = synthetic_pef_with_library_import(lib, b"DeleteMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 207, b"\x04Test", b"");
let current = ppc_current_menu_list(&mut loaded.memory);
assert!(ppc_menu_list_handles(&mut loaded.memory, current).unwrap().contains(&menu));
loaded.cpu.gpr[3] = 207;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let current = ppc_current_menu_list(&mut loaded.memory);
assert!(!ppc_menu_list_handles(&mut loaded.memory, current).unwrap().contains(&menu));
let pef = synthetic_pef_with_library_import(lib, b"DelMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 208, b"\x04Test", b"");
let current = ppc_current_menu_list(&mut loaded.memory);
assert!(ppc_menu_list_handles(&mut loaded.memory, current).unwrap().contains(&menu));
loaded.cpu.gpr[3] = 208;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let current = ppc_current_menu_list(&mut loaded.memory);
assert!(!ppc_menu_list_handles(&mut loaded.memory, current).unwrap().contains(&menu));
}
{
let pef = synthetic_pef_with_library_import(lib, b"AppendResMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 209, b"\x04Apple", b"Existing");
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"DRVR"),
res_id: 1,
name: b"Calculator".to_vec(),
data: vec![0; 4].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"DRVR");
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert!(items.iter().any(|item| item.text == b"Calculator"));
let pef = synthetic_pef_with_library_import(lib, b"AddResMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 210, b"\x04Apple", b"Existing");
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"DRVR"),
res_id: 2,
name: b"Key Caps".to_vec(),
data: vec![0; 4].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"DRVR");
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert!(items.iter().any(|item| item.text == b"Key Caps"));
let pef = synthetic_pef_with_library_import(lib, b"InsertResMenu");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 211, b"\x04Apple", b"First;Second");
let ref_num = *loaded.process_file_system.current_resource_file;
loaded.process_file_system.extend_vfs_resources([
PpcVfsResourceRecord {
ref_num,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"DRVR"),
res_id: 3,
name: b"Puzzle".to_vec(),
data: vec![0; 4].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
},
]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"DRVR");
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert!(items.iter().any(|item| item.text == b"Puzzle"));
}
}
}
#[test]
fn import_bindings_classify_menu_item_attribute_imports() {
for lib in ["InterfaceLib", "AppearanceLib", "CarbonLib"] {
assert_eq!(
dispatcher_target_for_import(lib, "CountMItems"),
PpcImportDispatcherTarget::CountMItems
);
assert_eq!(
dispatcher_target_for_import(lib, "countmitems"),
PpcImportDispatcherTarget::CountMItems
);
assert_eq!(
dispatcher_target_for_import(lib, "CountMenuItems"),
PpcImportDispatcherTarget::CountMItems
);
assert_eq!(
dispatcher_target_for_import(lib, "countmenuitems"),
PpcImportDispatcherTarget::CountMItems
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMenuItemText"),
PpcImportDispatcherTarget::GetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenuitemtext"),
PpcImportDispatcherTarget::GetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "GetItem"),
PpcImportDispatcherTarget::GetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "getitem"),
PpcImportDispatcherTarget::GetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMenuItemText"),
PpcImportDispatcherTarget::SetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "setmenuitemtext"),
PpcImportDispatcherTarget::SetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "SetItem"),
PpcImportDispatcherTarget::SetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "setitem"),
PpcImportDispatcherTarget::SetMenuItemText
);
assert_eq!(
dispatcher_target_for_import(lib, "EnableMenuItem"),
PpcImportDispatcherTarget::EnableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "enablemenuitem"),
PpcImportDispatcherTarget::EnableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "EnableItem"),
PpcImportDispatcherTarget::EnableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "enableitem"),
PpcImportDispatcherTarget::EnableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "DisableMenuItem"),
PpcImportDispatcherTarget::DisableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "disablemenuitem"),
PpcImportDispatcherTarget::DisableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "DisableItem"),
PpcImportDispatcherTarget::DisableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "disableitem"),
PpcImportDispatcherTarget::DisableMenuItem
);
assert_eq!(
dispatcher_target_for_import(lib, "SetItemMark"),
PpcImportDispatcherTarget::SetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "setitemmark"),
PpcImportDispatcherTarget::SetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMenuItemMark"),
PpcImportDispatcherTarget::SetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "setmenuitemmark"),
PpcImportDispatcherTarget::SetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "GetItemMark"),
PpcImportDispatcherTarget::GetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "getitemmark"),
PpcImportDispatcherTarget::GetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMenuItemMark"),
PpcImportDispatcherTarget::GetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenuitemmark"),
PpcImportDispatcherTarget::GetItemMark
);
assert_eq!(
dispatcher_target_for_import(lib, "CheckItem"),
PpcImportDispatcherTarget::CheckItem
);
assert_eq!(
dispatcher_target_for_import(lib, "checkitem"),
PpcImportDispatcherTarget::CheckItem
);
assert_eq!(
dispatcher_target_for_import(lib, "CheckMenuItem"),
PpcImportDispatcherTarget::CheckItem
);
assert_eq!(
dispatcher_target_for_import(lib, "checkmenuitem"),
PpcImportDispatcherTarget::CheckItem
);
assert_eq!(
dispatcher_target_for_import(lib, "SetItemCmd"),
PpcImportDispatcherTarget::SetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "setitemcmd"),
PpcImportDispatcherTarget::SetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMenuItemCmd"),
PpcImportDispatcherTarget::SetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "setmenuitemcmd"),
PpcImportDispatcherTarget::SetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "GetItemCmd"),
PpcImportDispatcherTarget::GetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "getitemcmd"),
PpcImportDispatcherTarget::GetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMenuItemCmd"),
PpcImportDispatcherTarget::GetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenuitemcmd"),
PpcImportDispatcherTarget::GetItemCmd
);
assert_eq!(
dispatcher_target_for_import(lib, "GetItemIcon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "getitemicon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMenuItemIcon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenuitemicon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "SetItemIcon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "setitemicon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMenuItemIcon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "setmenuitemicon"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemIcon,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "GetItemStyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemStyle,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "getitemstyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemStyle,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "GetMenuItemStyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemStyle,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "getmenuitemstyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::GetItemStyle,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "SetItemStyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemStyle,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "setitemstyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemStyle,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "SetMenuItemStyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemStyle,
)
);
assert_eq!(
dispatcher_target_for_import(lib, "setmenuitemstyle"),
PpcImportDispatcherTarget::QuickDrawCompatibility(
PpcQuickDrawCompatibilityOperation::SetItemStyle,
)
);
}
}
#[test]
fn menu_item_attributes_commands_dispatch_with_canonical_evaluation() {
for lib in [b"InterfaceLib".as_slice(), b"AppearanceLib".as_slice(), b"CarbonLib".as_slice()] {
{
let pef = synthetic_pef_with_library_import(lib, b"CountMItems");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 201, b"\x04File", b"New;Open;Save;Quit");
loaded.cpu.gpr[3] = menu;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 4);
let pef = synthetic_pef_with_library_import(lib, b"CountMenuItems");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 202, b"\x04File", b"One;Two");
loaded.cpu.gpr[3] = menu;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 2);
}
{
let pef = synthetic_pef_with_library_import(lib, b"GetMenuItemText");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 203, b"\x04Edit", b"Cut;Copy;Paste");
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 0x100]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let bytes = ppc_read_pstring_bytes(&mut loaded.memory, out_ptr).unwrap();
assert_eq!(bytes, b"Copy");
let pef = synthetic_pef_with_library_import(lib, b"SetMenuItemText");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 204, b"\x04Edit", b"Cut;Copy;Paste");
let in_ptr = 0x60100;
loaded.memory.add_region(in_ptr, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, in_ptr, b"Duplicate"));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = in_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert_eq!(items[1].text, b"Duplicate");
let pef = synthetic_pef_with_library_import(lib, b"GetItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 205, b"\x04Edit", b"Cut;Copy;Paste");
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 0x100]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let bytes = ppc_read_pstring_bytes(&mut loaded.memory, out_ptr).unwrap();
assert_eq!(bytes, b"Cut");
let pef = synthetic_pef_with_library_import(lib, b"SetItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 206, b"\x04Edit", b"Cut;Copy;Paste");
let in_ptr = 0x60100;
loaded.memory.add_region(in_ptr, vec![0; 0x100]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, in_ptr, b"Trim"));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = in_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap().items;
assert_eq!(items[0].text, b"Trim");
let pef = synthetic_pef_with_library_import(lib, b"GetMenuItemText");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 205, b"\x04Edit", b"Cut");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pef = synthetic_pef_with_library_import(lib, b"SetMenuItemText");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
}
{
let pef = synthetic_pef_with_library_import(lib, b"DisableMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 207, b"\x04Edit", b"Cut;Copy");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pef = synthetic_pef_with_library_import(lib, b"EnableMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 208, b"\x04Edit", b"Cut;Copy");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pef = synthetic_pef_with_library_import(lib, b"DisableItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 209, b"\x04Edit", b"Cut;Copy");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pef = synthetic_pef_with_library_import(lib, b"EnableItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 210, b"\x04Edit", b"Cut;Copy");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
}
{
let pef = synthetic_pef_with_library_import(lib, b"CheckItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 211, b"\x04View", b"Show;Hide");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 2)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(0x12)
);
let pef = synthetic_pef_with_library_import(lib, b"CheckMenuItem");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 212, b"\x04View", b"Show;Hide");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 2)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(0)
);
let pef = synthetic_pef_with_library_import(lib, b"CheckItem");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
}
{
let pef = synthetic_pef_with_library_import(lib, b"SetItemMark");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 213, b"\x04View", b"Show;Hide");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = b'-' as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 2, 2)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(b'-')
);
let pef = synthetic_pef_with_library_import(lib, b"GetItemMark");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 213, b"\x04View", b"Show;Hide");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = b'-' as u32;
ppc_set_item_mark(&loaded.cpu, &mut loaded.memory, &test_handle_records!(loaded));
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(out_ptr), Some(b'-' as u16));
let pef = synthetic_pef_with_library_import(lib, b"SetMenuItemMark");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 214, b"\x04View", b"Show;Hide");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = b'*' as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 2)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(b'*')
);
let pef = synthetic_pef_with_library_import(lib, b"GetMenuItemMark");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 214, b"\x04View", b"Show;Hide");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = b'*' as u32;
ppc_set_item_mark(&loaded.cpu, &mut loaded.memory, &test_handle_records!(loaded));
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(out_ptr), Some(b'*' as u16));
let pef = synthetic_pef_with_library_import(lib, b"GetItemMark");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pef = synthetic_pef_with_library_import(lib, b"SetItemMark");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
}
{
let pef = synthetic_pef_with_library_import(lib, b"SetItemCmd");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 215, b"\x04File", b"New;Open");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = b'N' as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 1)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(b'N')
);
let pef = synthetic_pef_with_library_import(lib, b"GetItemCmd");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 215, b"\x04File", b"New;Open");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = b'N' as u32;
ppc_set_item_cmd(&loaded.cpu, &mut loaded.memory, &test_handle_records!(loaded));
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(out_ptr), Some(b'N' as u16));
let pef = synthetic_pef_with_library_import(lib, b"SetMenuItemCmd");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 216, b"\x04File", b"New;Open");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = b'O' as u32;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 2, 1)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(b'O')
);
let pef = synthetic_pef_with_library_import(lib, b"GetMenuItemCmd");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 216, b"\x04File", b"New;Open");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = b'O' as u32;
ppc_set_item_cmd(&loaded.cpu, &mut loaded.memory, &test_handle_records!(loaded));
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u16_be(out_ptr), Some(b'O' as u16));
let pef = synthetic_pef_with_library_import(lib, b"GetItemCmd");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
let pef = synthetic_pef_with_library_import(lib, b"SetItemCmd");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
}
{
let pef = synthetic_pef_with_library_import(lib, b"SetItemIcon");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 217, b"\x04File", b"New");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 17;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 0)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(17)
);
let pef = synthetic_pef_with_library_import(lib, b"GetItemIcon");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 217, b"\x04File", b"New");
let icon_addr = ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 0).unwrap();
loaded.memory.write_u8(icon_addr, 17).unwrap();
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(out_ptr), Some(17));
let pef = synthetic_pef_with_library_import(lib, b"SetMenuItemIcon");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 218, b"\x04File", b"New");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 42;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 0)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(42)
);
let pef = synthetic_pef_with_library_import(lib, b"GetMenuItemIcon");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 218, b"\x04File", b"New");
let icon_addr = ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 0).unwrap();
loaded.memory.write_u8(icon_addr, 42).unwrap();
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(out_ptr), Some(42));
}
{
let pef = synthetic_pef_with_library_import(lib, b"SetItemStyle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 219, b"\x04File", b"New");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 1; let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 3)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(1)
);
let pef = synthetic_pef_with_library_import(lib, b"GetItemStyle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 219, b"\x04File", b"New");
let style_addr = ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 3).unwrap();
loaded.memory.write_u8(style_addr, 1).unwrap();
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(out_ptr), Some(1));
let pef = synthetic_pef_with_library_import(lib, b"SetMenuItemStyle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 220, b"\x04File", b"New");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 2; let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(
ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 3)
.and_then(|addr| loaded.memory.read_u8(addr)),
Some(2)
);
let pef = synthetic_pef_with_library_import(lib, b"GetMenuItemStyle");
let mut loaded = load_pef_application(&pef).unwrap();
let menu = install_test_menu(&mut loaded, 0x60000, 220, b"\x04File", b"New");
let style_addr = ppc_menu_item_attribute_address(&mut loaded.memory, menu, 1, 3).unwrap();
loaded.memory.write_u8(style_addr, 2).unwrap();
let out_ptr = 0x60100;
loaded.memory.add_region(out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(out_ptr), Some(2));
}
}
}
#[test]
fn import_bindings_classify_menu_selection_and_tracking_imports() {
for lib in ["InterfaceLib", "AppearanceLib", "CarbonLib"] {
assert_eq!(
dispatcher_target_for_import(lib, "MenuSelect"),
PpcImportDispatcherTarget::MenuSelect
);
assert_eq!(
dispatcher_target_for_import(lib, "menuselect"),
PpcImportDispatcherTarget::MenuSelect
);
assert_eq!(
dispatcher_target_for_import(lib, "MenuKey"),
PpcImportDispatcherTarget::MenuKey
);
assert_eq!(
dispatcher_target_for_import(lib, "menukey"),
PpcImportDispatcherTarget::MenuKey
);
assert_eq!(
dispatcher_target_for_import(lib, "MenuEvent"),
PpcImportDispatcherTarget::MenuEvent
);
assert_eq!(
dispatcher_target_for_import(lib, "menuevent"),
PpcImportDispatcherTarget::MenuEvent
);
assert_eq!(
dispatcher_target_for_import(lib, "MenuChoice"),
PpcImportDispatcherTarget::MenuChoice
);
assert_eq!(
dispatcher_target_for_import(lib, "menuchoice"),
PpcImportDispatcherTarget::MenuChoice
);
assert_eq!(
dispatcher_target_for_import(lib, "PopUpMenuSelect"),
PpcImportDispatcherTarget::PopUpMenuSelect
);
assert_eq!(
dispatcher_target_for_import(lib, "popupmenuselect"),
PpcImportDispatcherTarget::PopUpMenuSelect
);
}
}
#[test]
fn menu_selection_and_tracking_commands_dispatch_with_canonical_evaluation() {
for lib in [
b"InterfaceLib".as_slice(),
b"AppearanceLib".as_slice(),
b"CarbonLib".as_slice(),
] {
{
let pef = synthetic_pef_with_library_import(lib, b"MenuChoice");
let mut loaded = load_pef_application(&pef).unwrap();
let test_val = (199u32 << 16) | 7;
loaded
.memory
.write_u32_be(crate::memory::globals::addr::MENU_DISABLE, test_val)
.unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], test_val);
}
{
let pef = synthetic_pef_with_library_import(lib, b"MenuKey");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, 0x60000, 201, b"File", b"Open/O");
loaded.cpu.gpr[3] = u32::from(b'o');
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], (201 << 16) | 1);
assert_eq!(
loaded.memory.read_u16_be(PPC_THE_MENU_ADDR),
Some(201)
);
}
{
let pef = synthetic_pef_with_library_import(lib, b"MenuEvent");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, 0x60000, 202, b"File", b"Save/S");
let event = 0x61000;
loaded.memory.add_region(event, vec![0; 16]);
loaded.memory.write_u16_be(event, 3).unwrap();
loaded.memory.write_u32_be(event + 2, u32::from(b's')).unwrap();
loaded.memory.write_u16_be(event + 14, 0x0100).unwrap();
loaded.cpu.gpr[3] = event;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], (202 << 16) | 1);
loaded.memory.write_u16_be(event + 14, 0).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = event;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
{
let pef = synthetic_pef_with_library_import(lib, b"MenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
install_test_menu(&mut loaded, 0x60000, 203, b"File", b"Item1;Item2");
loaded
.toolbox_startup
.pending_native_menu_selection
.stage((203, 2));
loaded.cpu.gpr[3] = (10 << 16) | 100; let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], (203 << 16) | 2);
assert_eq!(
loaded.memory.read_u16_be(PPC_THE_MENU_ADDR),
Some(203)
);
}
{
let pef = synthetic_pef_with_library_import(lib, b"PopUpMenuSelect");
let mut loaded = load_pef_application(&pef).unwrap();
let popup_menu =
install_test_popup_menu(&mut loaded, 0x60000, 204, b"Options", b"Choice");
loaded.cpu.gpr[3] = popup_menu;
loaded.cpu.gpr[4] = 50;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
}
}
}
#[test]
fn menu_item_command_ids_bind_and_round_trip_without_changing_shortcuts() {
for library in [
b"InterfaceLib".as_slice(),
b"AppearanceLib".as_slice(),
b"CarbonLib".as_slice(),
] {
let pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
library,
b"SetMenuItemCommandID",
0,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::SetMenuItemCommandID
);
assert_eq!(
dispatcher_target_for_import(
std::str::from_utf8(library).unwrap(),
"GetMenuItemCommandID"
),
PpcImportDispatcherTarget::GetMenuItemCommandID
);
let scratch = PPC_DATA_BASE + 0x1000;
let menu = install_test_menu(&mut loaded, scratch, 128, b"Commands", b"One/A;Two/B");
let command = 0xc1d2_e3f4;
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = command;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
let output = scratch + 0x180;
loaded.memory.write_u32_be(output + 4, 0x1122_3344).unwrap();
for (item, expected) in [(1, command), (2, 0)] {
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = item;
loaded.cpu.gpr[5] = output;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenuItemCommandID);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(output), Some(expected));
assert_eq!(loaded.memory.read_u32_be(output + 4), Some(0x1122_3344));
}
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap();
assert_eq!(items.items[0].command, b'A');
assert_eq!(items.items[1].command, b'B');
for (invalid_menu, invalid_item, error) in [
(0, 1, -5623),
(0xffff_fffc, 1, -5623),
(menu, 0, -5622),
(menu, 3, -5622),
] {
loaded.cpu.gpr[3] = invalid_menu;
loaded.cpu.gpr[4] = invalid_item;
loaded.cpu.gpr[5] = 42;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemCommandID);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(error));
assert_eq!(
loaded.toolbox_startup.menu_item_commands.get(menu, 1),
command
);
}
for invalid_output in [0, 0xffff_fffe] {
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = invalid_output;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenuItemCommandID);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
}
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemCommandID);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.toolbox_startup.menu_item_commands.get(menu, 1), 0);
}
}
#[test]
fn menu_item_command_ids_follow_insert_delete_and_disposal() {
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"SetMenuItemCommandID")).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let menu = install_test_menu(&mut loaded, scratch, 128, b"Commands", b"One;Two");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x4142_4344;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemCommandID);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x80,
b"Inserted"
));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = scratch + 0x80;
loaded.cpu.gpr[5] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertMenuItem);
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 3);
assert_eq!(loaded.toolbox_startup.menu_item_commands.get(menu, 1), 0);
assert_eq!(
loaded.toolbox_startup.menu_item_commands.get(menu, 2),
0x4142_4344
);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(
loaded.toolbox_startup.menu_item_commands.get(menu, 1),
0x4142_4344
);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(loaded.toolbox_startup.menu_item_commands.get(menu, 1), 0);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x5152_5354;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemCommandID);
loaded.cpu.gpr[3] = menu;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DisposeMenu);
assert_eq!(loaded.toolbox_startup.menu_item_commands.get(menu, 1), 0);
}
#[test]
fn menu_item_reference_constants_bind_and_round_trip_without_changing_shortcuts() {
for library in [
b"InterfaceLib".as_slice(),
b"AppearanceLib".as_slice(),
b"CarbonLib".as_slice(),
] {
let pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
library,
b"SetMenuItemRefCon",
0,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::SetMenuItemRefCon
);
assert_eq!(
dispatcher_target_for_import(
std::str::from_utf8(library).unwrap(),
"GetMenuItemRefCon"
),
PpcImportDispatcherTarget::GetMenuItemRefCon
);
let scratch = PPC_DATA_BASE + 0x1000;
let menu = install_test_menu(&mut loaded, scratch, 128, b"Commands", b"One/A;Two/B");
let command = 0xc1d2_e3f4;
loaded
.toolbox_startup
.menu_item_commands
.set(menu, 1, 0x1020_3040);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = command;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0);
let output = scratch + 0x180;
loaded.memory.write_u32_be(output + 4, 0x1122_3344).unwrap();
for (item, expected) in [(1, command), (2, 0)] {
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = item;
loaded.cpu.gpr[5] = output;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenuItemRefCon);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(output), Some(expected));
assert_eq!(loaded.memory.read_u32_be(output + 4), Some(0x1122_3344));
}
assert_eq!(
loaded.toolbox_startup.menu_item_commands.get(menu, 1),
0x1020_3040
);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap();
assert_eq!(items.items[0].command, b'A');
assert_eq!(items.items[1].command, b'B');
for (invalid_menu, invalid_item, error) in [
(0, 1, -5623),
(0xffff_fffc, 1, -5623),
(menu, 0, -5622),
(menu, 3, -5622),
] {
loaded.cpu.gpr[3] = invalid_menu;
loaded.cpu.gpr[4] = invalid_item;
loaded.cpu.gpr[5] = 42;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemRefCon);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(error));
assert_eq!(
loaded.toolbox_startup.menu_item_refcons.get(menu, 1),
command
);
}
for invalid_output in [0, 0xffff_fffe] {
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = invalid_output;
run_test_import(&mut loaded, PpcImportDispatcherTarget::GetMenuItemRefCon);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
}
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemRefCon);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.toolbox_startup.menu_item_refcons.get(menu, 1), 0);
}
}
#[test]
fn menu_item_reference_constants_follow_insert_delete_and_disposal() {
let mut loaded =
load_pef_application(&synthetic_pef_with_import(b"SetMenuItemRefCon")).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let menu = install_test_menu(&mut loaded, scratch, 128, b"Commands", b"One;Two");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x4142_4344;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemRefCon);
assert!(ppc_write_pstring_bytes(
&mut loaded.memory,
scratch + 0x80,
b"Inserted"
));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = scratch + 0x80;
loaded.cpu.gpr[5] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertMenuItem);
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 3);
assert_eq!(loaded.toolbox_startup.menu_item_refcons.get(menu, 1), 0);
assert_eq!(
loaded.toolbox_startup.menu_item_refcons.get(menu, 2),
0x4142_4344
);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(
loaded.toolbox_startup.menu_item_refcons.get(menu, 1),
0x4142_4344
);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(loaded.toolbox_startup.menu_item_refcons.get(menu, 1), 0);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x5152_5354;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SetMenuItemRefCon);
loaded.cpu.gpr[3] = menu;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DisposeMenu);
assert_eq!(loaded.toolbox_startup.menu_item_refcons.get(menu, 1), 0);
}
#[test]
fn menu_insertion_deletion_and_enable_commands_dispatch_with_canonical_evaluation() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"InsertMenu")).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let menu = install_test_menu(&mut loaded, scratch, 128, b"Edit", b"Undo;Cut;Copy");
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 0; run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertMenu);
assert_eq!(loaded.last_mem_error(), 0);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertMenu);
assert_eq!(loaded.last_mem_error(), PPC_PARAM_ERR);
loaded.cpu.gpr[3] = 128;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenu);
assert_eq!(loaded.last_mem_error(), 0);
loaded.memory.add_region(scratch + 0x200, vec![0; 0x200]);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, scratch + 0x200, b"Paste;Clear"));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = scratch + 0x200;
run_test_import(&mut loaded, PpcImportDispatcherTarget::AppendMenu);
assert_eq!(loaded.last_mem_error(), 0);
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 5);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch + 0x200;
run_test_import(&mut loaded, PpcImportDispatcherTarget::AppendMenu);
assert_eq!(loaded.last_mem_error(), PPC_NIL_HANDLE_ERR);
assert!(ppc_write_pstring_bytes(&mut loaded.memory, scratch + 0x300, b"Redo"));
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = scratch + 0x300;
loaded.cpu.gpr[5] = 1; run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertMenuItem);
assert_eq!(loaded.last_mem_error(), 0);
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 6);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = scratch + 0x300;
loaded.cpu.gpr[5] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertMenuItem);
assert_eq!(loaded.last_mem_error(), PPC_NIL_HANDLE_ERR);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 2; run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(loaded.last_mem_error(), 0);
assert_eq!(ppc_count_menu_items(&mut loaded.memory, menu), 5);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(loaded.last_mem_error(), 0);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DeleteMenuItem);
assert_eq!(loaded.last_mem_error(), PPC_NIL_HANDLE_ERR);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DisableMenuItem);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap();
assert!(!items.items[0].enabled);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::EnableMenuItem);
let items = ppc_menu_items_from_memory(&mut loaded.memory, menu).unwrap();
assert!(items.items[0].enabled);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DisableMenuItem);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::EnableMenuItem);
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = 50;
run_test_import(&mut loaded, PpcImportDispatcherTarget::EnableMenuItem);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0x464f4e54;
run_test_import(&mut loaded, PpcImportDispatcherTarget::AppendResMenu);
assert_eq!(loaded.last_mem_error(), PPC_NIL_HANDLE_ERR);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 0x464f4e54;
loaded.cpu.gpr[5] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::InsertResMenu);
assert_eq!(loaded.last_mem_error(), PPC_NIL_HANDLE_ERR);
}
#[test]
fn menu_key_event_choice_and_help_commands_dispatch_with_canonical_evaluation() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"MenuKey")).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let _menu = install_test_menu(&mut loaded, scratch, 128, b"File", b"Open/O;Save/S");
loaded.cpu.gpr[3] = u32::from(b'O');
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuKey);
assert_eq!(
loaded.cpu.gpr[3],
crate::menu_manager::pack_menu_choice(128, 1)
);
loaded.cpu.gpr[3] = u32::from(b'Z');
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuKey);
assert_eq!(loaded.cpu.gpr[3], 0);
let event = scratch + 0x100;
loaded.memory.write_u16_be(event, 3).unwrap();
loaded.memory.write_u32_be(event + 2, u32::from(b's')).unwrap();
loaded.memory.write_u16_be(event + 14, 0x0100).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(
loaded.cpu.gpr[3],
crate::menu_manager::pack_menu_choice(128, 2)
);
loaded.memory.write_u16_be(event, 5).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(
loaded.cpu.gpr[3],
crate::menu_manager::pack_menu_choice(128, 2)
);
loaded.memory.write_u16_be(event + 14, 0).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.memory.write_u16_be(event, 1).unwrap();
loaded.memory.write_u16_be(event + 14, 0x0100).unwrap();
loaded.cpu.gpr[3] = event;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuEvent);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded
.memory
.write_u32_be(
crate::memory::globals::addr::MENU_DISABLE,
crate::menu_manager::pack_menu_choice(128, 1),
)
.unwrap();
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuChoice);
assert_eq!(
loaded.cpu.gpr[3],
crate::menu_manager::pack_menu_choice(128, 1)
);
let out_handle_addr = scratch + 0x180;
loaded
.memory
.write_u32_be(out_handle_addr, 0x1234_5678)
.unwrap();
loaded.cpu.gpr[3] = out_handle_addr;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMGetHelpMenuHandle);
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_HM_HELP_MANAGER_NOT_INITED)
);
assert_eq!(loaded.memory.read_u32_be(out_handle_addr), Some(0));
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMGetHelpMenuHandle);
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_HM_HELP_MANAGER_NOT_INITED)
);
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMGetBalloons);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMSetBalloons);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMGetBalloons);
assert_eq!(loaded.cpu.gpr[3], 1);
loaded.cpu.gpr[3] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMSetBalloons);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMGetBalloons);
assert_eq!(loaded.cpu.gpr[3], 0);
run_test_import(&mut loaded, PpcImportDispatcherTarget::HMIsBalloon);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn menu_tracking_and_popup_selection_commands_dispatch_with_canonical_evaluation() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"MenuSelect")).unwrap();
let scratch = PPC_DATA_BASE + 0x1000;
let _menu = install_test_menu(&mut loaded, scratch, 128, b"File", b"New;Open;Close");
loaded
.toolbox_startup
.pending_native_menu_selection
.stage((128, 2));
loaded.cpu.gpr[3] = (10 << 16) | 100;
run_test_import(&mut loaded, PpcImportDispatcherTarget::MenuSelect);
assert_eq!(
loaded.cpu.gpr[3],
crate::menu_manager::pack_menu_choice(128, 2)
);
assert_eq!(
loaded.memory.read_u16_be(PPC_THE_MENU_ADDR),
Some(128)
);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 50;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::PopUpMenuSelect);
assert_eq!(loaded.cpu.gpr[3], 0);
let popup_menu =
install_test_popup_menu(&mut loaded, scratch + 0x200, 129, b"Choice", b"Item1;Item2");
loaded.cpu.gpr[3] = popup_menu;
loaded.cpu.gpr[4] = 50;
loaded.cpu.gpr[5] = 50;
loaded.cpu.gpr[6] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::PopUpMenuSelect);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn menu_id_setter_import_updates_live_lookup_and_preserves_menu_contents() {
for library in ["InterfaceLib", "CarbonLib"] {
for symbol in ["SetMenuID", "setmenuid"] {
let loader = synthetic_loader_with_symbol_class(
library.as_bytes(), symbol.as_bytes(), 0x82, &[run_reloc(0x23, 1)],
);
let mut loaded = load_pef_application(&synthetic_pef_with_loader(loader)).unwrap();
let setter = PpcImportDispatcherTarget::SetMenuID;
assert_eq!(loaded.imports[0].dispatcher_target, setter);
assert!(loaded.imports[0].weak);
assert_ne!(loaded.imports[0].address, 0);
let scratch = PPC_DATA_BASE + 0x2800;
let menu = install_test_menu(&mut loaded, scratch, 128, b"Game", b"Play/P;Quit/Q");
let other = install_test_menu(&mut loaded, scratch + 0x400, 129, b"Help", b"About");
let record = loaded.memory.read_u32_be(menu).unwrap();
let handles = test_handle_records!(loaded).to_vec();
let before = ppc_menu_handle_bytes(&mut loaded.memory, &handles, menu).unwrap();
let mut old_id = 128;
for id in [0x1234_007f_u32, 0xffff_8000, 0xabcd_ffff] {
loaded.cpu.gpr[3] = menu;
loaded.cpu.gpr[4] = id;
run_test_import(&mut loaded, setter.clone());
assert_eq!(loaded.cpu.gpr[3], menu); assert_eq!(loaded.memory.read_u16_be(record), Some(id as u16));
let list = ppc_current_menu_list(&mut loaded.memory);
assert_eq!(ppc_get_menu_handle(&mut loaded.memory, list, old_id), 0);
assert_eq!(ppc_get_menu_handle(&mut loaded.memory, list, id as u16 as i16), menu);
assert_eq!(ppc_get_menu_handle(&mut loaded.memory, list, 129), other);
let after = ppc_menu_handle_bytes(&mut loaded.memory, &handles, menu).unwrap();
assert_eq!(&after[2..], &before[2..]);
old_id = id as u16 as i16;
}
for invalid in [0, 0xffff_fffc] {
loaded.cpu.gpr[3] = invalid;
loaded.cpu.gpr[4] = 1;
run_test_import(&mut loaded, setter.clone());
assert_eq!(loaded.cpu.gpr[3], invalid);
assert_eq!(loaded.memory.read_u16_be(record), Some(0xffff));
}
}
}
}