use super::*;
#[test]
fn draw_sprocket_blit_fastest_copies_plain_pixels_and_marks_completion() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpBlit_Fastest");
let mut loaded = load_pef_application(&pef).unwrap();
let info = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(info, vec![0; 64]);
let src = ppc_resolve_pixmap_bits(&mut loaded.memory, &loaded.gworlds, PPC_MAIN_GWORLD)
.expect("main buffer");
let dst = ppc_resolve_pixmap_bits(&mut loaded.memory, &loaded.gworlds, PPC_DSP_BACK_GWORLD)
.expect("back buffer");
assert_eq!(src.depth, dst.depth);
ppc_write_pixmap_raw_pixel(&mut loaded.memory, src, 0, 0, 0x21).unwrap();
ppc_write_pixmap_raw_pixel(&mut loaded.memory, src, 1, 0, 0x43).unwrap();
loaded
.memory
.write_u32_be(info + 12, PPC_MAIN_GWORLD)
.unwrap();
ppc_write_rect(&mut loaded.memory, info + 16, 0, 0, 1, 2).unwrap();
loaded
.memory
.write_u32_be(info + 32, PPC_DSP_BACK_GWORLD)
.unwrap();
ppc_write_rect(&mut loaded.memory, info + 36, 0, 0, 1, 2).unwrap();
loaded.cpu.gpr[3] = info;
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);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u8(info), Some(1));
assert_eq!(
ppc_read_pixmap_raw_pixel(&mut loaded.memory, dst, 0, 0),
Some(0x21)
);
assert_eq!(
ppc_read_pixmap_raw_pixel(&mut loaded.memory, dst, 1, 0),
Some(0x43)
);
}
#[test]
fn active_draw_sprocket_blanking_window_owns_clicks_and_is_disposed() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetState");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
let blanking = loaded
.draw_sprocket
.blanking_window
.expect("blanking WindowPtr");
assert!(ppc_window_is_visible(&mut loaded.memory, blanking));
assert_eq!(
loaded
.memory
.read_u16_be(blanking + PPC_CWINDOW_WINDOW_KIND_OFFSET),
Some(8)
);
assert!(loaded.window_list.contains_window(blanking));
let scratch = PPC_DATA_BASE + 0x1000;
let later_dialog = scratch + 0x100;
loaded.memory.add_region(scratch, vec![0; 0x200]);
loaded
.memory
.write_u8(later_dialog + PPC_CWINDOW_VISIBLE_OFFSET, 1)
.unwrap();
loaded
.memory
.write_u16_be(later_dialog + PPC_CWINDOW_WINDOW_KIND_OFFSET, 2)
.unwrap();
loaded.window_list.insert(0, later_dialog);
loaded.cpu.gpr[3] = (100 << 16) | 100;
loaded.cpu.gpr[4] = scratch + 16;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FindWindow);
assert_eq!(loaded.cpu.gpr[3], 3);
assert_eq!(loaded.memory.read_u32_be(scratch + 16), Some(blanking));
ppc_write_event_record(&mut loaded.memory, scratch, 1, 0, 0, 100, 100, 0);
loaded.cpu.gpr[3] = scratch;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DialogCompatibility(
PpcDialogCompatibilityOperation::IsDialogEvent,
),
);
assert_eq!(loaded.cpu.gpr[3], 0);
let update = |message| PpcQueuedEvent {
what: 6,
message,
when: 0,
where_v: 0,
where_h: 0,
modifiers: 0,
};
loaded.set_event_queue([update(blanking), update(later_dialog)]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.draw_sprocket.blanking_window, None);
assert!(!loaded.window_list.contains_window(blanking));
assert!(!loaded
.event_queue()
.iter()
.any(|event| event.what == 6 && event.message == blanking));
assert!(loaded
.event_queue()
.iter()
.any(|event| event.what == 6 && event.message == later_dialog));
}
#[test]
fn paused_draw_sprocket_retains_display_and_window_until_inactive() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetState");
let mut loaded = load_pef_application(&pef).unwrap();
let desktop = loaded.presented_front_buffer().unwrap();
loaded.memory.write_u8(PPC_MAIN_SCREEN_BASE + 100, 0x5a).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.context_attributes.width = 640;
loaded.draw_sprocket.context_attributes.height = 480;
loaded.draw_sprocket.context_attributes.display_depth = 16;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let window = loaded.draw_sprocket.blanking_window.unwrap();
let context_buffer = loaded.presented_front_buffer().unwrap();
loaded.memory.write_u8(PPC_MAIN_SCREEN_BASE + 100, 0x27).unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_PAUSED;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.presented_front_buffer().unwrap(), context_buffer);
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE + 100), Some(0x27));
assert_eq!(loaded.draw_sprocket.blanking_window, Some(window));
assert!(loaded.window_list.contains_window(window));
run_test_import(&mut loaded, PpcImportDispatcherTarget::FrontWindow);
assert_eq!(loaded.cpu.gpr[3], window);
let hit = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(hit, vec![0; 4]);
loaded.cpu.gpr[3] = (5 << 16) | 5;
loaded.cpu.gpr[4] = hit;
run_test_import(&mut loaded, PpcImportDispatcherTarget::FindWindow);
assert_eq!(loaded.cpu.gpr[3], 1, "paused context exposes the menu bar");
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSwapBuffers);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.draw_sprocket.blanking_window, Some(window));
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE + 100), Some(0x27));
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.presented_front_buffer().unwrap(), desktop);
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE + 100), Some(0x5a));
assert_eq!(loaded.draw_sprocket.blanking_window, None);
assert!(!loaded.window_list.contains_window(window));
}
#[test]
fn draw_sprocket_temporary_context_restores_desktop_mode_and_pixels() {
let pef = synthetic_pef_with_import(b"SetPort");
let mut loaded = load_pef_application(&pef).unwrap();
let desktop = loaded.presented_front_buffer().unwrap();
assert_eq!(desktop.depth, 8);
loaded.memory.write_u8(PPC_MAIN_SCREEN_BASE + 100, 0x5a).unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0;
assert_eq!(
ppc_dsp_context_reserve(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&mut loaded.gworlds,
),
PPC_NO_ERR
);
assert_eq!(loaded.presented_front_buffer().unwrap(), desktop);
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE + 100), Some(0x5a));
let mut clut = loaded.screen_clut.with_ref(|clut| *clut);
let mut logical_clut = clut;
let mut next_ct_seed = 1024;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
assert_eq!(
ppc_dsp_context_set_state(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.gworlds,
&mut clut,
&mut logical_clut,
&mut next_ct_seed,
None,
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
assert_eq!(loaded.presented_front_buffer().unwrap().depth, 16);
assert_eq!(loaded.memory.read_u16_be(PPC_MAIN_SCREEN_BASE + 100), Some(0));
loaded.memory.write_u8(PPC_MAIN_SCREEN_BASE + 100, 0).unwrap();
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
assert_eq!(
ppc_dsp_context_set_state(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.gworlds,
&mut clut,
&mut logical_clut,
&mut next_ct_seed,
None,
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
assert_eq!(loaded.presented_front_buffer().unwrap(), desktop);
assert_eq!(loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE + 100), Some(0x5a));
assert!(loaded.draw_sprocket.desktop_snapshot.is_none());
}
#[test]
fn draw_sprocket_activation_installs_context_screen_geometry() {
let pef = synthetic_pef_with_import(b"SetPort");
let mut loaded = load_pef_application(&pef).unwrap();
let screen_bits = PPC_DATA_BASE + 0x2000;
loaded.memory.add_region(screen_bits, vec![0; 14]);
let desktop = (
0,
0,
ppc_main_screen_height() as i16,
ppc_main_screen_width() as i16,
);
assert!(desktop.3 > 640, "the profile must be larger than the context");
ppc_write_screen_bits(
&mut loaded.memory,
Some(screen_bits),
ppc_main_screen_width(),
ppc_main_screen_width(),
ppc_main_screen_height(),
)
.unwrap();
let screen_geometry = |loaded: &mut PpcLoadedApp| {
(
ppc_read_rect(&mut loaded.memory, PPC_MAIN_GWORLD + 16).unwrap(),
ppc_read_rgn_bbox(&mut loaded.memory, PPC_MAIN_VIS_RGN_HANDLE).unwrap(),
ppc_read_rgn_bbox(&mut loaded.memory, PPC_GRAY_RGN_HANDLE).unwrap(),
ppc_read_rect(&mut loaded.memory, screen_bits + 6).unwrap(),
ppc_read_rect(&mut loaded.memory, PPC_MAIN_GDEVICE_RECORD + 34).unwrap(),
)
};
let before = screen_geometry(&mut loaded);
assert_eq!(before.0, desktop);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0;
assert_eq!(
ppc_dsp_context_reserve(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&mut loaded.gworlds,
),
PPC_NO_ERR
);
assert_eq!(screen_geometry(&mut loaded), before);
let mut clut = loaded.screen_clut.with_ref(|clut| *clut);
let mut logical_clut = clut;
let mut next_ct_seed = 1024;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
assert_eq!(
ppc_dsp_context_set_state(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.gworlds,
&mut clut,
&mut logical_clut,
&mut next_ct_seed,
Some(screen_bits),
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
let context = (0, 0, 480, 640);
let menu_bar_height = loaded.memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR).unwrap() as i16;
assert_eq!(
screen_geometry(&mut loaded),
(context, context, (menu_bar_height, 0, 480, 640), context, context)
);
assert_eq!(loaded.memory.read_u32_be(screen_bits), Some(PPC_MAIN_SCREEN_BASE));
let front = loaded.presented_front_buffer().unwrap();
assert_eq!((front.width, front.height), (640, 480));
assert_eq!(
loaded.memory.read_u16_be(screen_bits + 4),
Some(front.row_bytes as u16)
);
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
assert_eq!(
ppc_dsp_context_set_state(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.gworlds,
&mut clut,
&mut logical_clut,
&mut next_ct_seed,
Some(screen_bits),
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
assert_eq!(screen_geometry(&mut loaded), before);
}
#[test]
fn draw_sprocket_eight_bit_activation_uses_black_blanking_index() {
let pef = synthetic_pef_with_import(b"SetPort");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
display_best_depth_mask: 1 << 3,
back_buffer_best_depth_mask: 1 << 3,
display_depth: 8,
back_buffer_depth: 8,
page_count: 1,
..PpcDspContextAttributes::default()
},
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = attributes_ptr;
assert_eq!(
ppc_dsp_context_reserve(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&mut loaded.gworlds,
),
PPC_NO_ERR
);
let mut clut = loaded.screen_clut.with_ref(|clut| *clut);
let mut logical_clut = clut;
let mut next_ct_seed = 1024;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
assert_eq!(
ppc_dsp_context_set_state(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.gworlds,
&mut clut,
&mut logical_clut,
&mut next_ct_seed,
None,
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
let pixel = loaded.memory.read_u8(PPC_MAIN_SCREEN_BASE).unwrap();
assert_eq!(clut[pixel as usize], [0, 0, 0]);
}
#[test]
fn draw_sprocket_eight_bit_800x600_context_updates_the_front_buffer() {
let pef = synthetic_pef_with_import(b"SetPort");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(context_out_ptr, vec![0; 4]);
let requested = PpcDspContextAttributes {
width: PPC_DSP_LARGE_SCREEN_WIDTH,
height: PPC_DSP_LARGE_SCREEN_HEIGHT,
display_best_depth_mask: PPC_DSP_DEPTH_MASK_8,
back_buffer_best_depth_mask: PPC_DSP_DEPTH_MASK_8,
display_depth: 8,
back_buffer_depth: 8,
page_count: 1,
..PpcDspContextAttributes::default()
};
write_test_dsp_context_attributes(&mut loaded.memory, attributes_ptr, requested);
assert_eq!(
ppc_dsp_find_best_context(
&mut loaded.memory,
attributes_ptr,
context_out_ptr,
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
assert_eq!(
loaded.memory.read_u32_be(context_out_ptr),
Some(PPC_DSP_CONTEXT)
);
assert_eq!(
(
loaded.draw_sprocket.context_attributes.width,
loaded.draw_sprocket.context_attributes.height,
),
(800, 600)
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = attributes_ptr;
assert_eq!(
ppc_dsp_context_reserve(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&mut loaded.gworlds,
),
PPC_NO_ERR
);
let mut clut = loaded.screen_clut.with_ref(|clut| *clut);
let mut logical_clut = clut;
let mut next_ct_seed = 1024;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
assert_eq!(
ppc_dsp_context_set_state(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.gworlds,
&mut clut,
&mut logical_clut,
&mut next_ct_seed,
None,
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
let front = loaded.presented_front_buffer().unwrap();
assert_eq!(
(front.width, front.height, front.depth, front.row_bytes),
(800, 600, 8, 816)
);
assert_eq!(
loaded.draw_sprocket.front_buffer_gworld,
loaded.draw_sprocket.back_buffer_gworld
);
}
#[test]
fn draw_sprocket_get_version_writes_num_version() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpGetVersion");
let mut loaded = load_pef_application(&pef).unwrap();
let version_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(version_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = version_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(version_ptr), Some(0x0175_8000));
}
#[test]
fn draw_sprocket_context_flatten_and_restore_round_trip() {
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetFlattenedSize"),
PpcImportDispatcherTarget::DSpContextGetFlattenedSize
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_Flatten"),
PpcImportDispatcherTarget::DSpContextFlatten
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_Restore"),
PpcImportDispatcherTarget::DSpContextRestore
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Flatten");
let mut loaded = load_pef_application(&pef).unwrap();
let base = PPC_DATA_BASE + 0x3000;
let size_out = base;
let flat = base + 8;
let context_out = flat + PPC_DSP_FLAT_CONTEXT_SIZE;
loaded.memory.add_region(base, vec![0; 128]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = size_out;
assert_eq!(
ppc_dsp_context_get_flattened_size(&loaded.cpu, &mut loaded.memory),
PPC_NO_ERR
);
assert_eq!(
loaded.memory.read_u32_be(size_out),
Some(PPC_DSP_FLAT_CONTEXT_SIZE)
);
let mut saved_attributes = PpcDspContextAttributes::default();
saved_attributes.page_count = 1;
loaded.draw_sprocket.context_attributes = saved_attributes;
loaded.cpu.gpr[4] = flat;
assert_eq!(
ppc_dsp_context_flatten(&loaded.cpu, &mut loaded.memory, &loaded.draw_sprocket),
PPC_NO_ERR
);
loaded.draw_sprocket.context_attributes = PpcDspContextAttributes::default();
loaded.cpu.gpr[3] = flat;
loaded.cpu.gpr[4] = context_out;
assert_eq!(
ppc_dsp_context_restore(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
),
PPC_NO_ERR
);
assert_eq!(loaded.memory.read_u32_be(context_out), Some(PPC_DSP_CONTEXT));
assert_eq!(loaded.draw_sprocket.context_attributes, saved_attributes);
}
#[test]
fn draw_sprocket_context_serialization_rejects_bad_inputs_without_overwriting_state() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Restore");
let mut loaded = load_pef_application(&pef).unwrap();
let base = PPC_DATA_BASE + 0x3000;
let flat = base;
let context_out = base + PPC_DSP_FLAT_CONTEXT_SIZE;
loaded.memory.add_region(base, vec![0; 128]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = base;
assert_eq!(
ppc_dsp_context_get_flattened_size(&loaded.cpu, &mut loaded.memory),
PPC_DSP_CONTEXT_NOT_FOUND_ERR
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = base + 127;
assert_eq!(
ppc_dsp_context_flatten(&loaded.cpu, &mut loaded.memory, &loaded.draw_sprocket),
PPC_PARAM_ERR
);
let original_attributes = loaded.draw_sprocket.context_attributes;
loaded.memory.write_u32_be(context_out, 0x1234_5678).unwrap();
loaded.cpu.gpr[3] = flat;
loaded.cpu.gpr[4] = context_out;
assert_eq!(
ppc_dsp_context_restore(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
),
PPC_DSP_CONTEXT_NOT_FOUND_ERR
);
assert_eq!(loaded.memory.read_u32_be(context_out), Some(0x1234_5678));
assert_eq!(loaded.draw_sprocket.context_attributes, original_attributes);
}
#[test]
fn draw_sprocket_get_clut_entries_reads_colors_set_for_a_range() {
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetCLUTEntries"),
PpcImportDispatcherTarget::DSpContextGetClutEntries
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetCLUTEntries");
let mut loaded = load_pef_application(&pef).unwrap();
let base = PPC_DATA_BASE + 0x4000;
loaded.memory.add_region(base, vec![0; 40]);
for (offset, color) in [[0x1111, 0x2222, 0x3333], [0x4444, 0x5555, 0x6666]]
.into_iter()
.enumerate()
{
let entry = base + (offset as u32) * 8;
loaded.memory.write_u16_be(entry, 0xffff).unwrap();
for (component, value) in color.into_iter().enumerate() {
loaded
.memory
.write_u16_be(entry + 2 + (component as u32) * 2, value)
.unwrap();
}
}
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = base;
loaded.cpu.gpr[5] = 10;
loaded.cpu.gpr[6] = 2;
let mut screen_clut = [[0; 3]; 256];
assert_eq!(
ppc_dsp_context_set_clut_entries(&loaded.cpu, &mut loaded.memory, &mut screen_clut,
&mut [[0; 3]; 256], &mut 1024, &mut loaded.draw_sprocket),
PPC_NO_ERR
);
let output = base + 16;
loaded.cpu.gpr[4] = output;
assert_eq!(
ppc_dsp_context_get_clut_entries(&loaded.cpu, &mut loaded.memory, &screen_clut, &loaded.draw_sprocket),
PPC_NO_ERR
);
for (offset, color) in [[0x1111, 0x2222, 0x3333], [0x4444, 0x5555, 0x6666]]
.into_iter()
.enumerate()
{
let entry = output + (offset as u32) * 8;
assert_eq!(loaded.memory.read_u16_be(entry), Some(10 + offset as u16));
for (component, value) in color.into_iter().enumerate() {
assert_eq!(
loaded.memory.read_u16_be(entry + 2 + (component as u32) * 2),
Some(value)
);
}
}
}
#[test]
fn draw_sprocket_get_clut_entries_rejects_invalid_ranges_and_short_buffers() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetCLUTEntries");
let mut loaded = load_pef_application(&pef).unwrap();
let output = PPC_DATA_BASE + 0x4000;
loaded.memory.add_region(output, vec![0xaa; 8]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = output;
loaded.cpu.gpr[5] = 255;
loaded.cpu.gpr[6] = 2;
let screen_clut = [[0; 3]; 256];
assert_eq!(
ppc_dsp_context_get_clut_entries(&loaded.cpu, &mut loaded.memory, &screen_clut, &loaded.draw_sprocket),
PPC_PARAM_ERR
);
loaded.cpu.gpr[5] = 10;
assert_eq!(
ppc_dsp_context_get_clut_entries(&loaded.cpu, &mut loaded.memory, &screen_clut, &loaded.draw_sprocket),
PPC_PARAM_ERR
);
for offset in 0..8 {
assert_eq!(loaded.memory.read_u8(output + offset), Some(0xaa));
}
}
#[test]
fn find_best_context_on_display_id_selects_main_display_only() {
let pef = synthetic_pef_with_library_import(
b"DrawSprocketLib",
b"DSpFindBestContextOnDisplayID",
);
let mut loaded = load_pef_application(&pef).unwrap();
let context_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(context_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = context_out_ptr;
loaded.cpu.gpr[5] = PPC_DSP_DISPLAY_ID;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(context_out_ptr), Some(PPC_DSP_CONTEXT));
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = context_out_ptr;
loaded.cpu.gpr[5] = PPC_DSP_DISPLAY_ID + 1;
loaded.run_with_hle_imports(64);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_DSP_CONTEXT_NOT_FOUND_ERR));
}
#[test]
fn hle_import_runner_handles_draw_sprocket_find_best_context() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindBestContext");
let mut loaded = load_pef_application(&pef).unwrap();
let context_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(context_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = context_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.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(context_out_ptr),
Some(PPC_DSP_CONTEXT)
);
assert!(loaded.draw_sprocket.started);
}
#[test]
fn hle_import_runner_records_draw_sprocket_find_best_context_attributes() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindBestContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(context_out_ptr, vec![0; 4]);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
frequency: 75 << 16,
width: PPC_DSP_SCREEN_WIDTH,
height: PPC_DSP_SCREEN_HEIGHT,
context_options: 0x40,
display_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
back_buffer_best_depth_mask: 0,
display_depth: PPC_MAIN_PIXEL_DEPTH,
back_buffer_depth: 0,
page_count: 2,
},
);
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = context_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(context_out_ptr),
Some(PPC_DSP_CONTEXT)
);
assert_eq!(
loaded.draw_sprocket.context_attributes,
PpcDspContextAttributes {
frequency: PPC_DSP_FREQUENCY_60HZ,
width: PPC_DSP_SCREEN_WIDTH,
height: PPC_DSP_SCREEN_HEIGHT,
context_options: PPC_DSP_CONTEXT_OPTION_QD3D_ACCEL,
display_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
back_buffer_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
display_depth: PPC_MAIN_SCREEN_STORAGE_DEPTH,
back_buffer_depth: PPC_MAIN_SCREEN_STORAGE_DEPTH,
page_count: PPC_DSP_ADVERTISED_PAGE_COUNT,
}
);
}
#[test]
fn hle_import_runner_draw_sprocket_find_best_context_rejects_unsupported_mode() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindBestContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(context_out_ptr, vec![0xaa; 4]);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
width: 800,
height: 600,
display_best_depth_mask: 1 << 5,
display_depth: 32,
..PpcDspContextAttributes::default()
},
);
let initial_draw_sprocket = loaded.draw_sprocket.clone();
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = context_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.cpu.gpr[3],
ppc_i16_result(PPC_DSP_CONTEXT_NOT_FOUND_ERR)
);
assert_eq!(loaded.draw_sprocket, initial_draw_sprocket);
for offset in 0..4 {
assert_eq!(loaded.memory.read_u8(context_out_ptr + offset), Some(0xaa));
}
}
#[test]
fn hle_import_runner_traces_draw_sprocket_requested_context_attributes() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindBestContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
let requested = PpcDspContextAttributes {
frequency: 75 << 16,
width: 800,
height: 600,
context_options: 0x40,
display_best_depth_mask: 1 << 5,
back_buffer_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
display_depth: 32,
back_buffer_depth: PPC_MAIN_PIXEL_DEPTH,
page_count: 3,
};
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(context_out_ptr, vec![0xaa; 4]);
write_test_dsp_context_attributes(&mut loaded.memory, attributes_ptr, requested);
let initial_draw_sprocket = loaded.draw_sprocket.clone();
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = context_out_ptr;
let probe = loaded.run_with_hle_import_trace(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_DSP_CONTEXT_NOT_FOUND_ERR)
);
assert_eq!(loaded.draw_sprocket, initial_draw_sprocket);
assert_eq!(probe.draw_sprocket_trace.len(), 1);
let trace = &probe.draw_sprocket_trace[0];
assert_eq!(trace.action, "find_best_context");
assert_eq!(trace.result, PPC_DSP_CONTEXT_NOT_FOUND_ERR);
assert_eq!(trace.context, None);
assert_eq!(trace.requested_frequency, Some(requested.frequency));
assert_eq!(trace.requested_width, Some(requested.width));
assert_eq!(trace.requested_height, Some(requested.height));
assert_eq!(
trace.requested_context_options,
Some(requested.context_options)
);
assert_eq!(
trace.requested_display_depth_mask,
Some(requested.display_best_depth_mask)
);
assert_eq!(
trace.requested_back_buffer_depth_mask,
Some(requested.back_buffer_best_depth_mask)
);
assert_eq!(trace.requested_display_depth, Some(requested.display_depth));
assert_eq!(
trace.requested_back_buffer_depth,
Some(requested.back_buffer_depth)
);
assert_eq!(trace.requested_page_count, Some(requested.page_count));
assert_eq!(trace.width, PPC_DSP_SCREEN_WIDTH);
assert_eq!(trace.height, PPC_DSP_SCREEN_HEIGHT);
assert_eq!(trace.display_depth, PPC_MAIN_SCREEN_STORAGE_DEPTH);
for offset in 0..4 {
assert_eq!(loaded.memory.read_u8(context_out_ptr + offset), Some(0xaa));
}
}
#[test]
fn hle_import_runner_draw_sprocket_find_best_context_rejects_depth_requests_excluding_16bpp() {
for (case, attributes) in [
(
"display mask excludes 16-bit",
PpcDspContextAttributes {
display_best_depth_mask: 1 << 5,
display_depth: 0,
..PpcDspContextAttributes::default()
},
),
(
"display best depth excludes 16-bit",
PpcDspContextAttributes {
display_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
display_depth: 32,
..PpcDspContextAttributes::default()
},
),
(
"back-buffer mask excludes 16-bit",
PpcDspContextAttributes {
back_buffer_best_depth_mask: 1 << 5,
back_buffer_depth: 0,
..PpcDspContextAttributes::default()
},
),
(
"back-buffer best depth excludes 16-bit",
PpcDspContextAttributes {
back_buffer_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
back_buffer_depth: 32,
..PpcDspContextAttributes::default()
},
),
(
"too many pages requested",
PpcDspContextAttributes {
page_count: PPC_DSP_MAX_REQUESTED_PAGE_COUNT + 1,
..PpcDspContextAttributes::default()
},
),
] {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindBestContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(context_out_ptr, vec![0xcc; 4]);
write_test_dsp_context_attributes(&mut loaded.memory, attributes_ptr, attributes);
let initial_draw_sprocket = loaded.draw_sprocket.clone();
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = context_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1, "{case}");
assert_eq!(probe.unsupported_import_index, None, "{case}");
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_DSP_CONTEXT_NOT_FOUND_ERR),
"{case}"
);
assert_eq!(loaded.draw_sprocket, initial_draw_sprocket, "{case}");
for offset in 0..4 {
assert_eq!(
loaded.memory.read_u8(context_out_ptr + offset),
Some(0xcc),
"{case}"
);
}
}
}
#[test]
fn hle_import_runner_draw_sprocket_accepts_1bit_back_buffer_preference() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindBestContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(context_out_ptr, vec![0; 4]);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
display_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
display_depth: PPC_MAIN_PIXEL_DEPTH,
back_buffer_best_depth_mask: 1,
back_buffer_depth: 1,
..PpcDspContextAttributes::default()
},
);
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = context_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(context_out_ptr),
Some(PPC_DSP_CONTEXT)
);
assert_eq!(
loaded.draw_sprocket.context_attributes,
PpcDspContextAttributes::default()
);
}
#[test]
fn hle_import_runner_draw_sprocket_find_best_context_param_err_preserves_state() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindBestContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
width: 800,
height: 600,
..PpcDspContextAttributes::default()
},
);
let initial_draw_sprocket = loaded.draw_sprocket.clone();
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = context_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.draw_sprocket, initial_draw_sprocket);
assert_eq!(loaded.memory.read_u8(context_out_ptr), None);
}
#[test]
fn hle_import_runner_handles_draw_sprocket_can_user_select_context_signature() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpCanUserSelectContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let can_select_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(can_select_out_ptr, vec![0xff; 4]);
let requested = PpcDspContextAttributes {
width: 800,
height: 600,
..PpcDspContextAttributes::default()
};
write_test_dsp_context_attributes(&mut loaded.memory, attributes_ptr, requested);
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = can_select_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u8(can_select_out_ptr), Some(0));
assert_eq!(loaded.memory.read_u8(can_select_out_ptr + 1), Some(0xff));
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 4),
Some(requested.width)
);
}
#[test]
fn hle_import_runner_draw_sprocket_get_first_context_accepts_default_display() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpGetFirstContext");
let mut loaded = load_pef_application(&pef).unwrap();
let context_out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(context_out, vec![0xaa; 4]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = context_out;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(context_out),
Some(PPC_DSP_CONTEXT)
);
}
#[test]
fn hle_import_runner_traces_draw_sprocket_can_user_select_output() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpCanUserSelectContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let can_select_out_ptr = PPC_DATA_BASE + 0x1100;
let requested = PpcDspContextAttributes {
width: PPC_DSP_SCREEN_WIDTH,
height: PPC_DSP_SCREEN_HEIGHT,
..PpcDspContextAttributes::default()
};
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(can_select_out_ptr, vec![0xff; 1]);
write_test_dsp_context_attributes(&mut loaded.memory, attributes_ptr, requested);
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = can_select_out_ptr;
let probe = loaded.run_with_hle_import_trace(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_NO_ERR));
assert_eq!(loaded.memory.read_u8(can_select_out_ptr), Some(0));
assert_eq!(probe.draw_sprocket_trace.len(), 1);
let trace = &probe.draw_sprocket_trace[0];
assert_eq!(trace.action, "can_user_select_context");
assert_eq!(trace.result, PPC_NO_ERR);
assert_eq!(trace.requested_width, Some(requested.width));
assert_eq!(trace.requested_height, Some(requested.height));
assert_eq!(trace.can_user_select, Some(false));
}
#[test]
fn hle_import_runner_draw_sprocket_can_user_select_output_is_prevalidated() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpCanUserSelectContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let can_select_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
width: 800,
height: 600,
..PpcDspContextAttributes::default()
},
);
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = can_select_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u8(can_select_out_ptr), None);
assert_eq!(loaded.memory.read_u32_be(attributes_ptr + 4), Some(800));
assert_eq!(loaded.memory.read_u32_be(attributes_ptr + 8), Some(600));
}
#[test]
fn hle_import_runner_handles_draw_sprocket_user_select_context_signature() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpUserSelectContext");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(context_out_ptr, vec![0; 4]);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
width: PPC_DSP_SCREEN_WIDTH,
height: PPC_DSP_SCREEN_HEIGHT,
..PpcDspContextAttributes::default()
},
);
loaded.cpu.gpr[3] = attributes_ptr;
loaded.cpu.gpr[4] = 42;
loaded.cpu.gpr[5] = 0x1234_5678;
loaded.cpu.gpr[6] = context_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(context_out_ptr),
Some(PPC_DSP_CONTEXT)
);
assert!(loaded.draw_sprocket.started);
assert_eq!(
loaded.draw_sprocket.context_attributes.width,
PPC_DSP_SCREEN_WIDTH
);
assert_eq!(
loaded.draw_sprocket.context_attributes.height,
PPC_DSP_SCREEN_HEIGHT
);
assert_eq!(loaded.draw_sprocket.last_user_select_display_id, Some(42));
assert_eq!(
loaded.draw_sprocket.last_user_select_event_proc,
Some(0x1234_5678)
);
assert_eq!(loaded.draw_sprocket.user_select_count, 1);
}
#[test]
fn hle_import_runner_handles_draw_sprocket_set_blanking_color() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpSetBlankingColor");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(color_ptr, vec![0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc]);
loaded.cpu.gpr[3] = color_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.draw_sprocket.blanking_color,
PpcRgbColor {
red: 0x1234,
green: 0x5678,
blue: 0x9abc,
}
);
}
#[test]
fn hle_import_runner_draw_sprocket_get_mouse_writes_global_point() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpGetMouse");
let mut loaded = load_pef_application(&pef).unwrap();
let point_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(point_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = point_ptr;
loaded.set_input_snapshot(PpcInputSnapshot {
mouse_v: -12,
mouse_h: 345,
..PpcInputSnapshot::default()
});
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_NO_ERR));
assert_eq!(loaded.memory.read_u16_be(point_ptr), Some((-12_i16) as u16));
assert_eq!(loaded.memory.read_u16_be(point_ptr + 2), Some(345));
}
#[test]
fn hle_import_runner_draw_sprocket_get_mouse_rejects_null() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpGetMouse");
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], ppc_i16_result(PPC_PARAM_ERR));
}
#[test]
fn hle_import_runner_draw_sprocket_finds_context_from_packed_point() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindContextFromPoint");
let mut loaded = load_pef_application(&pef).unwrap();
let context_out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(context_out, vec![0xaa; 4]);
loaded.cpu.gpr[3] = (240_u32 << 16) | 320;
loaded.cpu.gpr[4] = context_out;
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_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(context_out),
Some(PPC_DSP_CONTEXT)
);
}
#[test]
fn hle_import_runner_draw_sprocket_rejects_point_outside_context() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpFindContextFromPoint");
let mut loaded = load_pef_application(&pef).unwrap();
let context_out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(context_out, vec![0xaa; 4]);
loaded.cpu.gpr[3] = ((-1_i16 as u16 as u32) << 16) | 20;
loaded.cpu.gpr[4] = context_out;
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_DSP_CONTEXT_NOT_FOUND_ERR)
);
assert_eq!(loaded.memory.read_u32_be(context_out), Some(0xaaaa_aaaa));
}
#[test]
fn hle_import_runner_draw_sprocket_global_to_local_preserves_main_display_point() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GlobalToLocal");
let mut loaded = load_pef_application(&pef).unwrap();
let point = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(point, vec![0x00, 0xf0, 0x01, 0x40]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = point;
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_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(point), Some(0x00f0_0140));
}
#[test]
fn hle_import_runner_draw_sprocket_local_to_global_preserves_main_display_point() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_LocalToGlobal");
let mut loaded = load_pef_application(&pef).unwrap();
let point = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(point, vec![0x00, 0xf0, 0x01, 0x40]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = point;
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_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(point), Some(0x00f0_0140));
}
#[test]
fn hle_import_runner_draw_sprocket_get_state_reports_reserved_context() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetState");
let mut loaded = load_pef_application(&pef).unwrap();
let state_out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(state_out, vec![0xff; 4]);
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.context_state = PpcDspContextPlayState::Active;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = state_out;
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_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(state_out), Some(PPC_DSP_CONTEXT_STATE_ACTIVE));
}
#[test]
fn hle_import_runner_draw_sprocket_set_blanking_color_rejects_null() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpSetBlankingColor");
let mut loaded = load_pef_application(&pef).unwrap();
let original = PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333,
};
loaded.draw_sprocket.blanking_color = original;
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_PARAM_ERR));
assert_eq!(loaded.draw_sprocket.blanking_color, original);
}
#[test]
fn hle_import_runner_draw_sprocket_set_blanking_color_rejects_truncated_input() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpSetBlankingColor");
let mut loaded = load_pef_application(&pef).unwrap();
let color_ptr = PPC_DATA_BASE + 0x1000;
let original = PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333,
};
loaded.draw_sprocket.blanking_color = original;
loaded
.memory
.add_region(color_ptr, vec![0x12, 0x34, 0x56, 0x78]);
loaded.cpu.gpr[3] = color_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.draw_sprocket.blanking_color, original);
}
#[test]
fn hle_import_runner_creates_draw_sprocket_alt_buffer_with_requested_size() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpAltBuffer_New");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let out_alt_buffer_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(attributes_ptr, vec![0; 28]);
loaded.memory.add_region(out_alt_buffer_ptr, vec![0; 4]);
loaded.memory.write_u32_be(attributes_ptr, 32).unwrap();
loaded.memory.write_u32_be(attributes_ptr + 4, 24).unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = attributes_ptr;
loaded.cpu.gpr[6] = out_alt_buffer_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let alt_buffer = loaded.memory.read_u32_be(out_alt_buffer_ptr).unwrap();
let world = loaded
.gworlds
.iter()
.find(|world| world.port == alt_buffer)
.unwrap();
assert_eq!((world.width, world.height), (32, 24));
assert_eq!(
world.depth,
loaded.draw_sprocket.context_attributes.display_depth
);
}
#[test]
fn hle_import_runner_gets_draw_sprocket_alt_buffer_port_and_device() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpAltBuffer_GetCGrafPtr");
let mut loaded = load_pef_application(&pef).unwrap();
let port_out_ptr = PPC_DATA_BASE + 0x1000;
let device_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(port_out_ptr, vec![0; 4]);
loaded.memory.add_region(device_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = PPC_DSP_BACK_GWORLD;
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
loaded.cpu.gpr[5] = port_out_ptr;
loaded.cpu.gpr[6] = device_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(port_out_ptr),
Some(PPC_DSP_BACK_GWORLD)
);
assert_eq!(
loaded.memory.read_u32_be(device_out_ptr),
Some(PPC_MAIN_GDEVICE)
);
}
#[test]
fn hle_import_runner_handles_draw_sprocket_startup() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpStartup");
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], ppc_i16_result(PPC_NO_ERR));
assert!(loaded.draw_sprocket.started);
}
#[test]
fn hle_import_runner_handles_draw_sprocket_shutdown() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpShutdown");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket = PpcDrawSprocketState {
started: true,
blanking_color: PPC_RGB_WHITE,
reserved_context: Some(PPC_DSP_CONTEXT),
active_context: Some(PPC_DSP_CONTEXT),
context_state: PpcDspContextPlayState::Active,
context_attributes: PpcDspContextAttributes {
width: 800,
height: 600,
..PpcDspContextAttributes::default()
},
front_buffer_gworld: PPC_DSP_BACK_GWORLD,
back_buffer_gworld: PPC_MAIN_GWORLD,
last_fade_context: Some(PPC_DSP_CONTEXT),
last_fade_kind: Some(PpcDspGammaFadeKind::Out),
last_fade_percent: Some(0),
last_fade_zero_color: Some(PpcRgbColor {
red: 0,
green: 0,
blue: 0,
}),
fade_count: 2,
last_user_select_display_id: Some(PPC_DSP_DISPLAY_ID),
last_user_select_event_proc: Some(0x1234_5678),
user_select_count: 1,
last_swap_context: Some(PPC_DSP_CONTEXT),
swap_count: 3,
..PpcDrawSprocketState::default()
};
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_NO_ERR));
assert_eq!(loaded.draw_sprocket, PpcDrawSprocketState::default());
}
#[test]
fn hle_import_runner_tracks_draw_sprocket_reserve_set_state_and_release() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Reserve");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
frequency: 0,
width: 1024,
height: 768,
context_options: 0x40,
display_best_depth_mask: 0,
back_buffer_best_depth_mask: 0,
display_depth: 0,
back_buffer_depth: 0,
page_count: 4,
},
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = attributes_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert!(loaded.draw_sprocket.started);
assert_eq!(loaded.draw_sprocket.reserved_context, Some(PPC_DSP_CONTEXT));
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Inactive
);
assert_eq!(
loaded.draw_sprocket.context_attributes,
PpcDspContextAttributes {
frequency: PPC_DSP_FREQUENCY_60HZ,
width: PPC_DSP_SCREEN_WIDTH,
height: PPC_DSP_SCREEN_HEIGHT,
context_options: PPC_DSP_CONTEXT_OPTION_QD3D_ACCEL,
display_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
back_buffer_best_depth_mask: PPC_DSP_DEPTH_MASK_16,
display_depth: PPC_MAIN_SCREEN_STORAGE_DEPTH,
back_buffer_depth: PPC_MAIN_SCREEN_STORAGE_DEPTH,
page_count: PPC_DSP_ADVERTISED_PAGE_COUNT,
}
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetState");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
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_NO_ERR));
assert_eq!(loaded.draw_sprocket.active_context, Some(PPC_DSP_CONTEXT));
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Active
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
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_NO_ERR));
assert_eq!(loaded.draw_sprocket.active_context, None);
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Inactive
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Release");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
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_NO_ERR));
assert_eq!(loaded.draw_sprocket.reserved_context, None);
assert_eq!(loaded.draw_sprocket.active_context, None);
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Inactive
);
}
#[test]
fn hle_import_runner_draw_sprocket_reports_reserved_lifecycle_errors() {
let already_reserved = ppc_i16_result(PPC_DSP_CONTEXT_ALREADY_RESERVED_ERR);
let not_reserved = ppc_i16_result(PPC_DSP_CONTEXT_NOT_RESERVED_ERR);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Reserve");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.context_state = PpcDspContextPlayState::Inactive;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
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);
assert_eq!(loaded.cpu.gpr[3], already_reserved);
assert_eq!(loaded.draw_sprocket.reserved_context, Some(PPC_DSP_CONTEXT));
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Inactive
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Release");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
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], not_reserved);
assert_eq!(loaded.draw_sprocket.reserved_context, None);
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Inactive
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetState");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
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], not_reserved);
assert_eq!(loaded.draw_sprocket.active_context, None);
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Inactive
);
}
#[test]
fn hle_import_runner_draw_sprocket_tracks_paused_state() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetState");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.context_state = PpcDspContextPlayState::Active;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_PAUSED;
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_NO_ERR));
assert_eq!(loaded.draw_sprocket.active_context, None);
assert_eq!(
loaded.draw_sprocket.context_state,
PpcDspContextPlayState::Paused
);
}
#[test]
fn hle_import_runner_draw_sprocket_context_apis_return_not_found_for_invalid_handles() {
let invalid_context = PPC_DSP_CONTEXT + 4;
let expected_error = ppc_i16_result(PPC_DSP_CONTEXT_NOT_FOUND_ERR);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Reserve");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = invalid_context;
loaded.cpu.gpr[4] = PPC_DATA_BASE + 0x1000;
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], expected_error);
assert_eq!(loaded.draw_sprocket.reserved_context, None);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Release");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = invalid_context;
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], expected_error);
assert_eq!(loaded.draw_sprocket.reserved_context, Some(PPC_DSP_CONTEXT));
assert_eq!(loaded.draw_sprocket.active_context, Some(PPC_DSP_CONTEXT));
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetState");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = invalid_context;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
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], expected_error);
assert_eq!(loaded.draw_sprocket.active_context, None);
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetFrontBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let front_buffer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(front_buffer_out_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = invalid_context;
loaded.cpu.gpr[4] = front_buffer_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.cpu.gpr[3], expected_error);
assert_ppc_bytes_equal(&mut loaded.memory, front_buffer_out_ptr, 4, 0xaa);
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetBackBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let back_buffer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(back_buffer_out_ptr, vec![0xbb; 4]);
loaded.cpu.gpr[3] = invalid_context;
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
loaded.cpu.gpr[5] = back_buffer_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.cpu.gpr[3], expected_error);
assert_ppc_bytes_equal(&mut loaded.memory, back_buffer_out_ptr, 4, 0xbb);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetDisplayID");
let mut loaded = load_pef_application(&pef).unwrap();
let display_id_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(display_id_out_ptr, vec![0xcc; 4]);
loaded.cpu.gpr[3] = invalid_context;
loaded.cpu.gpr[4] = display_id_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.cpu.gpr[3], expected_error);
assert_ppc_bytes_equal(&mut loaded.memory, display_id_out_ptr, 4, 0xcc);
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetAttributes");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(
attributes_out_ptr,
vec![0xdd; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.cpu.gpr[3] = invalid_context;
loaded.cpu.gpr[4] = attributes_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.cpu.gpr[3], expected_error);
assert_ppc_bytes_equal(
&mut loaded.memory,
attributes_out_ptr,
PPC_DSP_CONTEXT_ATTRIBUTES_SIZE,
0xdd,
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_FadeGamma");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = invalid_context;
loaded.cpu.gpr[4] = 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.cpu.gpr[3], expected_error);
assert_eq!(loaded.draw_sprocket.last_fade_context, None);
assert_eq!(loaded.draw_sprocket.fade_count, 0);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SwapBuffers");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = invalid_context;
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], expected_error);
assert_eq!(loaded.draw_sprocket.active_context, Some(PPC_DSP_CONTEXT));
assert_eq!(loaded.draw_sprocket.last_swap_context, None);
assert_eq!(loaded.draw_sprocket.swap_count, 0);
}
#[test]
fn hle_import_runner_handles_draw_sprocket_front_buffer_and_display_id() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetFrontBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let front_buffer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(front_buffer_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = front_buffer_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(front_buffer_out_ptr),
Some(PPC_MAIN_GWORLD)
);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetDisplayID");
let mut loaded = load_pef_application(&pef).unwrap();
let display_id_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(display_id_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = display_id_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(display_id_out_ptr),
Some(PPC_DSP_DISPLAY_ID)
);
}
#[test]
fn hle_import_runner_draw_sprocket_buffer_outputs_are_all_or_nothing() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetFrontBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let front_buffer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded
.memory
.add_region(front_buffer_out_ptr, vec![0xaa; 2]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = front_buffer_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u8(front_buffer_out_ptr), Some(0xaa));
assert_eq!(loaded.memory.read_u8(front_buffer_out_ptr + 1), Some(0xaa));
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetDisplayID");
let mut loaded = load_pef_application(&pef).unwrap();
let display_id_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(display_id_out_ptr, vec![0xbb; 2]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = display_id_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u8(display_id_out_ptr), Some(0xbb));
assert_eq!(loaded.memory.read_u8(display_id_out_ptr + 1), Some(0xbb));
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetBackBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let back_buffer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(back_buffer_out_ptr, vec![0xcc; 2]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
loaded.cpu.gpr[5] = back_buffer_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.memory.read_u8(back_buffer_out_ptr), Some(0xcc));
assert_eq!(loaded.memory.read_u8(back_buffer_out_ptr + 1), Some(0xcc));
}
#[test]
fn hle_import_runner_handles_draw_sprocket_back_buffer_as_distinct_page() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetBackBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let back_buffer_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(back_buffer_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
loaded.cpu.gpr[5] = back_buffer_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(back_buffer_out_ptr),
Some(PPC_DSP_BACK_GWORLD)
);
assert_ne!(loaded.draw_sprocket.back_buffer_gworld, PPC_MAIN_GWORLD);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL + 1;
loaded.cpu.gpr[5] = back_buffer_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
}
#[test]
fn draw_sprocket_one_page_context_draws_into_displayed_buffer() {
let pef = synthetic_pef_with_import(b"SetPort");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let back_buffer_out_ptr = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(
attributes_ptr,
vec![0; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.memory.add_region(back_buffer_out_ptr, vec![0; 4]);
write_test_dsp_context_attributes(
&mut loaded.memory,
attributes_ptr,
PpcDspContextAttributes {
page_count: 1,
..PpcDspContextAttributes::default()
},
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = attributes_ptr;
assert_eq!(
ppc_dsp_context_reserve(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&mut loaded.gworlds,
),
PPC_NO_ERR
);
assert_eq!(loaded.draw_sprocket.context_attributes.page_count, 1);
assert_eq!(loaded.draw_sprocket.back_buffer_gworld, PPC_MAIN_GWORLD);
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
loaded.cpu.gpr[5] = back_buffer_out_ptr;
assert_eq!(
ppc_dsp_context_get_back_buffer(&loaded.cpu, &mut loaded.memory, &mut loaded.draw_sprocket, &loaded.gworlds),
PPC_NO_ERR
);
assert_eq!(
loaded.memory.read_u32_be(back_buffer_out_ptr),
Some(PPC_MAIN_GWORLD)
);
}
#[test]
fn hle_import_runner_tracks_draw_sprocket_swap_buffers() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SwapBuffers");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded
.memory
.write_u16_be(PPC_DSP_BACK_SCREEN_BASE, 0x7c00)
.unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
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_NO_ERR));
assert!(loaded.draw_sprocket.started);
assert_eq!(loaded.draw_sprocket.reserved_context, Some(PPC_DSP_CONTEXT));
assert_eq!(loaded.draw_sprocket.active_context, Some(PPC_DSP_CONTEXT));
assert_eq!(
loaded.draw_sprocket.last_swap_context,
Some(PPC_DSP_CONTEXT)
);
assert_eq!(loaded.draw_sprocket.swap_count, 1);
assert_eq!(loaded.draw_sprocket.front_buffer_gworld, PPC_MAIN_GWORLD);
assert_eq!(loaded.draw_sprocket.back_buffer_gworld, PPC_DSP_BACK_GWORLD);
let current_buffer = loaded.current_front_buffer().unwrap();
assert_eq!(current_buffer.base_addr, PPC_MAIN_SCREEN_BASE);
let front_buffer = loaded.presented_front_buffer().unwrap();
assert_eq!(front_buffer.base_addr, PPC_MAIN_SCREEN_BASE);
assert_eq!(
loaded.memory.read_u16_be(front_buffer.base_addr),
Some(0x7c00)
);
}
#[test]
fn presented_front_buffer_uses_main_screen_without_active_draw_sprocket() {
let pef = synthetic_pef_with_import(b"SetPort");
let loaded = load_pef_application(&pef).unwrap();
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_DSP_BACK_GWORLD);
let front_buffer = loaded.presented_front_buffer().unwrap();
assert_eq!(loaded.draw_sprocket.active_context, None);
assert_eq!(loaded.draw_sprocket.front_buffer_gworld, PPC_MAIN_GWORLD);
assert_eq!(front_buffer.base_addr, PPC_MAIN_SCREEN_BASE);
}
#[test]
fn presented_front_buffer_uses_main_screen_before_first_draw_sprocket_swap() {
let pef = synthetic_pef_with_import(b"SetPort");
let mut loaded = load_pef_application(&pef).unwrap();
loaded
.current_gworld
.with_mut(|current_gworld| *current_gworld = PPC_DSP_BACK_GWORLD);
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.active_context = None;
loaded.draw_sprocket.front_buffer_gworld = PPC_MAIN_GWORLD;
let front_buffer = loaded.presented_front_buffer().unwrap();
assert_eq!(front_buffer.base_addr, PPC_MAIN_SCREEN_BASE);
}
#[test]
fn hle_import_runner_traces_draw_sprocket_swap_buffers() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SwapBuffers");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.context_state = PpcDspContextPlayState::Active;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
let probe = loaded.run_with_hle_import_trace(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_NO_ERR));
assert_eq!(probe.draw_sprocket_trace.len(), 1);
let trace = &probe.draw_sprocket_trace[0];
assert_eq!(trace.import_index, 0);
assert_eq!(trace.action, "swap_buffers");
assert_eq!(trace.result, PPC_NO_ERR);
assert_eq!(trace.context, Some(PPC_DSP_CONTEXT));
assert_eq!(trace.requested_state, None);
assert_eq!(trace.requested_frequency, None);
assert_eq!(trace.requested_width, None);
assert_eq!(trace.requested_height, None);
assert_eq!(trace.requested_context_options, None);
assert_eq!(trace.requested_display_depth_mask, None);
assert_eq!(trace.requested_back_buffer_depth_mask, None);
assert_eq!(trace.requested_display_depth, None);
assert_eq!(trace.requested_back_buffer_depth, None);
assert_eq!(trace.requested_page_count, None);
assert_eq!(trace.can_user_select, None);
assert_eq!(trace.fade_kind, None);
assert_eq!(trace.fade_percent, None);
assert_eq!(trace.fade_zero_red, None);
assert_eq!(trace.fade_zero_green, None);
assert_eq!(trace.fade_zero_blue, None);
assert_eq!(trace.reserved_context, Some(PPC_DSP_CONTEXT));
assert_eq!(trace.active_context, Some(PPC_DSP_CONTEXT));
assert_eq!(trace.context_state, "active");
assert_eq!(trace.front_buffer_gworld, PPC_MAIN_GWORLD);
assert_eq!(trace.back_buffer_gworld, PPC_DSP_BACK_GWORLD);
assert_eq!(trace.last_swap_context, Some(PPC_DSP_CONTEXT));
assert_eq!(trace.swap_count, 1);
assert_eq!(trace.fade_count, 0);
assert_eq!(trace.frequency, PPC_DSP_FREQUENCY_60HZ);
assert_eq!(trace.width, PPC_DSP_SCREEN_WIDTH);
assert_eq!(trace.height, PPC_DSP_SCREEN_HEIGHT);
assert_eq!(trace.context_options, PPC_DSP_CONTEXT_OPTION_QD3D_ACCEL);
assert_eq!(trace.display_depth_mask, PPC_DSP_DEPTH_MASK_16);
assert_eq!(trace.back_buffer_depth_mask, PPC_DSP_DEPTH_MASK_16);
assert_eq!(trace.display_depth, PPC_MAIN_SCREEN_STORAGE_DEPTH);
assert_eq!(trace.back_buffer_depth, PPC_MAIN_SCREEN_STORAGE_DEPTH);
assert_eq!(trace.page_count, PPC_DSP_ADVERTISED_PAGE_COUNT);
}
#[test]
fn hle_import_runner_traces_draw_sprocket_lifecycle_errors() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Release");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
let probe = loaded.run_with_hle_import_trace(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_DSP_CONTEXT_NOT_RESERVED_ERR)
);
assert_eq!(probe.draw_sprocket_trace.len(), 1);
let trace = &probe.draw_sprocket_trace[0];
assert_eq!(trace.action, "context_release");
assert_eq!(trace.result, PPC_DSP_CONTEXT_NOT_RESERVED_ERR);
assert_eq!(trace.context, Some(PPC_DSP_CONTEXT));
assert_eq!(trace.reserved_context, None);
assert_eq!(trace.active_context, None);
assert_eq!(trace.context_state, "inactive");
assert_eq!(trace.swap_count, 0);
assert_eq!(trace.fade_count, 0);
}
#[test]
fn hle_import_runner_draw_sprocket_swap_requires_active_context() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SwapBuffers");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded
.memory
.write_u16_be(PPC_DSP_BACK_SCREEN_BASE, 0x7c00)
.unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
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_PARAM_ERR));
assert_eq!(loaded.draw_sprocket.active_context, None);
assert_eq!(loaded.draw_sprocket.last_swap_context, None);
assert_eq!(loaded.draw_sprocket.swap_count, 0);
assert_eq!(loaded.draw_sprocket.front_buffer_gworld, PPC_MAIN_GWORLD);
assert_eq!(loaded.draw_sprocket.back_buffer_gworld, PPC_DSP_BACK_GWORLD);
assert_eq!(
loaded.memory.read_u16_be(PPC_DSP_BACK_SCREEN_BASE),
Some(0x7c00)
);
}
#[test]
fn hle_import_runner_records_draw_sprocket_gamma_fades() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_FadeGamma");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.draw_sprocket.last_fade_context,
Some(PPC_DSP_CONTEXT)
);
assert_eq!(
loaded.draw_sprocket.last_fade_kind,
Some(PpcDspGammaFadeKind::Manual)
);
assert_eq!(loaded.draw_sprocket.last_fade_percent, Some(37));
assert_eq!(loaded.draw_sprocket.last_fade_zero_color, None);
assert_eq!(loaded.draw_sprocket.fade_count, 1);
}
#[test]
fn hle_import_runner_records_draw_sprocket_gamma_fade_out_color() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_FadeGammaOut");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
let color_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(color_ptr, vec![0; 6]);
loaded.memory.write_u16_be(color_ptr, 0x1111).unwrap();
loaded.memory.write_u16_be(color_ptr + 2, 0x2222).unwrap();
loaded.memory.write_u16_be(color_ptr + 4, 0x3333).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = color_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.draw_sprocket.last_fade_context, Some(0));
assert_eq!(
loaded.draw_sprocket.last_fade_kind,
Some(PpcDspGammaFadeKind::Out)
);
assert_eq!(loaded.draw_sprocket.last_fade_percent, Some(0));
assert_eq!(
loaded.draw_sprocket.last_fade_zero_color,
Some(PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333
})
);
assert_eq!(loaded.draw_sprocket.fade_count, 1);
}
#[test]
fn hle_import_runner_traces_draw_sprocket_gamma_fade_zero_color() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_FadeGammaOut");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
let color_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(color_ptr, vec![0; 6]);
loaded.memory.write_u16_be(color_ptr, 0x1111).unwrap();
loaded.memory.write_u16_be(color_ptr + 2, 0x2222).unwrap();
loaded.memory.write_u16_be(color_ptr + 4, 0x3333).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = color_ptr;
let probe = loaded.run_with_hle_import_trace(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_NO_ERR));
assert_eq!(probe.draw_sprocket_trace.len(), 1);
let trace = &probe.draw_sprocket_trace[0];
assert_eq!(trace.action, "fade_gamma_out");
assert_eq!(trace.result, PPC_NO_ERR);
assert_eq!(trace.fade_kind.as_deref(), Some("out"));
assert_eq!(trace.fade_percent, Some(0));
assert_eq!(trace.fade_zero_red, Some(0x1111));
assert_eq!(trace.fade_zero_green, Some(0x2222));
assert_eq!(trace.fade_zero_blue, Some(0x3333));
assert_eq!(trace.fade_count, 1);
}
#[test]
fn hle_import_runner_draw_sprocket_auto_gamma_requires_reserved_context() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_FadeGammaOut");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.cpu.gpr[3] = 0;
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);
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_DSP_CONTEXT_NOT_RESERVED_ERR)
);
assert_eq!(loaded.draw_sprocket.last_fade_context, None);
assert_eq!(loaded.draw_sprocket.fade_count, 0);
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_FadeGammaIn");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.started = true;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
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);
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_DSP_CONTEXT_NOT_RESERVED_ERR)
);
assert_eq!(loaded.draw_sprocket.last_fade_context, None);
assert_eq!(loaded.draw_sprocket.fade_count, 0);
}
#[test]
fn hle_import_runner_handles_draw_sprocket_context_attributes() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetAttributes");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(
attributes_ptr,
vec![0xaa; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = attributes_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.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr),
Some(PPC_DSP_FREQUENCY_60HZ)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 4),
Some(PPC_DSP_SCREEN_WIDTH)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 8),
Some(PPC_DSP_SCREEN_HEIGHT)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 28),
Some(PPC_DSP_CONTEXT_OPTION_QD3D_ACCEL)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 32),
Some(PPC_DSP_DEPTH_MASK_16)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 36),
Some(PPC_DSP_DEPTH_MASK_16)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 40),
Some(PPC_MAIN_SCREEN_STORAGE_DEPTH)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 44),
Some(PPC_MAIN_SCREEN_STORAGE_DEPTH)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 48),
Some(PPC_DSP_ADVERTISED_PAGE_COUNT)
);
assert_eq!(loaded.memory.read_u8(attributes_ptr + 52), Some(0));
assert_eq!(loaded.memory.read_u32_be(attributes_ptr + 56), Some(0));
}
#[test]
fn hle_import_runner_draw_sprocket_get_attributes_is_all_or_nothing() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetAttributes");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(attributes_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = attributes_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.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
for offset in 0..4 {
assert_eq!(loaded.memory.read_u8(attributes_ptr + offset), Some(0xaa));
}
}
#[test]
fn hle_import_runner_returns_stored_draw_sprocket_context_attributes() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetAttributes");
let mut loaded = load_pef_application(&pef).unwrap();
let attributes_ptr = PPC_DATA_BASE + 0x1000;
let context_attributes = PpcDspContextAttributes {
frequency: 75 << 16,
width: 800,
height: 600,
context_options: PPC_DSP_CONTEXT_OPTION_QD3D_ACCEL | 0x20,
display_best_depth_mask: 0x20,
back_buffer_best_depth_mask: 0x10,
display_depth: 32,
back_buffer_depth: 16,
page_count: 1,
};
loaded.draw_sprocket.context_attributes = context_attributes;
loaded.memory.add_region(
attributes_ptr,
vec![0xaa; PPC_DSP_CONTEXT_ATTRIBUTES_SIZE as usize],
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = attributes_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr),
Some(context_attributes.frequency)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 4),
Some(context_attributes.width)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 8),
Some(context_attributes.height)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 28),
Some(context_attributes.context_options)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 32),
Some(context_attributes.back_buffer_best_depth_mask)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 36),
Some(context_attributes.display_best_depth_mask)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 40),
Some(context_attributes.back_buffer_depth)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 44),
Some(context_attributes.display_depth)
);
assert_eq!(
loaded.memory.read_u32_be(attributes_ptr + 48),
Some(context_attributes.page_count)
);
assert_eq!(loaded.memory.read_u8(attributes_ptr + 52), Some(0));
}
#[test]
fn hle_import_runner_handles_draw_sprocket_vbl_busy_and_alt_buffer_calls() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetVBLProc");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0x0200_1000;
loaded.cpu.gpr[5] = 0x1234_5678;
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_NO_ERR));
assert_eq!(loaded.draw_sprocket.vbl_proc, Some(0x0200_1000));
assert_eq!(loaded.draw_sprocket.vbl_refcon, Some(0x1234_5678));
let busy_ptr = 0x0400_0100;
loaded.memory.write_u8(busy_ptr, 1).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DSpContextIsBusy;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = busy_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.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u8(busy_ptr), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::DSpAltBufferDispose;
loaded.cpu.gpr[3] = 0x0300_0100;
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_NO_ERR));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::DSpContextInvalBackBufferRect;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
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);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target =
PpcImportDispatcherTarget::DSpContextSetUnderlayAltBuffer;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0x0300_0100;
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_PARAM_ERR));
}
#[test]
fn fire_vbl_tasks_invokes_active_draw_sprocket_vbl_proc() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpStartup");
let mut loaded = load_pef_application(&pef).unwrap();
const VECTOR: u32 = PPC_DATA_BASE + 0x4000;
const ENTRY: u32 = PPC_CODE_BASE + 0x2000;
loaded.memory.add_region(VECTOR, vec![0; 8]);
loaded.memory.write_u32_be(VECTOR, ENTRY).unwrap();
loaded.memory.write_u32_be(VECTOR + 4, PPC_DATA_BASE).unwrap();
loaded.memory.add_region(ENTRY, vec![0x4e, 0x80, 0x00, 0x20]);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.context_state = PpcDspContextPlayState::Active;
loaded.draw_sprocket.vbl_proc = Some(VECTOR);
loaded.draw_sprocket.vbl_refcon = Some(0x1234_5678);
let probes = loaded.fire_vbl_tasks_for_ticks(0, 2, 10, 64, false, false);
assert_eq!(probes.len(), 2);
assert_eq!(probes[0].invocation.callback, VECTOR);
assert_eq!(probes[1].invocation.callback, VECTOR);
}
#[test]
fn sprocket_trace_formatter_includes_draw_sprocket_state() {
let mut attrs = PpcDspContextAttributes::default();
attrs.width = 800;
attrs.height = 600;
attrs.page_count = 2;
let draw_sprocket = PpcDrawSprocketState {
started: true,
reserved_context: Some(0x00ab_cdef),
active_context: Some(0x00ab_cdef),
context_state: PpcDspContextPlayState::Active,
context_attributes: attrs,
last_swap_context: Some(0x00ab_cdef),
swap_count: 3,
last_fade_context: Some(0x00ab_cdef),
last_fade_kind: Some(PpcDspGammaFadeKind::Out),
last_fade_percent: Some(0),
last_fade_zero_color: Some(PpcRgbColor {
red: 0x1111,
green: 0x2222,
blue: 0x3333,
}),
fade_count: 1,
..PpcDrawSprocketState::default()
};
let entry = PpcHleImportTraceEntry {
import_index: 41,
library_name: "DrawSprocketLib".to_string(),
symbol_name: "DSpContext_SwapBuffers".to_string(),
pc: 0x01f0_1000,
lr: 0x0100_2000,
rtoc: 0x0200_3000,
sp: 0x03fe_f000,
dispatcher_target: PpcImportDispatcherTarget::DSpContextSwapBuffers,
repeat_count: 1,
};
assert_eq!(
format_sprocket_trace(
&entry,
[0x00ab_cdef, 0, 0, 0, 0, 0],
&format_sprocket_action(&PpcImportAction::Return(0)),
&draw_sprocket,
&PpcInputSprocketState::default(),
&[],
),
"[SPROCKET-TRACE] DrawSprocketLib:DSpContext_SwapBuffers pc=$01F01000 lr=$01002000 rtoc=$02003000 sp=$03FEF000 r3=$00ABCDEF r4=$00000000 r5=$00000000 r6=$00000000 r7=$00000000 r8=$00000000 action=return($00000000) dsp started=true reserved=$00ABCDEF active=$00ABCDEF state=active attrs=800x600 display_depth=16 back_depth=16 pages=2 front=$02F00000 back=$40010000 swaps=3 last_swap=$00ABCDEF fades=1 last_fade=out context=$00ABCDEF percent=0 zero=$1111/$2222/$3333"
);
}
#[test]
fn import_bindings_classify_draw_sprocket_imports() {
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpStartup"),
PpcImportDispatcherTarget::DSpStartup
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpShutdown"),
PpcImportDispatcherTarget::DSpShutdown
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpCanUserSelectContext"),
PpcImportDispatcherTarget::DSpCanUserSelectContext
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpGetMouse"),
PpcImportDispatcherTarget::DSpGetMouse
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpFindContextFromPoint"),
PpcImportDispatcherTarget::DSpFindContextFromPoint
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GlobalToLocal"),
PpcImportDispatcherTarget::DSpContextGlobalToLocal
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpFindBestContext"),
PpcImportDispatcherTarget::DSpFindBestContext
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpUserSelectContext"),
PpcImportDispatcherTarget::DSpUserSelectContext
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpSetBlankingColor"),
PpcImportDispatcherTarget::DSpSetBlankingColor
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpAltBuffer_New"),
PpcImportDispatcherTarget::DSpAltBufferNew
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpAltBuffer_GetCGrafPtr"),
PpcImportDispatcherTarget::DSpAltBufferGetCGrafPtr
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_Reserve"),
PpcImportDispatcherTarget::DSpContextReserve
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_Release"),
PpcImportDispatcherTarget::DSpContextRelease
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_SetState"),
PpcImportDispatcherTarget::DSpContextSetState
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_FadeGamma"),
PpcImportDispatcherTarget::DSpContextFadeGamma
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_FadeGammaIn"),
PpcImportDispatcherTarget::DSpContextFadeGammaIn
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_FadeGammaOut"),
PpcImportDispatcherTarget::DSpContextFadeGammaOut
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetFrontBuffer"),
PpcImportDispatcherTarget::DSpContextGetFrontBuffer
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetBackBuffer"),
PpcImportDispatcherTarget::DSpContextGetBackBuffer
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_SwapBuffers"),
PpcImportDispatcherTarget::DSpContextSwapBuffers
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetDisplayID"),
PpcImportDispatcherTarget::DSpContextGetDisplayID
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetAttributes"),
PpcImportDispatcherTarget::DSpContextGetAttributes
);
}
#[test]
fn nondebugging_draw_sprocket_debug_mode_resolves_weak_import_without_display_changes() {
for class in [2, 0x82] {
let pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"DrawSprocketLib",
b"DSpSetDebugMode",
class,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::DSpSetDebugMode
);
assert_ne!(loaded.imports[0].address, 0);
assert_eq!(
loaded.memory.read_u32_be(PPC_DATA_BASE),
Some(loaded.imports[0].address)
);
loaded.entry_pc = PPC_CODE_BASE;
let mut code = Vec::new();
for word in [
d_form_u(15, 12, 0, (PPC_DATA_BASE >> 16) as u16),
d_form_u(24, 12, 12, (PPC_DATA_BASE & 0xffff) as u16),
d_form_u(32, 12, 12, 0), d_form_u(32, 0, 12, 0), d_form_u(32, 2, 12, 4), xfx_form(31, 0, 9, 467),
xl_form(19, 20, 0, 528, true),
d_form_u(14, 0, 0, 0),
xfx_form(31, 0, 8, 467),
BLR,
] {
code.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(PPC_CODE_BASE, code);
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded.draw_sprocket.blanking_window = Some(0x1234_5678);
loaded.draw_sprocket.last_fade_percent = Some(25);
let state = loaded.draw_sprocket.clone();
for enabled in [0, 1, 0xff] {
loaded.cpu.gpr[3] = enabled;
loaded.cpu.gpr[4] = 0x1122_3344;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpSetDebugMode);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.cpu.gpr[4], 0x1122_3344);
assert_eq!(loaded.draw_sprocket, state);
}
}
let pef = synthetic_pef_with_loader(synthetic_loader_with_symbol_class(
b"DrawSprocketLib",
b"MissingOptionalDrawAPI",
0x82,
&[sm_index_reloc(0x30, 0)],
));
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::UnresolvedWeak
);
assert_eq!(loaded.imports[0].address, 0);
assert_eq!(loaded.memory.read_u32_be(PPC_DATA_BASE), Some(0));
}
#[test]
fn draw_sprocket_dirty_grid_import_writes_base_units_and_retains_rounded_size() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetDirtyRectGridUnits");
let mut loaded = load_pef_application(&pef).unwrap();
let out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(out, vec![0xA5; 16]);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = out;
loaded.cpu.gpr[5] = out + 4;
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_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(out), Some(32));
assert_eq!(loaded.memory.read_u32_be(out + 4), Some(32));
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 40;
loaded.cpu.gpr[5] = 96;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetDirtyRectGridSize,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = out;
loaded.cpu.gpr[5] = out + 4;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextGetDirtyRectGridSize,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(out), Some(64));
assert_eq!(loaded.memory.read_u32_be(out + 4), Some(96));
assert_eq!(loaded.memory.read_u32_be(out + 8), Some(0xA5A5_A5A5));
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_SetDirtyRectGridSize"),
PpcImportDispatcherTarget::DSpContextSetDirtyRectGridSize
);
assert_eq!(
dispatcher_target_for_import("DrawSprocketLib", "DSpContext_GetDirtyRectGridSize"),
PpcImportDispatcherTarget::DSpContextGetDirtyRectGridSize
);
}
#[test]
fn draw_sprocket_dirty_grid_rejects_bad_outputs_and_sizes_without_partial_changes() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetDirtyRectGridUnits");
let mut loaded = load_pef_application(&pef).unwrap();
let out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(out, vec![0xA5; 8]);
for (context, height, expected) in [
(PPC_DSP_CONTEXT, 0, PPC_PARAM_ERR),
(PPC_DSP_CONTEXT, 0xFFFF_FFFC, PPC_PARAM_ERR),
(0, out + 4, PPC_DSP_CONTEXT_NOT_FOUND_ERR),
] {
loaded.cpu.gpr[3] = context;
loaded.cpu.gpr[4] = out;
loaded.cpu.gpr[5] = height;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextGetDirtyRectGridUnits,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(expected));
assert_eq!(loaded.memory.read_u32_be(out), Some(0xA5A5_A5A5));
assert_eq!(loaded.memory.read_u32_be(out + 4), Some(0xA5A5_A5A5));
}
for (context, width, height, expected) in [
(PPC_DSP_CONTEXT, 0, 32, PPC_PARAM_ERR),
(PPC_DSP_CONTEXT, 32, u32::MAX, PPC_PARAM_ERR),
(0, 40, 40, PPC_DSP_CONTEXT_NOT_FOUND_ERR),
] {
loaded.cpu.gpr[3] = context;
loaded.cpu.gpr[4] = width;
loaded.cpu.gpr[5] = height;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetDirtyRectGridSize,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(expected));
assert_eq!(loaded.draw_sprocket.dirty_grid_size, (32, 32));
}
}
#[test]
fn draw_sprocket_monitor_frequency_import_returns_full_fixed_context_value() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetMonitorFrequency");
let mut loaded = load_pef_application(&pef).unwrap();
let out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(out, vec![0xA5; 8]);
loaded.draw_sprocket.context_attributes.frequency = (75 << 16) | 0x8000;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = out;
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_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(out), Some(0x004B_8000));
assert_eq!(loaded.memory.read_u32_be(out + 4), Some(0xA5A5_A5A5));
}
#[test]
fn draw_sprocket_monitor_frequency_errors_preserve_caller_output() {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetMonitorFrequency");
let mut loaded = load_pef_application(&pef).unwrap();
let out = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(out, vec![0xA5; 4]);
for (context, ptr, expected) in [
(0, out, PPC_DSP_CONTEXT_NOT_FOUND_ERR),
(PPC_DSP_CONTEXT, 0, PPC_PARAM_ERR),
(PPC_DSP_CONTEXT, out + 1, PPC_PARAM_ERR),
(PPC_DSP_CONTEXT, 0xFFFF_FFFC, PPC_PARAM_ERR),
] {
loaded.cpu.gpr[3] = context;
loaded.cpu.gpr[4] = ptr;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextGetMonitorFrequency,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(expected));
assert_eq!(loaded.memory.read_u32_be(out), Some(0xA5A5_A5A5));
}
}
#[test]
fn alternate_buffer_invalidation_updates_pixels_and_restores_sprites_after_presentation() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpAltBuffer_InvalRect");
let mut loaded = load_pef_application(&pef).unwrap();
let mut front = loaded.gworlds[0];
front.port = 0x03000100;
front.base_addr = 0x0A000000;
front.width = 4;
front.height = 4;
front.depth = 8;
front.row_bytes = ppc_row_bytes(front.width, front.depth).unwrap();
let mut back = front;
back.port = 0x03000200;
back.base_addr = 0x0A000100;
let mut underlay = front;
underlay.port = 0x03000300;
underlay.base_addr = 0x0A000200;
loaded.gworlds = vec![front, back, underlay];
for world in [front, back, underlay] {
loaded.memory.add_region(
world.base_addr,
vec![10; (world.row_bytes * world.height) as usize],
);
}
loaded.draw_sprocket.front_buffer_gworld = front.port;
loaded.draw_sprocket.back_buffer_gworld = back.port;
loaded.draw_sprocket.active_context = Some(PPC_DSP_CONTEXT);
loaded
.draw_sprocket
.alt_buffer_invalid_rects
.insert(underlay.port, Vec::new());
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = underlay.port;
assert_eq!(
ppc_dsp_context_set_underlay(&loaded.cpu, &mut loaded.draw_sprocket, &loaded.gworlds),
PPC_NO_ERR
);
let rect = PPC_DATA_BASE + 0x1100;
let output = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(rect, vec![0; 8]);
loaded.memory.add_region(output, vec![0; 4]);
ppc_write_rect(&mut loaded.memory, rect, 1, 1, 2, 2).unwrap();
loaded.memory.write_u8(underlay.base_addr + 17, 20).unwrap();
loaded.memory.write_u8(back.base_addr + 51, 99).unwrap();
loaded.cpu.gpr[3] = underlay.port;
loaded.cpu.gpr[4] = rect;
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_NO_ERR));
assert_eq!(
loaded.memory.read_u8(back.base_addr + 17),
Some(10),
"invalidation is retained until buffer acquisition"
);
loaded.memory.write_u8(back.base_addr + 18, 77).unwrap();
loaded.memory.write_u8(underlay.base_addr + 19, 30).unwrap();
ppc_write_rect(&mut loaded.memory, rect, 1, 3, 2, 4).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = underlay.port;
loaded.cpu.gpr[4] = rect;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
loaded.cpu.gpr[5] = output;
assert_eq!(
ppc_dsp_context_get_back_buffer(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&loaded.gworlds
),
PPC_NO_ERR
);
assert_eq!(loaded.memory.read_u8(back.base_addr + 17), Some(20));
assert_eq!(loaded.memory.read_u8(back.base_addr + 19), Some(30));
assert_eq!(
loaded.memory.read_u8(back.base_addr + 18),
Some(77),
"disjoint invalidation must preserve its gap"
);
ppc_write_rect(&mut loaded.memory, rect, 1, 1, 2, 2).unwrap();
assert_eq!(
loaded.memory.read_u8(back.base_addr + 51),
Some(99),
"pixels outside explicit invalidation stay intact"
);
loaded.memory.write_u8(back.base_addr + 17, 42).unwrap(); loaded.cpu.gpr[4] = rect;
assert_eq!(
ppc_dsp_context_inval_back_rect(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&loaded.gworlds
),
PPC_NO_ERR
);
assert_eq!(
ppc_dsp_context_swap_buffers(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&loaded.gworlds
),
PPC_NO_ERR
);
assert_eq!(
loaded.memory.read_u8(front.base_addr + 17),
Some(42),
"sprite must be presented before restoration"
);
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
assert_eq!(
ppc_dsp_context_get_back_buffer(
&loaded.cpu,
&mut loaded.memory,
&mut loaded.draw_sprocket,
&loaded.gworlds
),
PPC_NO_ERR
);
assert_eq!(
loaded.memory.read_u8(back.base_addr + 17),
Some(20),
"next frame erases sprite from underlay"
);
assert_eq!(
loaded.memory.read_u8(front.base_addr + 17),
Some(42),
"restoration must not rewrite the displayed frame"
);
assert_eq!(loaded.memory.read_u8(back.base_addr + 51), Some(99));
}
#[test]
fn alternate_buffer_invalidation_rejects_unknown_and_truncated_inputs_atomically() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpAltBuffer_InvalRect");
let mut loaded = load_pef_application(&pef).unwrap();
let world = loaded.gworlds[0];
loaded
.draw_sprocket
.alt_buffer_invalid_rects
.insert(world.port, Vec::new());
let rect = 0x0A000000;
loaded.memory.add_region(rect, vec![0; 6]);
for (port, ptr) in [
(0, rect),
(world.port + 1, rect),
(world.port, 0),
(world.port, rect),
] {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = port;
loaded.cpu.gpr[4] = ptr;
let before = loaded.draw_sprocket.clone();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.draw_sprocket, before);
}
}
#[test]
fn active_draw_sprocket_front_buffer_is_an_agl_window_and_expires_on_deactivation() {
use super::super::classic_gl_agl::PpcAglPixelFormatRequest;
use super::super::classic_gl_framebuffer::ClassicGlColorBuffer;
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_GetFrontBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let output = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(output, vec![0; 4]);
loaded.draw_sprocket.started = true;
loaded.draw_sprocket.reserved_context = Some(PPC_DSP_CONTEXT);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = output;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextGetFrontBuffer,
);
assert_eq!(loaded.cpu.gpr[3], 0);
let port = loaded.memory.read_u32_be(output).unwrap();
assert_eq!(Some(port), loaded.draw_sprocket.blanking_window);
assert!(loaded.window_list.contains_window(port));
let format = loaded.agl.choose_pixel_format(PpcAglPixelFormatRequest {
rgba: true,
double_buffered: true,
..Default::default()
});
let context = loaded.agl.create_context(format, 0);
loaded.cpu.gpr[3] = context;
loaded.cpu.gpr[4] = port;
run_test_import(&mut loaded, PpcImportDispatcherTarget::AglSetDrawable);
assert_eq!(loaded.cpu.gpr[3], 1);
let framebuffer = loaded
.agl
.context_mut(context)
.unwrap()
.framebuffer
.as_mut()
.unwrap();
assert!(framebuffer.clear_color(ClassicGlColorBuffer::Back, [0, 255, 0, 255]));
loaded.cpu.gpr[3] = context;
run_test_import(&mut loaded, PpcImportDispatcherTarget::AglSwapBuffers);
assert_eq!(loaded.agl.get_error(), 0);
assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_SCREEN_BASE),
Some(0x03e0)
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], 0);
assert!(!loaded.window_list.contains_window(port));
loaded.cpu.gpr[3] = context;
loaded.cpu.gpr[4] = port;
run_test_import(&mut loaded, PpcImportDispatcherTarget::AglSetDrawable);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn active_single_buffer_draw_sprocket_exposes_the_same_window_for_both_buffers() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_Reserve");
let mut loaded = load_pef_application(&pef).unwrap();
let output = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(output, vec![0; 8]);
loaded.draw_sprocket.context_attributes.page_count = 1;
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextReserve);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = output;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextGetFrontBuffer,
);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_BUFFER_KIND_NORMAL;
loaded.cpu.gpr[5] = output + 4;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextGetBackBuffer,
);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.memory.read_u32_be(output),
loaded.draw_sprocket.blanking_window
);
assert_eq!(
loaded.memory.read_u32_be(output + 4),
loaded.memory.read_u32_be(output)
);
}
#[test]
fn draw_sprocket_context_palette_survives_display_driver_table_replay() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetCLUTEntries");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.draw_sprocket.context_attributes = PpcDspContextAttributes {
display_best_depth_mask: 1 << 3,
back_buffer_best_depth_mask: 1 << 3,
display_depth: 8,
back_buffer_depth: 8,
..PpcDspContextAttributes::default()
};
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextReserve);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], 0);
let base = PPC_DATA_BASE + 0x4000;
loaded.memory.add_region(base, vec![0; 64]);
let colors = [[0x1234, 0x5678, 0x9abc], [0xdef0, 0x2468, 0x1357]];
for (offset, color) in colors.into_iter().enumerate() {
let entry = base + offset as u32 * 8;
loaded
.memory
.write_u16_be(entry, 10 + offset as u16)
.unwrap();
for (component, value) in color.into_iter().enumerate() {
loaded
.memory
.write_u16_be(entry + 2 + component as u32 * 2, value)
.unwrap();
}
}
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = base;
loaded.cpu.gpr[5] = 10;
loaded.cpu.gpr[6] = 2;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetClutEntries,
);
assert_eq!(loaded.cpu.gpr[3], 0);
let before_replay = loaded.screen_clut.with_ref(|clut| [clut[10], clut[11]]);
let device_table = loaded.memory.read_u32_be(PPC_MAIN_CTABLE_HANDLE).unwrap();
loaded
.memory
.write_u32_be(base + 32, device_table + 8 + 10 * 8)
.unwrap();
loaded.memory.write_u16_be(base + 36, 10).unwrap();
loaded.memory.write_u16_be(base + 38, 1).unwrap(); loaded.memory.write_u32_be(base + 40, base + 32).unwrap();
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = 3;
loaded.cpu.gpr[5] = base + 40;
run_test_import(&mut loaded, PpcImportDispatcherTarget::Control);
assert_eq!(loaded.cpu.gpr[3], 0);
let after_replay = loaded.screen_clut.with_ref(|clut| [clut[10], clut[11]]);
assert_eq!((before_replay, after_replay), (colors, colors));
}
fn activate_test_dsp_palette_context(loaded: &mut PpcLoadedApp, depth: u32) {
loaded.draw_sprocket.context_attributes = PpcDspContextAttributes {
display_best_depth_mask: if depth == 8 { 1 << 3 } else { 1 << 4 },
back_buffer_best_depth_mask: if depth == 8 { 1 << 3 } else { 1 << 4 },
display_depth: depth,
back_buffer_depth: depth,
..PpcDspContextAttributes::default()
};
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = 0;
run_test_import(loaded, PpcImportDispatcherTarget::DSpContextReserve);
assert_eq!(loaded.cpu.gpr[3], 0);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], 0);
}
#[test]
fn draw_sprocket_inactive_palette_preserves_desktop_and_survives_reactivation() {
for end in [
PpcImportDispatcherTarget::DSpContextSetState,
PpcImportDispatcherTarget::DSpContextRelease,
PpcImportDispatcherTarget::DSpShutdown,
] {
let pef =
synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetCLUTEntries");
let mut loaded = load_pef_application(&pef).unwrap();
let base = PPC_DATA_BASE + 0x4000;
loaded.memory.add_region(base, vec![0; 8]);
let mut color = [0x1234, 0x5678, 0x9abc];
for (component, value) in color.into_iter().enumerate() {
loaded
.memory
.write_u16_be(base + 2 + component as u32 * 2, value)
.unwrap();
}
loaded
.color_manager_clut
.with_mut(|clut| clut[3] = [0x1357, 0x2468, 0x9999]);
let rebound_table = PPC_DATA_BASE + 0x5000;
let rebound_bytes =
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE)
.unwrap();
loaded
.memory
.add_region(rebound_table, rebound_bytes.clone());
loaded
.memory
.write_u32_be(PPC_MAIN_CTABLE_HANDLE, rebound_table)
.unwrap();
let desktop = loaded.screen_clut.with_ref(|clut| *clut);
let desktop_logical = loaded.color_manager_clut.with_ref(|clut| *clut);
loaded
.memory
.write_u16_be(PPC_MAIN_CTABLE + 8 + 16 * 8, 0x4321)
.unwrap();
let desktop_table =
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE)
.unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = base;
loaded.cpu.gpr[5] = 17;
loaded.cpu.gpr[6] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetClutEntries,
);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.screen_clut.with_ref(|clut| *clut), desktop);
assert_eq!(
loaded.color_manager_clut.with_ref(|clut| *clut),
desktop_logical
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE)
.unwrap(),
desktop_table
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.memory.write_u16_be(base + 2, 0).unwrap();
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextGetClutEntries,
);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u16_be(base + 2), Some(color[0]));
activate_test_dsp_palette_context(&mut loaded, 8);
assert_eq!(loaded.screen_clut.with_ref(|clut| clut[17]), color);
assert_eq!(loaded.color_manager_clut.with_ref(|clut| clut[17]), color);
assert_eq!(
loaded.memory.read_u16_be(PPC_MAIN_CTABLE + 10 + 17 * 8),
Some(color[0])
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_PAUSED;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], 0);
color = [0x1111, 0x2222, 0x3333];
for (component, value) in color.into_iter().enumerate() {
loaded
.memory
.write_u16_be(base + 2 + component as u32 * 2, value)
.unwrap();
}
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = base;
loaded.cpu.gpr[5] = 17;
loaded.cpu.gpr[6] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetClutEntries,
);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.screen_clut.with_ref(|clut| clut[17]), color);
assert_eq!(loaded.color_manager_clut.with_ref(|clut| clut[17]), color);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.screen_clut.with_ref(|clut| *clut), desktop);
assert_eq!(
loaded.color_manager_clut.with_ref(|clut| *clut),
desktop_logical
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE)
.unwrap(),
desktop_table
);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_ACTIVE;
run_test_import(&mut loaded, PpcImportDispatcherTarget::DSpContextSetState);
assert_eq!(loaded.screen_clut.with_ref(|clut| clut[17]), color);
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = PPC_DSP_CONTEXT_STATE_INACTIVE;
run_test_import(&mut loaded, end);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.screen_clut.with_ref(|clut| *clut), desktop);
assert_eq!(
loaded.color_manager_clut.with_ref(|clut| *clut),
desktop_logical
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE)
.unwrap(),
desktop_table
);
assert!(loaded.draw_sprocket.desktop_snapshot.is_none());
assert_eq!(
loaded.memory.read_u32_be(PPC_MAIN_CTABLE_HANDLE),
Some(rebound_table)
);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, rebound_table, PPC_MAIN_CTABLE_SIZE).unwrap(),
rebound_bytes
);
}
}
#[test]
fn draw_sprocket_palette_updates_stage_aliased_sources_and_reject_short_inputs() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetCLUTEntries");
let mut loaded = load_pef_application(&pef).unwrap();
activate_test_dsp_palette_context(&mut loaded, 8);
let table = loaded.memory.read_u32_be(PPC_MAIN_CTABLE_HANDLE).unwrap();
let colors = loaded.screen_clut.with_ref(|clut| [clut[10], clut[11]]);
loaded
.memory
.write_u16_be(table + 8 + 11 * 8, 0x1234)
.unwrap();
loaded
.memory
.write_u16_be(table + 8 + 12 * 8, 0x5678)
.unwrap();
let neighbor = ppc_memory_read_bytes(&mut loaded.memory, table + 8 + 13 * 8, 8).unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = table + 8 + 10 * 8;
loaded.cpu.gpr[5] = 11;
loaded.cpu.gpr[6] = 2;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetClutEntries,
);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(
loaded.screen_clut.with_ref(|clut| [clut[11], clut[12]]),
colors
);
assert_eq!(
loaded
.color_manager_clut
.with_ref(|clut| [clut[11], clut[12]]),
colors
);
assert_eq!(loaded.memory.read_u16_be(table + 8 + 11 * 8), Some(0x1234));
assert_eq!(loaded.memory.read_u16_be(table + 8 + 12 * 8), Some(0x5678));
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, table + 8 + 13 * 8, 8).unwrap(),
neighbor
);
let before = loaded.screen_clut.with_ref(|clut| *clut);
let logical = loaded.color_manager_clut.with_ref(|clut| *clut);
let bytes = ppc_memory_read_bytes(&mut loaded.memory, table, PPC_MAIN_CTABLE_SIZE).unwrap();
let context = loaded.draw_sprocket.context_clut;
let short = PPC_DATA_BASE + 0x4000;
loaded.memory.add_region(short, vec![0; 8]);
for source in [0, short, u32::MAX - 4] {
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = source;
loaded.cpu.gpr[5] = 10;
loaded.cpu.gpr[6] = 2;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetClutEntries,
);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.screen_clut.with_ref(|clut| *clut), before);
assert_eq!(loaded.color_manager_clut.with_ref(|clut| *clut), logical);
assert_eq!(loaded.draw_sprocket.context_clut, context);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, table, PPC_MAIN_CTABLE_SIZE).unwrap(),
bytes
);
}
}
#[test]
fn draw_sprocket_direct_context_palette_does_not_change_display_colors() {
let pef = synthetic_pef_with_library_import(b"DrawSprocketLib", b"DSpContext_SetCLUTEntries");
let mut loaded = load_pef_application(&pef).unwrap();
activate_test_dsp_palette_context(&mut loaded, 16);
let base = PPC_DATA_BASE + 0x4000;
loaded.memory.add_region(base, vec![0x12; 8]);
let before = loaded.screen_clut.with_ref(|clut| *clut);
let logical = loaded.color_manager_clut.with_ref(|clut| *clut);
let table =
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE).unwrap();
loaded.cpu.gpr[3] = PPC_DSP_CONTEXT;
loaded.cpu.gpr[4] = base;
loaded.cpu.gpr[5] = 10;
loaded.cpu.gpr[6] = 1;
run_test_import(
&mut loaded,
PpcImportDispatcherTarget::DSpContextSetClutEntries,
);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.screen_clut.with_ref(|clut| *clut), before);
assert_eq!(loaded.color_manager_clut.with_ref(|clut| *clut), logical);
assert_eq!(
ppc_memory_read_bytes(&mut loaded.memory, PPC_MAIN_CTABLE, PPC_MAIN_CTABLE_SIZE).unwrap(),
table
);
}