use super::{
blit_row, build_device_itable, build_pict_indexed_transfer_table, build_src_to_dst_table,
clear_src_to_dst_table_cache_for_tests, closest_grayscale_luminance_index, draw_picture,
dst_clip_row_spans, peek_initial_packbits_clut, picture_stream_len, read_color_table,
try_blit_packbits_8bpp_src_copy_fast, try_blit_row_8bpp_src_copy_fast, DstClip, DstClipRegion,
PictIndexedTransfer, PictureRegion, PixMapInfo,
};
use crate::memory::{MacMemoryBus, MemoryBus};
use crate::trap::dispatch::TrapDispatcher;
#[test]
fn direct_color_matcher_preserves_full_scan_results() {
if super::clut_match_itable_enabled() {
return;
}
let mut palettes = [TrapDispatcher::standard_mac_8bpp_clut(), [[0u16; 3]; 256]];
let mut seed = 0x5EED_1234u32;
for entry in &mut palettes[1] {
for channel in entry {
seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*channel = (seed >> 16) as u16;
}
}
for clut in &palettes {
let matcher = super::DirectColorMatcher::new(clut);
for gray in 0..=255u8 {
let channel = gray as u16 * 257;
assert_eq!(
matcher.match_rgb(gray, gray, gray),
super::closest_clut_index(channel, channel, channel, clut)
);
}
for _ in 0..5_000 {
seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let [r, g, b, _] = seed.to_be_bytes();
assert_eq!(
matcher.match_rgb(r, g, b),
super::closest_clut_index(r as u16 * 257, g as u16 * 257, b as u16 * 257, clut),
"RGB ({r}, {g}, {b})"
);
}
}
}
#[test]
fn extended_v2_header_maps_source_rect_into_draw_picture_destination() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pic = 0x10_0000u32;
let screen_base = 0x08_0000u32;
let mut p = pic;
bus.write_word(p, 0);
p += 2;
for value in [10u16, 25, 20, 35] {
bus.write_word(p, value);
p += 2;
}
for value in [0x0011u16, 0x02FF, 0x0C00, 0xFFFE, 0] {
bus.write_word(p, value);
p += 2;
}
for value in [0x0120_0000u32, 0x0120_0000] {
bus.write_long(p, value);
p += 4;
}
for value in [40u16, 100, 80, 140, 0, 0, 0x0031, 50, 110, 60, 120, 0x00FF] {
bus.write_word(p, value);
p += 2;
}
bus.write_word(pic, (p - pic) as u16);
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
10,
10,
(screen_base, 10, 10, 10, 8),
&clut,
0,
None,
);
assert!(ok);
let painted = bus.read_byte(screen_base + 3 * 10 + 3);
assert_ne!(
painted, 0,
"high-resolution picture coordinates must reach the destination"
);
assert_eq!(bus.read_byte(screen_base), 0);
assert_eq!(bus.read_byte(screen_base + 6 * 10 + 6), 0);
}
fn push_v2_relative_text(commands: &mut Vec<u8>, opcode: u16, deltas: &[u8], text: &[u8]) {
super::recording_push_word(commands, opcode);
commands.extend_from_slice(deltas);
commands.push(text.len() as u8);
commands.extend_from_slice(text);
if !(deltas.len() + 1 + text.len()).is_multiple_of(2) {
commands.push(0);
}
}
fn push_v1_long_text(commands: &mut Vec<u8>, v: i16, h: i16, text: &[u8]) {
commands.push(0x28);
commands.extend_from_slice(&v.to_be_bytes());
commands.extend_from_slice(&h.to_be_bytes());
commands.push(text.len() as u8);
commands.extend_from_slice(text);
}
fn finish_v1_picture(frame: (i16, i16, i16, i16), commands: &[u8]) -> Vec<u8> {
let mut picture = vec![0; 10];
for (index, value) in [frame.0, frame.1, frame.2, frame.3].into_iter().enumerate() {
picture[2 + index * 2..4 + index * 2].copy_from_slice(&value.to_be_bytes());
}
picture.extend_from_slice(&[0x11, 0x01]);
picture.extend_from_slice(commands);
picture.push(0xFF);
let size = u16::try_from(picture.len()).unwrap();
picture[0..2].copy_from_slice(&size.to_be_bytes());
picture
}
fn render_text_picture(picture: &[u8], width: u16, height: u16) -> Vec<u8> {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen = 0x08_0000;
let pic = 0x10_0000;
bus.write_bytes(pic, picture);
bus.fill_zeros(screen, u32::from(width) * u32::from(height));
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let (drawn, _) = draw_picture(
&mut bus,
pic,
0,
0,
height as i16,
width as i16,
(screen, u32::from(width), width, height, 8),
&clut,
0,
None,
);
assert!(drawn);
bus.read_bytes(screen, usize::from(width) * usize::from(height))
}
fn push_origin_test_op(commands: &mut Vec<u8>, v2: bool, opcode: u16, words: &[i16]) {
if v2 {
super::recording_push_word(commands, opcode);
} else {
commands.push(opcode as u8);
}
for &word in words {
commands.extend_from_slice(&word.to_be_bytes());
}
}
fn finish_origin_test_picture(frame: (i16, i16, i16, i16), v2: bool, commands: Vec<u8>) -> Vec<u8> {
if v2 {
super::finish_recording(frame, commands)
} else {
finish_v1_picture(frame, &commands)
}
}
#[test]
fn pict_origin_moves_shapes_and_preserves_existing_clip_at_multiple_scales() {
for v2 in [false, true] {
let mut commands = Vec::new();
push_origin_test_op(&mut commands, v2, 0x0C, &[10, 20]);
push_origin_test_op(&mut commands, v2, 0x01, &[10, 20, 10, 32, 26]);
push_origin_test_op(&mut commands, v2, 0x31, &[22, 13, 25, 17]);
push_origin_test_op(&mut commands, v2, 0x0C, &[-4, -6]);
push_origin_test_op(&mut commands, v2, 0x31, &[16, 8, 18, 10]);
push_origin_test_op(&mut commands, v2, 0x31, &[24, 18, 28, 24]);
let picture = finish_origin_test_picture((0, 0, 24, 32), v2, commands);
for scale in [1u16, 2] {
let width = 32 * scale;
let pixels = render_text_picture(&picture, width, 24 * scale);
for y in 0..24 * scale {
for x in 0..width {
let (px, py) = (x / scale, y / scale);
let inside = ((2..5).contains(&py) && (3..7).contains(&px))
|| ((2..4).contains(&py) && (2..4).contains(&px))
|| ((10..12).contains(&py) && (12..16).contains(&px));
assert_eq!(
pixels[usize::from(y * width + x)],
if inside { 255 } else { 0 },
"v2={v2} scale={scale} pixel=({x},{y})"
);
}
}
}
}
}
#[test]
fn pict_origin_keeps_relative_text_positions_in_the_shifted_coordinate_plane() {
let frame = (0, 0, 48, 80);
let mut shifted = Vec::new();
push_origin_test_op(&mut shifted, true, 0x0C, &[8, 16]);
push_origin_test_op(&mut shifted, true, 0x01, &[10, 16, 8, 64, 88]);
push_v2_relative_text(&mut shifted, 0x2B, &[12, 28], b"A");
push_origin_test_op(&mut shifted, true, 0x0C, &[-4, 6]);
push_v2_relative_text(&mut shifted, 0x2A, &[12], b"B");
super::recording_push_long_text(&mut shifted, 46, 24, b"C");
let shifted = super::finish_recording(frame, shifted);
let mut plain = Vec::new();
for (v, h, text) in [(12, 4, b"A"), (18, 8, b"B"), (24, 20, b"C")] {
super::recording_push_long_text(&mut plain, v, h, text);
}
let plain = super::finish_recording(frame, plain);
for scale in [1, 2] {
let expected = render_text_picture(&plain, 80 * scale, 48 * scale);
assert!(expected.contains(&255));
assert_eq!(
render_text_picture(&shifted, 80 * scale, 48 * scale),
expected
);
}
}
#[test]
fn pict_origin_preserves_reused_rectangle_and_graphics_pen_device_positions() {
let frame = (0, 0, 32, 48);
let mut shifted = Vec::new();
push_origin_test_op(&mut shifted, true, 0x31, &[2, 2, 6, 8]);
push_origin_test_op(&mut shifted, true, 0x20, &[20, 3, 20, 10]);
push_origin_test_op(&mut shifted, true, 0x0C, &[10, 8]);
push_origin_test_op(&mut shifted, true, 0x0E, &[0, 30]); push_origin_test_op(&mut shifted, true, 0x39, &[]); push_origin_test_op(&mut shifted, true, 0x0E, &[0, 33]); push_origin_test_op(&mut shifted, true, 0x21, &[28, 30]); let shifted = super::finish_recording(frame, shifted);
let mut plain = Vec::new();
push_origin_test_op(&mut plain, true, 0x20, &[20, 3, 20, 20]);
let plain = super::finish_recording(frame, plain);
for scale in [1, 2] {
let expected = render_text_picture(&plain, 48 * scale, 32 * scale);
assert!(expected.contains(&255));
assert_eq!(
render_text_picture(&shifted, 48 * scale, 32 * scale),
expected
);
}
}
#[test]
fn pict_origin_moves_bitmap_destination_without_changing_source_coordinates() {
for v2 in [false, true] {
let mut commands = Vec::new();
push_origin_test_op(&mut commands, v2, 0x0C, &[8, 6]);
push_origin_test_op(
&mut commands,
v2,
0x90,
&[1, 0, 0, 1, 8, 0, 0, 1, 8, 8, 11, 9, 19, 0],
);
commands.push(0xAA);
if v2 && !commands.len().is_multiple_of(2) {
commands.push(0);
}
let picture = finish_origin_test_picture((0, 0, 16, 32), v2, commands);
let mut plain = Vec::new();
push_origin_test_op(
&mut plain,
v2,
0x90,
&[1, 0, 0, 1, 8, 0, 0, 1, 8, 2, 3, 3, 11, 0],
);
plain.push(0xAA);
if v2 && !plain.len().is_multiple_of(2) {
plain.push(0);
}
let plain = finish_origin_test_picture((0, 0, 16, 32), v2, plain);
for scale in [1u16, 2] {
let width = 32 * scale;
let pixels = render_text_picture(&picture, width, 16 * scale);
let expected = render_text_picture(&plain, width, 16 * scale);
assert_eq!(pixels, expected, "unshifted control v2={v2} scale={scale}");
if scale != 1 {
continue;
}
for y in 0..16 * scale {
for x in 0..width {
let (px, py) = (x / scale, y / scale);
let black = py == 2 && [3, 5, 7, 9].contains(&px);
assert_eq!(
pixels[usize::from(y * width + x)],
if black { 255 } else { 0 },
"v2={v2} scale={scale} pixel=({x},{y})"
);
}
}
}
}
}
#[test]
fn pict_v1_text_metadata_preserves_byte_aligned_following_text() {
let frame = (0, 0, 48, 80);
let mut plain = Vec::new();
push_v1_long_text(&mut plain, 20, 20, b"A");
let expected = render_text_picture(&finish_v1_picture(frame, &plain), 80, 48);
for opcode in [0x24, 0x25, 0x26, 0x27, 0x2C, 0x2D, 0x2E, 0x2F] {
let mut commands = vec![opcode, 0, 4, 0, 0, 0, 0];
commands.extend_from_slice(&plain);
let picture = finish_v1_picture(frame, &commands);
assert_eq!(picture_stream_len(&picture), Some(picture.len()));
assert_eq!(
render_text_picture(&picture, 80, 48),
expected,
"opcode {opcode:#x}"
);
}
}
#[test]
fn pict_v2_text_metadata_keeps_word_padding_before_following_text() {
let frame = (0, 0, 48, 80);
let mut plain = Vec::new();
super::recording_push_long_text(&mut plain, 20, 20, b"A");
let expected = render_text_picture(&super::finish_recording(frame, plain.clone()), 80, 48);
for opcode in [0x24, 0x25, 0x26, 0x27, 0x2C, 0x2D, 0x2E, 0x2F] {
let mut commands = Vec::new();
super::recording_push_word(&mut commands, opcode);
commands.extend_from_slice(&[0, 3, 0, 0, 0, 0xFF]);
commands.extend_from_slice(&plain);
let picture = super::finish_recording(frame, commands);
assert_eq!(picture_stream_len(&picture), Some(picture.len()));
assert_eq!(
render_text_picture(&picture, 80, 48),
expected,
"opcode {opcode:#x}"
);
}
}
#[test]
fn pict_v2_relative_text_uses_unsigned_deltas_from_previous_origins() {
let frame = (0, 0, 320, 700);
let mut relative = Vec::new();
push_v2_relative_text(&mut relative, 0x002B, &[10, 0xFE], b"A");
push_v2_relative_text(&mut relative, 0x0029, &[0xFE], b"B");
push_v2_relative_text(&mut relative, 0x0029, &[0xF8], b"C");
super::recording_push_long_text(&mut relative, 20, 620, b"D");
push_v2_relative_text(&mut relative, 0x002A, &[0xFE], b"E");
let relative = super::finish_recording(frame, relative);
let mut absolute = Vec::new();
super::recording_push_long_text(&mut absolute, 254, 10, b"A");
super::recording_push_long_text(&mut absolute, 254, 264, b"B");
super::recording_push_long_text(&mut absolute, 254, 512, b"C");
super::recording_push_long_text(&mut absolute, 20, 620, b"D");
super::recording_push_long_text(&mut absolute, 274, 620, b"E");
let absolute = super::finish_recording(frame, absolute);
let actual = render_text_picture(&relative, 700, 320);
let expected = render_text_picture(&absolute, 700, 320);
assert_eq!(actual, expected);
for (left, right) in [(0, 100), (250, 350), (500, 600), (600, 680)] {
assert!(expected
.chunks_exact(700)
.any(|row| row[left..right].contains(&255)));
}
}
#[test]
fn pict_v1_dvtext_keeps_the_previous_text_origin() {
let frame = (0, 0, 64, 320);
let mut relative = Vec::new();
push_v1_long_text(&mut relative, 20, 20, b"MMMMMMMMMMMM");
relative.extend_from_slice(&[0x2A, 20, 1, b'X']);
let relative = finish_v1_picture(frame, &relative);
let mut absolute = Vec::new();
push_v1_long_text(&mut absolute, 20, 20, b"MMMMMMMMMMMM");
push_v1_long_text(&mut absolute, 40, 20, b"X");
let absolute = finish_v1_picture(frame, &absolute);
let actual = render_text_picture(&relative, 320, 64);
let expected = render_text_picture(&absolute, 320, 64);
assert_eq!(actual, expected);
assert!(expected
.chunks_exact(320)
.skip(32)
.any(|row| row[16..48].contains(&255)));
}
fn render_v1_styled_text_pair(face: u8, missing: bool) -> (Vec<u8>, Vec<u8>) {
let glyph_advance = i16::from(
crate::quickdraw::text::get_glyph(3, 9, 'A')
.expect("bundled Geneva substitute must contain A")
.0
.advance,
);
let picture = |face: u8, split: bool, missing: bool| {
let mut commands = Vec::new();
commands.extend_from_slice(&[0x03, 0x00, 0x03]); commands.extend_from_slice(&[0x04, face]); commands.extend_from_slice(&[0x0D, 0x00, 0x09]); if split {
push_v1_long_text(&mut commands, 20, 20, b"A");
push_v1_long_text(
&mut commands,
20,
20 + glyph_advance
+ i16::from(face & 1)
+ if missing { 6 + i16::from(face & 1) } else { 0 },
b"A",
);
} else {
push_v1_long_text(
&mut commands,
20,
20,
if missing { b"A\x01A" } else { b"AA" },
);
}
finish_v1_picture((0, 0, 48, 80), &commands)
};
(
render_text_picture(&picture(face, false, missing), 80, 48),
render_text_picture(&picture(face, true, missing), 80, 48),
)
}
#[test]
fn pict_v1_bold_text_advances_each_glyph_by_style_width() {
let (plain_run, plain_absolute) = render_v1_styled_text_pair(0, false);
assert_eq!(plain_run, plain_absolute);
assert!(plain_run.contains(&255));
let (bold_run, bold_absolute) = render_v1_styled_text_pair(1, false);
assert_eq!(bold_run, bold_absolute);
}
#[test]
fn pict_v1_bold_text_advances_missing_glyphs_by_style_width() {
let (bold_missing_run, bold_missing_absolute) = render_v1_styled_text_pair(1, true);
assert_eq!(bold_missing_run, bold_missing_absolute);
}
#[test]
fn pict_geneva9_bold_run_matches_classic_relative_text_origins() {
const FIRST: &[u8] = b"This is your shooter. There are many like it, ";
const SECOND: &[u8] = b"but this one is yours. Mind it well, cuz it is ";
const THIRD: &[u8] = b"made of ";
let frame = (0, 0, 96, 700);
let text_state = |commands: &mut Vec<u8>| {
super::recording_push_word(commands, 0x0003); super::recording_push_word(commands, 3); super::recording_push_word(commands, 0x0004); commands.extend_from_slice(&[1, 0]); super::recording_push_word(commands, 0x000D); super::recording_push_word(commands, 9);
};
let mut relative = Vec::new();
text_state(&mut relative);
push_v2_relative_text(&mut relative, 0x002B, &[65, 56], FIRST);
push_v2_relative_text(&mut relative, 0x0029, &[0xFE], SECOND);
push_v2_relative_text(&mut relative, 0x0029, &[0xF8], THIRD);
let relative = super::finish_recording(frame, relative);
let mut continuous = Vec::new();
text_state(&mut continuous);
let mut text = Vec::new();
text.extend_from_slice(FIRST);
text.extend_from_slice(SECOND);
text.extend_from_slice(THIRD);
super::recording_push_long_text(&mut continuous, 56, 65, &text);
let continuous = super::finish_recording(frame, continuous);
let relative = render_text_picture(&relative, 700, 96);
let continuous = render_text_picture(&continuous, 700, 96);
assert_eq!(relative, continuous);
assert!(relative.contains(&255));
}
#[test]
fn device_itable_matches_rom_propagation_samples() {
let table = build_device_itable(&TrapDispatcher::standard_mac_8bpp_clut());
assert_eq!(table[0x564], 130);
assert_eq!(table[0x631], 137);
assert_eq!(table[0x431], 173);
assert_eq!(table[0x666], 129);
assert_eq!(table[0x333], 172);
assert_eq!(table[0x555], 251);
}
#[test]
fn device_itable_keeps_a_dark_shade_available_beside_exact_black() {
let mut clut = [[0xFFFF; 3]; 256];
clut[1] = [0x0000, 0x0000, 0x0000];
clut[104] = [0x0F0F, 0x0A0A, 0x0F0F];
let table = build_device_itable(&clut);
assert_eq!(table[0x000], 104);
assert_eq!(table[0x010], 104);
}
#[test]
fn color_table_uses_sparse_colorspec_values_as_source_indexes() {
let mut bus = MacMemoryBus::new(1024);
let mut pos = 0x100;
bus.write_long(pos, 0x1234_5678);
pos += 4;
bus.write_word(pos, 0); pos += 2;
bus.write_word(pos, 2); pos += 2;
for (value, rgb) in [
(200u16, [0x1111, 0x2222, 0x3333]),
(3u16, [0x4444, 0x5555, 0x6666]),
(99u16, [0x7777, 0x8888, 0x9999]),
] {
bus.write_word(pos, value);
pos += 2;
for component in rgb {
bus.write_word(pos, component);
pos += 2;
}
}
let (end, colors, seed) = read_color_table(&bus, 0x100);
assert_eq!(end, pos);
assert_eq!(seed, 0x1234_5678);
assert_eq!(colors[200], [0x1111, 0x2222, 0x3333]);
assert_eq!(colors[3], [0x4444, 0x5555, 0x6666]);
assert_eq!(colors[99], [0x7777, 0x8888, 0x9999]);
assert_eq!(colors[0], [0, 0, 0]);
}
#[test]
fn grayscale_luminance_mapping_prefers_low_chroma_match() {
let mut dst = [[0u16; 3]; 256];
dst[10] = [0xE000, 0x0000, 0x0000];
dst[20] = [0x3939, 0x2C2C, 0x3939];
assert_eq!(closest_grayscale_luminance_index(0x3939, &dst), 20);
}
#[test]
fn dense_grayscale_source_uses_luminance_translation() {
let mut src = [[0u16; 3]; 256];
for (index, rgb) in src.iter_mut().enumerate() {
let value = 0xFFFFu16.saturating_sub((index as u16) * 0x0101);
*rgb = [value, value, value];
}
let mut dst = [[0u16; 3]; 256];
dst[10] = [0xE000, 0x0000, 0x0000];
dst[20] = [0x3939, 0x2C2C, 0x3939];
dst[42] = [0x1111, 0x0202, 0x0000];
let table = build_src_to_dst_table(&src, &dst);
assert_eq!(table[198], 20);
}
#[test]
fn dense_grayscale_source_does_not_preserve_indices_on_system_palette() {
let mut src = [[0u16; 3]; 256];
for (index, rgb) in src.iter_mut().enumerate() {
let value = 0xFFFFu16.saturating_sub((index as u16) * 0x0101);
*rgb = [value, value, value];
}
let dst = TrapDispatcher::standard_mac_8bpp_clut();
let table = build_src_to_dst_table(&src, &dst);
assert_ne!(table[16], 16);
let mapped = dst[table[16] as usize];
assert_eq!(mapped[0], mapped[1]);
assert_eq!(mapped[1], mapped[2]);
}
#[test]
fn exact_same_index_palette_entries_win_over_earlier_duplicates() {
let mut src = [[0u16; 3]; 256];
let mut dst = [[0u16; 3]; 256];
let rgb = [0x2E2E, 0x0000, 0x3333];
src[71] = rgb;
dst[12] = rgb;
dst[71] = rgb;
let table = build_src_to_dst_table(&src, &dst);
assert_eq!(table[71], 71);
}
#[test]
fn exact_palette_entry_at_another_index_wins_over_inverse_cell_seed() {
let mut src = [[0u16; 3]; 256];
let mut dst = [[0u16; 3]; 256];
dst[5] = [0x2000, 0x0000, 0x3000];
dst[12] = [0x2E2E, 0x0202, 0x3333];
src[71] = dst[12];
let table = build_src_to_dst_table(&src, &dst);
assert_eq!(table[71], 12);
}
#[test]
fn eight_bit_device_matching_ignores_pict_rgb_low_bytes() {
let mut src = [[0u16; 3]; 256];
let mut dst = [[0u16; 3]; 256];
src[14] = [0xFF0E, 0x2D0E, 0x890E];
dst[73] = [0xFFFF, 0x2D2D, 0x8989];
dst[12] = [0xF000, 0x2000, 0x8000];
let table = build_src_to_dst_table(&src, &dst);
assert_eq!(table[14], 73);
}
#[test]
fn display_equivalent_palettes_preserve_authored_indices() {
let mut src = [[0u16; 3]; 256];
let mut dst = [[0u16; 3]; 256];
src[14] = [0xFF0E, 0x2D0E, 0x890E];
dst[14] = [0xFFFF, 0x2D2D, 0x8989];
dst[73] = [0xFFFF, 0x2D2D, 0x8989];
let table = build_src_to_dst_table(&src, &dst);
assert_eq!(table[14], 14);
}
#[test]
fn standard_eight_bit_colors_use_rom_four_bit_color2index_mapping() {
let src = TrapDispatcher::standard_mac_8bpp_clut();
let mut dst = TrapDispatcher::standard_mac_4bpp_gworld_clut();
let terminal = dst[15];
dst[16..].fill(terminal);
let table = build_src_to_dst_table(&src, &dst);
for (source, destination) in [
(0, 0),
(1, 0),
(7, 12),
(16, 2),
(42, 12),
(64, 3),
(128, 13),
(214, 15),
(215, 3),
(225, 8),
(235, 6),
(245, 0),
(255, 15),
] {
assert_eq!(
table[source], destination,
"standard 8-bit source index {source}"
);
}
}
#[test]
fn src_to_dst_table_cache_reuses_identical_cluts() {
clear_src_to_dst_table_cache_for_tests();
let mut src = [[0u16; 3]; 256];
let mut dst = [[0u16; 3]; 256];
src[1] = [0x2222, 0x3333, 0x4444];
dst[7] = [0x2222, 0x3333, 0x4444];
let first = build_src_to_dst_table(&src, &dst);
let second = build_src_to_dst_table(&src, &dst);
assert_eq!(second, first);
}
#[test]
fn src_to_dst_table_cache_keys_on_destination_clut_contents() {
clear_src_to_dst_table_cache_for_tests();
let mut src = [[0u16; 3]; 256];
src[1] = [0x2222, 0x3333, 0x4444];
let mut first_dst = [[0u16; 3]; 256];
first_dst[7] = [0x2222, 0x3333, 0x4444];
let mut second_dst = first_dst;
second_dst[9] = [0x2222, 0x3333, 0x4444];
second_dst[7] = [0x1111, 0x1111, 0x1111];
let first = build_src_to_dst_table(&src, &first_dst);
let second = build_src_to_dst_table(&src, &second_dst);
assert_ne!(first[1], second[1]);
}
#[test]
fn complex_dst_clip_row_spans_follow_region_edges() {
let clip = DstClip::new(
(0, 0, 5, 20),
vec![DstClipRegion::complex(
1,
0,
4,
20,
vec![vec![3, 8, 12, 15], vec![5, 10], vec![]],
)],
);
assert_eq!(
dst_clip_row_spans(Some(&clip), 1, 0, 20),
vec![(3, 8), (12, 15)]
);
assert_eq!(dst_clip_row_spans(Some(&clip), 2, 0, 20), vec![(5, 10)]);
assert!(dst_clip_row_spans(Some(&clip), 3, 0, 20).is_empty());
}
#[test]
fn eight_bit_src_copy_fast_path_respects_complex_dst_clip() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[0xEE; 8]);
let pm = PixMapInfo {
row_bytes: 8,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 1,
bounds_right: 8,
pixel_size: 8,
cmp_count: 1,
pack_type: 0,
};
let mut src_to_dst = [0u8; 256];
for (index, slot) in src_to_dst.iter_mut().enumerate() {
*slot = 100u8.saturating_add(index as u8);
}
let clip = DstClip::new(
(0, 0, 1, 8),
vec![DstClipRegion::complex(0, 0, 1, 8, vec![vec![2, 5]])],
);
let mut scratch = Vec::new();
assert!(try_blit_row_8bpp_src_copy_fast(
&mut bus,
&[1, 2, 3, 4, 5, 6, 7, 8],
0,
&pm,
&src_to_dst,
false,
0,
0,
0,
1,
8,
0,
0,
0,
0,
0,
0,
1,
8,
1.0,
1.0,
screen_base,
8,
8,
1,
8,
None,
Some(&clip),
&mut scratch,
));
assert_eq!(
bus.read_bytes(screen_base, 8),
vec![0xEE, 0xEE, 103, 104, 105, 0xEE, 0xEE, 0xEE]
);
}
#[test]
fn eight_bit_src_copy_fast_path_packs_one_bit_destination_rows() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_byte(screen_base, 0xFF);
let pm = PixMapInfo {
row_bytes: 8,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 1,
bounds_right: 8,
pixel_size: 8,
cmp_count: 1,
pack_type: 0,
};
let mut src_to_dst = [0u8; 256];
for (index, slot) in src_to_dst.iter_mut().enumerate() {
*slot = if index % 2 == 0 { 0 } else { 255 };
}
let mut scratch = Vec::new();
assert!(try_blit_row_8bpp_src_copy_fast(
&mut bus,
&[0, 1, 2, 3, 4, 5, 6, 7],
0,
&pm,
&src_to_dst,
false,
0,
0,
0,
1,
8,
0,
0,
0,
0,
0,
0,
1,
8,
1.0,
1.0,
screen_base,
1,
8,
1,
1,
None,
None,
&mut scratch,
));
assert_eq!(bus.read_byte(screen_base), 0b0101_0101);
}
#[test]
fn eight_bit_scaled_blit_fills_every_enlarged_destination_pixel() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[0xEE; 15]);
let pm = PixMapInfo {
row_bytes: 3,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 2,
bounds_right: 3,
pixel_size: 8,
cmp_count: 1,
pack_type: 0,
};
let src_to_dst = std::array::from_fn(|index| index as u8);
let indexed_transfer = std::array::from_fn(|index| PictIndexedTransfer::Write(index as u8));
let device_clut = [[0u16; 3]; 256];
let mut scratch = Vec::new();
for (row, pixels) in [[1, 2, 3], [4, 5, 6]].iter().enumerate() {
blit_row(
&mut bus,
pixels,
0,
&pm,
&device_clut,
&device_clut,
&src_to_dst,
true,
&indexed_transfer,
row as u32,
0,
0,
2,
3,
0,
0,
0,
0,
0,
0,
3,
5,
1.0,
1.0,
screen_base,
5,
5,
3,
8,
0,
0,
None,
None,
&mut scratch,
);
}
assert_eq!(
bus.read_bytes(screen_base, 15),
vec![1, 1, 2, 3, 3, 4, 4, 5, 6, 6, 4, 4, 5, 6, 6]
);
}
fn draw_region_masked_rows(
region: Option<&PictureRegion>,
dst_clip: Option<&DstClip>,
scrn_ps: u16,
) -> Vec<u8> {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_rb = if scrn_ps == 8 { 16 } else { 2 };
bus.write_bytes(screen_base, &[0u8; 16 * 4]);
let pm = PixMapInfo {
row_bytes: 12,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 4,
bounds_right: 12,
pixel_size: 8,
cmp_count: 1,
pack_type: 0,
};
let rows: Vec<Vec<u8>> = (0..4u8)
.map(|y| (0..12u8).map(|x| 1 + y * 12 + x).collect())
.collect();
let src_to_dst = std::array::from_fn(|index| index as u8);
let indexed_transfer = std::array::from_fn(|index| PictIndexedTransfer::Write(index as u8));
let device_clut = [[0u16; 3]; 256];
let mut scratch = Vec::new();
for (row, pixels) in rows.iter().enumerate() {
blit_row(
&mut bus,
pixels,
0,
&pm,
&device_clut,
&device_clut,
&src_to_dst,
true,
&indexed_transfer,
row as u32,
0,
0,
4,
12,
0, 0, 5, 3, 5, 3, 9, 15, 1.0,
1.0,
screen_base,
screen_rb,
16,
4,
scrn_ps,
255,
0,
region,
dst_clip,
&mut scratch,
);
}
bus.read_bytes(screen_base, (screen_rb * 4) as usize)
}
fn expected_region_masked_rows(region: Option<&PictureRegion>) -> Vec<u8> {
let mut expected = vec![0u8; 16 * 4];
for y in 0..4i32 {
for x in 0..12i32 {
let (pic_y, pic_x) = (y + 5, x + 3);
if region.is_some_and(|clip| !clip.contains(pic_y, pic_x)) {
continue;
}
expected[(y * 16 + x) as usize] = 1 + (y * 12 + x) as u8;
}
}
expected
}
#[test]
fn region_masked_8bpp_rows_take_the_span_fast_path_and_match_the_pixel_predicate() {
let notched = PictureRegion {
top: 5,
left: 3,
bottom: 8,
right: 15,
rows: vec![vec![4, 13], vec![4], vec![3, 6, 9]],
};
assert_eq!(
draw_region_masked_rows(Some(¬ched), None, 8),
expected_region_masked_rows(Some(¬ched)),
"notched op region: fast path must match the per-pixel predicate"
);
let boxed = PictureRegion {
top: 6,
left: 5,
bottom: 8,
right: 11,
rows: Vec::new(),
};
assert_eq!(
draw_region_masked_rows(Some(&boxed), None, 8),
expected_region_masked_rows(Some(&boxed))
);
let dst_clip = DstClip::new(
(0, 0, 4, 16),
vec![DstClipRegion::complex(
0,
0,
4,
16,
vec![vec![0, 16], vec![2, 8], vec![0, 16], vec![0, 16]],
)],
);
let both = draw_region_masked_rows(Some(¬ched), Some(&dst_clip), 8);
let mut expected = expected_region_masked_rows(Some(¬ched));
for x in (0..2).chain(8..16) {
expected[16 + x] = 0;
}
assert_eq!(both, expected, "op region and dst_clip must both apply");
assert!(both.iter().any(|&b| b != 0));
assert!(expected_region_masked_rows(None) != expected_region_masked_rows(Some(¬ched)));
}
#[test]
fn region_masked_rows_are_admitted_to_the_row_fast_path() {
let region = PictureRegion {
top: 0,
left: 0,
bottom: 4,
right: 12,
rows: vec![vec![1, 5], vec![0, 12], vec![2, 3], vec![]],
};
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pm = PixMapInfo {
row_bytes: 12,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 4,
bounds_right: 12,
pixel_size: 8,
cmp_count: 1,
pack_type: 0,
};
let src_to_dst = std::array::from_fn(|index| index as u8);
let row = [7u8; 12];
let mut scratch = Vec::new();
let taken = |bus: &mut MacMemoryBus, mode: u16, scale: f64, scratch: &mut Vec<u8>| {
try_blit_row_8bpp_src_copy_fast(
bus,
&row,
mode,
&pm,
&src_to_dst,
true,
1,
0,
0,
4,
12,
0,
0,
0,
0,
0,
0,
4,
12,
scale,
scale,
0x08_0000,
16,
16,
4,
8,
Some(®ion),
None,
scratch,
)
};
assert!(
taken(&mut bus, 0, 1.0, &mut scratch),
"srcCopy + region takes the row path"
);
assert!(
!taken(&mut bus, 1, 1.0, &mut scratch),
"srcOr still goes per-pixel"
);
assert!(
!taken(&mut bus, 0, 2.0, &mut scratch),
"scaling still goes per-pixel"
);
assert_eq!(bus.read_bytes(0x08_0000 + 16, 12), vec![7u8; 12]);
}
#[test]
fn one_bit_screen_region_masked_rows_match_the_pixel_predicate() {
let notched = PictureRegion {
top: 5,
left: 3,
bottom: 9,
right: 15,
rows: vec![vec![4, 13], vec![4], vec![3, 6, 9], vec![]],
};
let bits = draw_region_masked_rows(Some(¬ched), None, 1);
let expected = expected_region_masked_rows(Some(¬ched));
for y in 0..4usize {
for x in 0..16usize {
let bit = (bits[y * 2 + x / 8] >> (7 - (x % 8))) & 1;
let inside = expected[y * 16 + x] != 0;
assert_eq!(
bit == 1,
inside,
"1-bit pixel ({y}, {x}) must follow the region"
);
}
}
}
fn draw_one_bit_source_rows(mode: u16, region: Option<&PictureRegion>) -> Vec<u8> {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[9u8; 24 * 4]);
let pm = PixMapInfo {
row_bytes: 3,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 4,
bounds_right: 20,
pixel_size: 1,
cmp_count: 1,
pack_type: 0,
};
let rows: [[u8; 3]; 4] = [
[0b1010_1100, 0b0011_1100, 0b1111_0000],
[0b0101_0011, 0b1100_0011, 0b0000_1111],
[0b1111_1111, 0b0000_0000, 0b1010_1010],
[0b1000_0001, 0b0111_1110, 0b0101_0101],
];
let src_to_dst = std::array::from_fn(|index| index as u8);
let indexed_transfer = std::array::from_fn(|index| PictIndexedTransfer::Write(index as u8));
let device_clut = [[0u16; 3]; 256];
let mut scratch = Vec::new();
for (row, bits) in rows.iter().enumerate() {
blit_row(
&mut bus,
bits,
mode,
&pm,
&device_clut,
&device_clut,
&src_to_dst,
true,
&indexed_transfer,
row as u32,
0,
0,
4,
20,
0,
0,
5,
3,
5,
3,
9,
23,
1.0,
1.0,
screen_base,
24,
24,
4,
8,
200,
30,
region,
None,
&mut scratch,
);
}
bus.read_bytes(screen_base, 24 * 4)
}
fn expected_one_bit_source_rows(mode: u16, region: Option<&PictureRegion>) -> Vec<u8> {
let rows: [[u8; 3]; 4] = [
[0b1010_1100, 0b0011_1100, 0b1111_0000],
[0b0101_0011, 0b1100_0011, 0b0000_1111],
[0b1111_1111, 0b0000_0000, 0b1010_1010],
[0b1000_0001, 0b0111_1110, 0b0101_0101],
];
let mut screen = vec![9u8; 24 * 4];
for y in 0..4i32 {
for x in 0..20i32 {
let set = rows[y as usize][(x / 8) as usize] & (0x80 >> (x % 8)) != 0;
let index = if set {
200
} else if mode == 0 {
30
} else {
continue;
};
if region.is_some_and(|clip| !clip.contains(y + 5, x + 3)) {
continue;
}
screen[(y * 24 + x) as usize] = index;
}
}
screen
}
#[test]
fn one_bit_srccopy_source_rows_take_the_row_path_and_match_the_pixel_predicate() {
let notched = PictureRegion {
top: 5,
left: 3,
bottom: 9,
right: 23,
rows: vec![vec![4, 21], vec![6], vec![3, 9, 15], vec![]],
};
for region in [None, Some(¬ched)] {
assert_eq!(
draw_one_bit_source_rows(0, region),
expected_one_bit_source_rows(0, region),
"srcCopy 1-bit rows (region {:?}) must match the per-pixel arm",
region.is_some()
);
}
assert_eq!(
draw_one_bit_source_rows(1, Some(¬ched)),
expected_one_bit_source_rows(1, Some(¬ched))
);
let drawn = draw_one_bit_source_rows(0, None);
assert!(drawn.contains(&200) && drawn.contains(&30));
}
#[test]
fn packbits_src_copy_fast_path_decodes_only_visible_mapped_span() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pict_row = 0x04_0000u32;
bus.write_byte(pict_row, 9); bus.write_byte(pict_row + 1, 7); bus.write_bytes(pict_row + 2, &[1, 2, 3, 4, 5, 6, 7, 8]);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[0xEE; 4]);
let pm = PixMapInfo {
row_bytes: 8,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 1,
bounds_right: 8,
pixel_size: 8,
cmp_count: 1,
pack_type: 0,
};
let mut src_to_dst = [0u8; 256];
for (index, slot) in src_to_dst.iter_mut().enumerate() {
*slot = index.wrapping_add(10) as u8;
}
let end = try_blit_packbits_8bpp_src_copy_fast(
&mut bus,
pict_row,
1,
&pm,
0,
&src_to_dst,
false,
0,
0,
1,
8,
0,
-2,
0,
0,
0,
0,
1,
8,
1.0,
1.0,
screen_base,
4,
4,
1,
8,
None,
None,
)
.expect("simple clipped 8bpp PackBits srcCopy should use the direct fast path");
assert_eq!(end, pict_row + 10);
assert_eq!(bus.read_bytes(screen_base, 4), vec![13, 14, 15, 16]);
}
fn write_peekable_indexed_packbits_pict(
bus: &mut MacMemoryBus,
pic: u32,
mode: u16,
leading_fill_rect: bool,
) {
bus.write_word(pic, 0);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 1);
bus.write_word(pic + 8, 2);
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1;
bus.write_byte(p, 0x01);
p += 1;
bus.write_byte(p, 0x0E); p += 1;
bus.write_long(p, 0x0000_00CD);
p += 4;
if leading_fill_rect {
bus.write_byte(p, 0x34);
p += 1;
for value in [0i16, 0, 1, 1] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_byte(p, 0x98); p += 1;
bus.write_word(p, 0x8002); p += 2;
for value in [0i16, 0, 1, 2] {
bus.write_word(p, value as u16);
p += 2;
}
bus.write_word(p, 0); p += 2;
bus.write_word(p, 0); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_word(p, 0); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_word(p, 1); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_word(p, 0x8000); p += 2;
bus.write_word(p, 1); p += 2;
for (index, rgb) in [
(0u16, [0x1111, 0x2222, 0x3333]),
(1u16, [0xAAAA, 0xBBBB, 0xCCCC]),
] {
bus.write_word(p, index);
p += 2;
for component in rgb {
bus.write_word(p, component);
p += 2;
}
}
for _ in 0..2 {
for value in [0i16, 0, 1, 2] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, mode);
p += 2;
bus.write_bytes(p, &[0, 1]);
p += 2;
bus.write_byte(p, 0xFF);
p += 1;
bus.write_word(pic, (p - pic) as u16);
}
#[test]
fn peek_initial_packbits_clut_accepts_simple_first_src_copy_image() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pic = 0x10_0000u32;
write_peekable_indexed_packbits_pict(&mut bus, pic, 0, false);
let clut = peek_initial_packbits_clut(&bus, pic).expect("initial PackBitsRect CLUT");
assert_eq!(clut[0], [0x1111, 0x2222, 0x3333]);
assert_eq!(clut[1], [0xAAAA, 0xBBBB, 0xCCCC]);
}
#[test]
fn peek_initial_packbits_clut_rejects_non_src_copy_images() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pic = 0x10_0000u32;
write_peekable_indexed_packbits_pict(&mut bus, pic, 1, false);
assert!(peek_initial_packbits_clut(&bus, pic).is_none());
}
#[test]
fn peek_initial_packbits_clut_rejects_after_prior_drawing_opcode() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pic = 0x10_0000u32;
write_peekable_indexed_packbits_pict(&mut bus, pic, 0, true);
assert!(peek_initial_packbits_clut(&bus, pic).is_none());
}
#[test]
fn src_copy_transfer_table_is_direct_write_mapping() {
let mut src_to_dst = [0u8; 256];
for (index, slot) in src_to_dst.iter_mut().enumerate() {
*slot = 255u8.saturating_sub(index as u8);
}
let src = [[0u16; 3]; 256];
let dst = [[0u16; 3]; 256];
let table = build_pict_indexed_transfer_table(0, &src, &src_to_dst, &dst, 1, 2);
assert_eq!(table[0], PictIndexedTransfer::Write(255));
assert_eq!(table[42], PictIndexedTransfer::Write(213));
assert_eq!(table[255], PictIndexedTransfer::Write(0));
}
#[test]
fn four_bit_indexed_rows_fill_enlarged_destination_pixels() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[0xEE; 16]);
let pm = PixMapInfo {
row_bytes: 1,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 2,
bounds_right: 2,
pixel_size: 4,
cmp_count: 1,
pack_type: 0,
};
let device_clut = [[0u16; 3]; 256];
let mut src_to_dst = [0u8; 256];
src_to_dst[1] = 10;
src_to_dst[2] = 20;
let transfer = build_pict_indexed_transfer_table(0, &[], &src_to_dst, &device_clut, 0, 0);
let mut scratch = Vec::new();
for (row, packed_pixels) in [(0, 0x12), (1, 0x21)] {
blit_row(
&mut bus,
&[packed_pixels],
0,
&pm,
&device_clut,
&device_clut,
&src_to_dst,
false,
&transfer,
row,
0,
0,
2,
2,
0,
0,
0,
0,
0,
0,
2,
2,
2.0,
2.0,
screen_base,
4,
4,
4,
8,
0,
0,
None,
None,
&mut scratch,
);
}
assert_eq!(
bus.read_bytes(screen_base, 16),
vec![
10, 10, 20, 20, 10, 10, 20, 20, 20, 20, 10, 10, 20, 20, 10, 10,
]
);
}
#[test]
fn indexed_src_copy_preserves_source_colors_on_direct_destinations() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let pm = PixMapInfo {
row_bytes: 1,
bounds_top: 0,
bounds_left: 0,
bounds_bottom: 1,
bounds_right: 1,
pixel_size: 8,
cmp_count: 1,
pack_type: 0,
};
let mut source_clut = vec![[0u16; 3]; 256];
source_clut[5] = [0x7000, 0x8800, 0x9800];
let mut device_clut = [[0u16; 3]; 256];
device_clut[42] = [0xffff, 0, 0];
let mut src_to_dst = [0u8; 256];
src_to_dst[5] = 42;
let transfer =
build_pict_indexed_transfer_table(0, &source_clut, &src_to_dst, &device_clut, 0, 0);
let mut scratch = Vec::new();
blit_row(
&mut bus,
&[5],
0,
&pm,
&source_clut,
&device_clut,
&src_to_dst,
false,
&transfer,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
1,
1,
1.0,
1.0,
screen_base,
2,
1,
1,
16,
0,
0,
None,
None,
&mut scratch,
);
assert_eq!(
bus.read_word(screen_base),
((0x7000u16 >> 11) << 10) | ((0x8800u16 >> 11) << 5) | (0x9800u16 >> 11)
);
}
#[test]
fn packbitsrect_matching_ctseed_still_translates_when_tables_differ() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_row_bytes = 8u32;
bus.write_bytes(screen_base, &[0xEE; 8]);
let mut device_clut = [[0u16; 3]; 256];
device_clut[42] = [0xFFFF, 0, 0];
let pic = 0x10_0000u32;
let mut p = pic;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 1);
p += 2;
bus.write_word(p, 2);
p += 2;
bus.write_byte(p, 0x98); p += 1;
bus.write_word(p, 0x8002); p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 1);
p += 2;
bus.write_word(p, 2);
p += 2;
bus.write_word(p, 0); p += 2;
bus.write_word(p, 0); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_word(p, 0); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_word(p, 1); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 8); p += 4;
bus.write_word(p, 0x8000);
p += 2;
bus.write_word(p, 1); p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 1);
p += 2;
bus.write_word(p, 0xFFFF);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
for _ in 0..2 {
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 1);
p += 2;
bus.write_word(p, 2);
p += 2;
}
bus.write_word(p, 0); p += 2;
bus.write_byte(p, 1);
p += 1;
bus.write_byte(p, 1);
p += 1;
bus.write_byte(p, 0xFF); p += 1;
bus.write_word(pic, (p - pic) as u16);
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
1,
2,
(screen_base, screen_row_bytes, 8, 1, 8),
&device_clut,
8,
None,
);
assert!(ok);
assert_eq!(
bus.read_bytes(screen_base, 2),
vec![42, 42],
"matching ctSeed is not enough for identity mapping when ColorTable contents differ"
);
bus.write_bytes(screen_base, &[0; 8]);
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
1,
2,
(screen_base, screen_row_bytes, 2, 1, 32),
&device_clut,
8,
None,
);
assert!(ok);
assert_eq!(
bus.read_bytes(screen_base, 8),
vec![0, 255, 0, 0, 0, 255, 0, 0]
);
}
#[test]
fn one_bit_packbitsrect_uses_destination_clut_black_and_white() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[0x42; 8]);
let mut clut = [[0x7777u16; 3]; 256];
clut[4] = [0x0000, 0x0000, 0x0000];
clut[7] = [0xFFFF, 0xFFFF, 0xFFFF];
let pic = 0x10_0000u32;
bus.write_word(pic, 42); bus.write_word(pic + 2, 0); bus.write_word(pic + 4, 0); bus.write_word(pic + 6, 1); bus.write_word(pic + 8, 8); let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1;
bus.write_byte(p, 0x01);
p += 1;
bus.write_byte(p, 0x98); p += 1;
bus.write_word(p, 1); p += 2;
for value in [0i16, 0, 1, 8] {
bus.write_word(p, value as u16);
p += 2;
}
for _ in 0..2 {
for value in [0i16, 0, 1, 8] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, 0); p += 2;
bus.write_byte(p, 0b1010_0000);
p += 1;
bus.write_byte(p, 0xFF);
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
1,
8,
(screen_base, 8, 8, 1, 8),
&clut,
0,
None,
);
assert!(ok);
assert_eq!(bus.read_bytes(screen_base, 8), vec![4, 7, 4, 7, 7, 7, 7, 7]);
}
#[test]
fn one_bit_packbitsrect_to_direct_destination_writes_exact_black_and_white() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[0x42; 16]);
let mut clut = [[0x7777u16; 3]; 256];
clut[214] = [0x0000, 0x0000, 0x0000];
clut[7] = [0xFFFF, 0xFFFF, 0xFFFF];
let pic = 0x10_0000u32;
bus.write_word(pic, 42); bus.write_word(pic + 2, 0); bus.write_word(pic + 4, 0); bus.write_word(pic + 6, 1); bus.write_word(pic + 8, 8); let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1;
bus.write_byte(p, 0x01);
p += 1;
bus.write_byte(p, 0x98); p += 1;
bus.write_word(p, 1); p += 2;
for value in [0i16, 0, 1, 8] {
bus.write_word(p, value as u16);
p += 2;
}
for _ in 0..2 {
for value in [0i16, 0, 1, 8] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, 0); p += 2;
bus.write_byte(p, 0b1010_0000);
p += 1;
bus.write_byte(p, 0xFF);
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
1,
8,
(screen_base, 16, 8, 1, 16),
&clut,
0,
None,
);
assert!(ok);
let pixels: Vec<u16> = (0..8).map(|x| bus.read_word(screen_base + x * 2)).collect();
assert_eq!(
pixels,
vec![0x0000, 0x7FFF, 0x0000, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF]
);
}
#[test]
fn eight_bit_packbitsrect_srcor_preserves_white_source_pixels() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_bytes(screen_base, &[42; 16]);
let mut clut = [[0x7777u16; 3]; 256];
clut[0] = [0xFFFF, 0xFFFF, 0xFFFF];
clut[42] = [0x1234, 0x5678, 0x9ABC];
clut[255] = [0x0000, 0x0000, 0x0000];
let pic = 0x10_0000u32;
bus.write_word(pic, 0); bus.write_word(pic + 2, 0); bus.write_word(pic + 4, 0); bus.write_word(pic + 6, 4); bus.write_word(pic + 8, 4); let mut p = pic + 10;
bus.write_byte(p, 0x11); p += 1;
bus.write_byte(p, 0x01); p += 1;
bus.write_byte(p, 0x98); p += 1;
bus.write_word(p, 0x8004); p += 2;
for value in [0i16, 0, 4, 4] {
bus.write_word(p, value as u16);
p += 2;
}
bus.write_word(p, 0); p += 2;
bus.write_word(p, 0); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_word(p, 0); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_word(p, 1); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_word(p, 0x8000); p += 2;
bus.write_word(p, 1); p += 2;
for (value, rgb) in [
(0u16, [0xFFFF, 0xFFFF, 0xFFFF]),
(1u16, [0x0000, 0x0000, 0x0000]),
] {
bus.write_word(p, value);
p += 2;
for component in rgb {
bus.write_word(p, component);
p += 2;
}
}
for _ in 0..2 {
for value in [0i16, 0, 4, 4] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, 1); p += 2;
bus.write_bytes(
p,
&[
1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
],
);
p += 16;
bus.write_byte(p, 0xFF); p += 1;
bus.write_word(pic, (p - pic) as u16);
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
4,
4,
(screen_base, 4, 4, 4, 8),
&clut,
0,
None,
);
assert!(ok);
assert_eq!(
bus.read_bytes(screen_base, 16),
vec![
255, 255, 255, 42, 255, 42, 42, 42, 255, 42, 42, 42, 42, 42, 42, 42,
]
);
}
#[test]
fn indexed_transfer_table_precomputes_srcor_black_white_actions() {
let mut src_clut = [[0u16; 3]; 256];
src_clut[0] = [0xFFFF, 0xFFFF, 0xFFFF];
src_clut[1] = [0x0000, 0x0000, 0x0000];
src_clut[2] = [0x8000, 0x8000, 0x8000];
let mut dst_clut = [[0x7777u16; 3]; 256];
dst_clut[0] = [0xFFFF, 0xFFFF, 0xFFFF];
dst_clut[42] = [0x8000, 0x8000, 0x8000];
dst_clut[255] = [0x0000, 0x0000, 0x0000];
let mut src_to_dst = [0u8; 256];
src_to_dst[0] = 0;
src_to_dst[1] = 255;
src_to_dst[2] = 42;
let table = build_pict_indexed_transfer_table(1, &src_clut, &src_to_dst, &dst_clut, 255, 0);
assert_eq!(table[0], PictIndexedTransfer::Skip);
assert_eq!(table[1], PictIndexedTransfer::Write(255));
assert!(
matches!(table[2], PictIndexedTransfer::Write(_)),
"non-white source colors should be resolved once into the transfer table"
);
}
#[test]
fn indexed_src_copy_ignores_foreground_and_background_colors() {
let mut src_clut = [[0u16; 3]; 256];
src_clut[1] = [0xFFFF, 0x0000, 0x0000];
let mut dst_clut = [[0x7777u16; 3]; 256];
dst_clut[7] = [0x0000, 0xFFFF, 0x0000];
dst_clut[42] = [0xFFFF, 0x0000, 0x0000];
dst_clut[99] = [0x0000, 0x0000, 0xFFFF];
let mut src_to_dst = [0u8; 256];
src_to_dst[1] = 42;
let table = build_pict_indexed_transfer_table(0, &src_clut, &src_to_dst, &dst_clut, 7, 99);
assert_eq!(
table[1],
PictIndexedTransfer::Write(42),
"indexed srcCopy should copy the source ColorTable color, not tint it through fg/bg"
);
}
#[test]
fn color_packbitsrect_to_one_bit_destination_maps_to_black_or_white() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
bus.write_byte(screen_base, 0);
let pic = 0x10_0000u32;
bus.write_word(pic, 0);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 1);
bus.write_word(pic + 8, 3);
let mut p = pic + 10;
bus.write_byte(p, 0x98); p += 1;
bus.write_word(p, 0x8003); p += 2;
for value in [0i16, 0, 1, 3] {
bus.write_word(p, value as u16);
p += 2;
}
bus.write_word(p, 0); p += 2;
bus.write_word(p, 0); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_word(p, 0); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_word(p, 1); p += 2;
bus.write_word(p, 8); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0); p += 4;
bus.write_word(p, 0x8000); p += 2;
bus.write_word(p, 2); p += 2;
for (index, [r, g, b]) in [
(0u16, [0x0000, 0x0000, 0x0000]), (1u16, [0xFFFF, 0xFFFF, 0x0000]), (2u16, [0xFFFF, 0xFFFF, 0xFFFF]), ] {
bus.write_word(p, index);
p += 2;
bus.write_word(p, r);
p += 2;
bus.write_word(p, g);
p += 2;
bus.write_word(p, b);
p += 2;
}
for _ in 0..2 {
for value in [0i16, 0, 1, 3] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, 0); p += 2;
bus.write_byte(p, 0); p += 1;
bus.write_byte(p, 1); p += 1;
bus.write_byte(p, 2); p += 1;
bus.write_byte(p, 0xFF); p += 1;
bus.write_word(pic, (p - pic) as u16);
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
1,
3,
(screen_base, 1, 8, 1, 1),
&clut,
0,
None,
);
assert!(ok);
assert_eq!(
bus.read_byte(screen_base) & 0b1110_0000,
0b1000_0000,
"indexed color PICT pixels drawn into 1bpp must resolve against the black/white destination, not the full 8bpp CLUT"
);
}
#[test]
fn directbitsrect_packtype4_uses_pixmap_rowbytes_for_word_byte_counts() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_w: u16 = 80;
let screen_h: u16 = 2;
let row_bytes = u32::from(screen_w);
bus.write_bytes(
screen_base,
&vec![0xAA; (row_bytes * u32::from(screen_h)) as usize],
);
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1; bus.write_byte(p, 0x02);
p += 1; bus.write_byte(p, 0xFF);
p += 1; bus.write_byte(p, 0x00);
p += 1;
bus.write_word(p, 0x009A);
p += 2; bus.write_long(p, 0x0000_00FF);
p += 4; bus.write_word(p, 0x8000 | 320);
p += 2; for value in [0i16, 0, 1, 80] {
bus.write_word(p, value as u16);
p += 2;
}
bus.write_word(p, 0);
p += 2; bus.write_word(p, 4);
p += 2; bus.write_long(p, 0);
p += 4; bus.write_long(p, 0x0048_0000);
p += 4; bus.write_long(p, 0x0048_0000);
p += 4; bus.write_word(p, 16);
p += 2; bus.write_word(p, 32);
p += 2; bus.write_word(p, 3);
p += 2; bus.write_word(p, 8);
p += 2; bus.write_long(p, 0);
p += 4; bus.write_long(p, 0);
p += 4; bus.write_long(p, 0);
p += 4;
for _ in 0..2 {
for value in [0i16, 0, 1, 80] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, 64);
p += 2;
bus.write_word(p, 6);
p += 2;
for component in [0x12u8, 0x34, 0x56] {
bus.write_byte(p, 0xB1); p += 1;
bus.write_byte(p, component);
p += 1;
}
bus.write_word(p, 0x0034);
p += 2; bus.write_word(p, 1);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 2);
p += 2;
bus.write_word(p, 80);
p += 2;
bus.write_word(p, 0x00FF);
p += 2;
bus.write_word(pic, (p - pic) as u16);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 2);
bus.write_word(pic + 8, 80);
let mut clut = [[0x8000u16, 0x8000, 0x8000]; 256];
clut[0] = [0xFFFF, 0xFFFF, 0xFFFF];
clut[42] = [0x1212, 0x3434, 0x5656];
clut[255] = [0x0000, 0x0000, 0x0000];
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
screen_h as i16,
screen_w as i16,
(screen_base, row_bytes, screen_w, screen_h, 8),
&clut,
0,
None,
);
assert!(ok);
assert_eq!(bus.read_byte(screen_base), 42);
assert_eq!(bus.read_byte(screen_base + row_bytes), 255);
}
#[test]
fn directbitsrect_maps_rgbdirect_colors_into_indexed_and_16bpp_destinations() {
for (pixel_size, expected_indexed) in [(2u16, Some(0x60u8)), (4, Some(0x12)), (16, None)] {
for source_depth in [16u16, 32] {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_word(pic, 0);
for (offset, value) in [(2, 0u16), (4, 0), (6, 1), (8, 2)] {
bus.write_word(pic + offset, value);
}
bus.write_byte(p, 0x11);
p += 1;
bus.write_byte(p, 0x02);
p += 1;
bus.write_byte(p, 0xFF);
p += 1;
bus.write_byte(p, 0);
p += 1;
bus.write_word(p, 0x009A);
p += 2;
bus.write_long(p, 0x0000_00FF);
p += 4;
let row_bytes = if source_depth == 16 { 4 } else { 8 };
bus.write_word(p, 0x8000 | row_bytes);
p += 2;
for value in [0i16, 0, 1, 2] {
bus.write_word(p, value as u16);
p += 2;
}
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 1);
p += 2;
bus.write_long(p, 0);
p += 4;
bus.write_long(p, 0x0048_0000);
p += 4;
bus.write_long(p, 0x0048_0000);
p += 4;
bus.write_word(p, 16);
p += 2;
bus.write_word(p, source_depth);
p += 2;
bus.write_word(p, if source_depth == 32 { 3 } else { 1 });
p += 2;
bus.write_word(p, if source_depth == 32 { 8 } else { 16 });
p += 2;
bus.write_long(p, 0);
p += 4;
bus.write_long(p, 0);
p += 4;
bus.write_long(p, 0);
p += 4;
for _ in 0..2 {
for value in [0i16, 0, 1, 2] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, 0);
p += 2;
let row: &[u8] = if source_depth == 16 {
&[0x7C, 0x00, 0x03, 0xE0]
} else {
&[0xFF, 0, 0, 0xFF, 0, 0, 0, 0]
};
bus.write_bytes(p, row);
p += row.len() as u32;
bus.write_word(p, 0x00FF);
p += 2;
bus.write_word(pic, (p - pic) as u16);
let mut clut = [[0u16; 3]; 256];
clut[0] = [0xFFFF, 0xFFFF, 0xFFFF];
clut[1] = [0xFFFF, 0, 0];
clut[2] = [0, 0xFFFF, 0];
if pixel_size < 8 {
clut[(1usize << pixel_size) - 1] = [0, 0, 0];
}
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
1,
2,
(
screen_base,
if pixel_size == 16 { 4 } else { 1 },
2,
1,
pixel_size,
),
&clut,
0,
None,
);
assert!(ok);
if let Some(expected) = expected_indexed {
assert_eq!(
bus.read_byte(screen_base),
expected,
"{source_depth}-bit DirectBitsRect into {pixel_size}-bit indexed"
);
} else {
assert_eq!(bus.read_word(screen_base), 0x7c00);
assert_eq!(bus.read_word(screen_base + 2), 0x03e0);
}
}
}
}
#[test]
fn pict_fillrect_honors_fillpat_not_pnpat() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_w: u16 = 32;
let screen_h: u16 = 32;
let row_bytes = screen_w as u32;
bus.write_bytes(
screen_base,
&vec![0x42; (row_bytes * screen_h as u32) as usize],
);
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1; bus.write_byte(p, 0x01);
p += 1; bus.write_byte(p, 0x09);
p += 1;
bus.fill_zeros(p, 8);
p += 8;
bus.write_byte(p, 0x0A);
p += 1;
bus.write_bytes(p, &[0xFFu8; 8]);
p += 8;
bus.write_byte(p, 0x34);
p += 1;
bus.write_word(p, 0);
p += 2; bus.write_word(p, 0);
p += 2; bus.write_word(p, 32);
p += 2; bus.write_word(p, 32);
p += 2; bus.write_byte(p, 0xFF);
bus.write_word(pic, (p - pic + 1) as u16); bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 32);
bus.write_word(pic + 8, 32);
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let (_ok, _clut) = draw_picture(
&mut bus,
pic,
0,
0,
32,
32,
(screen_base, row_bytes, screen_w, screen_h, 8),
&clut,
0,
None,
);
let sample = bus.read_byte(screen_base + 8 * row_bytes + 8);
assert_eq!(
sample, 255,
"fillRect must use FillPat (all-0xFF → fg=255), not PnPat \
(all-0x00 → bg=0). Got 0x{:02X}.",
sample,
);
}
#[test]
fn pict_v2_opcolor_advances_to_following_opcode() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_w: u16 = 16;
let screen_h: u16 = 16;
let row_bytes = screen_w as u32;
bus.write_bytes(
screen_base,
&vec![0x42; (row_bytes * screen_h as u32) as usize],
);
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1; bus.write_byte(p, 0x02);
p += 1; bus.write_byte(p, 0xFF);
p += 1; bus.write_byte(p, 0x00);
p += 1; bus.write_word(p, 0x001F);
p += 2; bus.write_word(p, 0x1111);
p += 2;
bus.write_word(p, 0x2222);
p += 2;
bus.write_word(p, 0x3333);
p += 2;
bus.write_word(p, 0x0034);
p += 2; bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 16);
p += 2;
bus.write_word(p, 16);
p += 2;
bus.write_word(p, 0x00FF);
p += 2;
bus.write_word(pic, (p - pic) as u16);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 16);
bus.write_word(pic + 8, 16);
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
16,
16,
(screen_base, row_bytes, screen_w, screen_h, 8),
&clut,
0,
None,
);
assert!(ok, "v2 OpColor should be skipped, not stop the PICT stream");
assert_eq!(bus.read_byte(screen_base + 8 * row_bytes + 8), 255);
}
#[test]
fn pict_v2_rgb_colors_map_foreground_and_background_through_destination_clut() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_w = 4u16;
let screen_h = 4u16;
let row_bytes = u32::from(screen_w);
bus.write_bytes(
screen_base,
&vec![0xEE; (row_bytes * u32::from(screen_h)) as usize],
);
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1; bus.write_byte(p, 0x02);
p += 1; bus.write_byte(p, 0xFF);
p += 1; bus.write_byte(p, 0x00);
p += 1;
bus.write_word(p, 0x001A);
p += 2; for component in [0x1234u16, 0x5678, 0x9ABC] {
bus.write_word(p, component);
p += 2;
}
bus.write_word(p, 0x0034);
p += 2; for value in [0u16, 0, 2, 4] {
bus.write_word(p, value);
p += 2;
}
bus.write_word(p, 0x001B);
p += 2; for component in [0xDEADu16, 0xBEEF, 0x1111] {
bus.write_word(p, component);
p += 2;
}
bus.write_word(p, 0x000A);
p += 2; bus.fill_zeros(p, 8); p += 8;
bus.write_word(p, 0x0034);
p += 2; for value in [2u16, 0, 4, 4] {
bus.write_word(p, value);
p += 2;
}
bus.write_word(p, 0x00FF);
p += 2;
bus.write_word(pic, (p - pic) as u16);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, screen_h);
bus.write_word(pic + 8, screen_w);
let mut clut = [[0x8000u16; 3]; 256];
clut[42] = [0x1234, 0x5678, 0x9ABC];
clut[77] = [0xDEAD, 0xBEEF, 0x1111];
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
screen_h as i16,
screen_w as i16,
(screen_base, row_bytes, screen_w, screen_h, 8),
&clut,
0,
None,
);
assert!(ok);
assert_eq!(bus.read_bytes(screen_base, 8), vec![42; 8]);
assert_eq!(bus.read_bytes(screen_base + 2 * row_bytes, 8), vec![77; 8]);
}
#[test]
fn pict_v1_reserved_shape_opcode_advances_to_following_opcode() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_w: u16 = 16;
let screen_h: u16 = 16;
let row_bytes = screen_w as u32;
bus.write_bytes(
screen_base,
&vec![0x42; (row_bytes * screen_h as u32) as usize],
);
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1; bus.write_byte(p, 0x01);
p += 1; bus.write_byte(p, 0x35);
p += 1; bus.write_bytes(p, &[0xAA; 8]);
p += 8;
bus.write_byte(p, 0x34);
p += 1; bus.write_word(p, 0);
p += 2;
bus.write_word(p, 0);
p += 2;
bus.write_word(p, 16);
p += 2;
bus.write_word(p, 16);
p += 2;
bus.write_byte(p, 0xFF);
p += 1;
bus.write_word(pic, (p - pic) as u16);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 16);
bus.write_word(pic + 8, 16);
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
16,
16,
(screen_base, row_bytes, screen_w, screen_h, 8),
&clut,
0,
None,
);
assert!(
ok,
"v1 reserved shape opcodes should skip their data, not stop the PICT stream"
);
assert_eq!(bus.read_byte(screen_base + 8 * row_bytes + 8), 255);
}
#[test]
fn pict_fillpoly_honors_fillpat_striped_pattern() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_w: u16 = 32;
let screen_h: u16 = 32;
let row_bytes = screen_w as u32;
bus.write_bytes(
screen_base,
&vec![0x42; (row_bytes * screen_h as u32) as usize],
);
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1; bus.write_byte(p, 0x01);
p += 1; bus.write_byte(p, 0x0A);
p += 1;
for row in 0..8 {
bus.write_byte(p, if row % 2 == 0 { 0xFF } else { 0x00 });
p += 1;
}
bus.write_byte(p, 0x74);
p += 1;
let poly_size: u16 = 10 + 4 * 4;
bus.write_word(p, poly_size);
p += 2;
bus.write_word(p, 4);
p += 2; bus.write_word(p, 4);
p += 2; bus.write_word(p, 28);
p += 2; bus.write_word(p, 28);
p += 2; for &(v, h) in &[(4i16, 4i16), (4, 28), (28, 28), (28, 4)] {
bus.write_word(p, v as u16);
p += 2;
bus.write_word(p, h as u16);
p += 2;
}
bus.write_byte(p, 0xFF);
bus.write_word(pic, (p - pic + 1) as u16);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 32);
bus.write_word(pic + 8, 32);
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let _ = draw_picture(
&mut bus,
pic,
0,
0,
32,
32,
(screen_base, row_bytes, screen_w, screen_h, 8),
&clut,
0,
None,
);
let x = 10u32;
let mut saw_fg = false;
let mut saw_bg = false;
for dy in 6..16u32 {
let val = bus.read_byte(screen_base + dy * row_bytes + x);
if val == 255 {
saw_fg = true;
}
if val == 0 {
saw_bg = true;
}
}
assert!(saw_fg, "striped fillPoly must produce some fg_idx pixels");
assert!(saw_bg, "striped fillPoly must produce some bg_idx pixels");
}
#[test]
fn pict_filloval_honors_fillpat_striped_pattern() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let screen_w: u16 = 32;
let screen_h: u16 = 32;
let row_bytes = screen_w as u32;
bus.write_bytes(
screen_base,
&vec![0x42; (row_bytes * screen_h as u32) as usize],
);
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x11);
p += 1;
bus.write_byte(p, 0x01);
p += 1;
bus.write_byte(p, 0x0A);
p += 1;
for row in 0..8 {
bus.write_byte(p, if row % 2 == 0 { 0xFF } else { 0x00 });
p += 1;
}
bus.write_byte(p, 0x54);
p += 1;
bus.write_word(p, 2);
p += 2;
bus.write_word(p, 2);
p += 2;
bus.write_word(p, 30);
p += 2;
bus.write_word(p, 30);
p += 2;
bus.write_byte(p, 0xFF);
bus.write_word(pic, (p - pic + 1) as u16);
bus.write_word(pic + 2, 0);
bus.write_word(pic + 4, 0);
bus.write_word(pic + 6, 32);
bus.write_word(pic + 8, 32);
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let _ = draw_picture(
&mut bus,
pic,
0,
0,
32,
32,
(screen_base, row_bytes, screen_w, screen_h, 8),
&clut,
0,
None,
);
let x = 16u32;
let mut saw_fg = false;
let mut saw_bg = false;
for dy in 6..22u32 {
let val = bus.read_byte(screen_base + dy * row_bytes + x);
if val == 255 {
saw_fg = true;
}
if val == 0 {
saw_bg = true;
}
}
assert!(saw_fg, "striped fillOval must produce some fg_idx pixels");
assert!(saw_bg, "striped fillOval must produce some bg_idx pixels");
}
#[test]
fn pict_bitsrect_decodes_unpacked_four_bit_pixmap() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let screen_base = 0x08_0000u32;
let pic = 0x10_0000u32;
let mut p = pic + 10;
bus.write_byte(p, 0x00); p += 1;
bus.write_byte(p, 0x11); p += 1;
bus.write_byte(p, 0x02);
p += 1;
bus.write_byte(p, 0xFF);
p += 1;
bus.write_word(p, 0x0090); p += 2;
bus.write_word(p, 0x8002); p += 2;
for value in [0i16, 0, 1, 4] {
bus.write_word(p, value as u16);
p += 2;
}
bus.write_word(p, 0); p += 2;
bus.write_word(p, 1); p += 2;
bus.write_long(p, 0); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_long(p, 0x0048_0000); p += 4;
bus.write_word(p, 0); p += 2;
bus.write_word(p, 4); p += 2;
bus.write_word(p, 1); p += 2;
bus.write_word(p, 4); p += 2;
for _ in 0..3 {
bus.write_long(p, 0); p += 4;
}
bus.write_long(p, 0); p += 4;
bus.write_word(p, 0); p += 2;
bus.write_word(p, 1); p += 2;
for (index, component) in [(0u16, 0u16), (1, 0xFFFF)] {
bus.write_word(p, index);
p += 2;
for _ in 0..3 {
bus.write_word(p, component);
p += 2;
}
}
for _ in 0..2 {
for value in [0i16, 0, 1, 4] {
bus.write_word(p, value as u16);
p += 2;
}
}
bus.write_word(p, 0); p += 2;
bus.write_bytes(p, &[0x01, 0x10]);
p += 2;
bus.write_word(p, 0x00FF); p += 2;
bus.write_word(pic, (p - pic) as u16);
for (offset, value) in [(2, 0u16), (4, 0), (6, 1), (8, 4)] {
bus.write_word(pic + offset, value);
}
let mut clut = [[0u16; 3]; 256];
clut[7] = [0xFFFF; 3];
let (ok, _) = draw_picture(
&mut bus,
pic,
0,
0,
1,
4,
(screen_base, 4, 4, 1, 8),
&clut,
0,
None,
);
assert!(ok);
assert_eq!(bus.read_bytes(screen_base, 4), vec![0, 7, 7, 0]);
assert_eq!(
picture_stream_len(&bus.read_bytes(pic, (p - pic) as usize)),
Some((p - pic) as usize)
);
}
#[test]
fn pict_reserved_opcode_length_overflow_stops_without_panicking() {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pic = 0x10_0000u32;
for (offset, value) in [(2, 0u16), (4, 0), (6, 1), (8, 1)] {
bus.write_word(pic + offset, value);
}
let mut p = pic + 10;
bus.write_byte(p, 0x00);
p += 1;
bus.write_byte(p, 0x11);
p += 1;
bus.write_byte(p, 0x02);
p += 1;
bus.write_byte(p, 0xFF);
p += 1;
bus.write_word(p, 0x8100);
p += 2;
bus.write_long(p, u32::MAX);
p += 4;
bus.write_word(pic, (p - pic) as u16);
let clut = [[0u16; 3]; 256];
let result = draw_picture(
&mut bus,
pic,
0,
0,
1,
1,
(0x08_0000, 1, 1, 1, 8),
&clut,
0,
None,
);
assert!(result.0);
}
#[test]
fn recorded_round_rect_honors_ovsize_when_scaled() {
let mut commands = Vec::new();
super::recording_push_round_rect(&mut commands, 0x0041, (0, 0, 40, 40), 10, 10);
let picture = super::finish_recording((0, 0, 40, 40), commands);
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let pic = 0x10_0000;
let screen = 0x08_0000;
bus.write_bytes(pic, &picture);
bus.fill_zeros(screen, 60 * 60);
let mut clut = [[0u16; 3]; 256];
clut[0] = [0xFFFF; 3];
let (drawn, _) = draw_picture(
&mut bus,
pic,
0,
0,
50,
50,
(screen, 60, 60, 60, 8),
&clut,
0,
None,
);
assert!(drawn);
assert_eq!(bus.read_byte(screen + 25 * 60 + 25), 255);
assert_eq!(bus.read_byte(screen), 0);
assert_eq!(bus.read_byte(screen + 60 + 1), 0);
assert_eq!(bus.read_byte(screen + 6 * 60 + 6), 255);
}
#[test]
fn pict_shape_erasure_preserves_background_pattern_bit_colors() {
let rect = [0, 1, 0, 1, 0, 7, 0, 7];
for opcode in [0x32, 0x42, 0x52, 0x62, 0x72, 0x82] {
for pattern in [0x00, 0xAA, 0xFF] {
for swapped in [false, true] {
let mut commands = vec![0x02];
commands.extend_from_slice(&[pattern; 8]);
if swapped {
commands.extend_from_slice(&[0x0E, 0, 0, 0, 30, 0x0F, 0, 0, 0, 33]);
}
commands.push(opcode);
match opcode {
0x72 => {
commands.extend_from_slice(&[0, 30]);
commands.extend_from_slice(&rect);
for point in [
[0, 1, 0, 1],
[0, 1, 0, 7],
[0, 7, 0, 7],
[0, 7, 0, 1],
[0, 1, 0, 1],
] {
commands.extend_from_slice(&point);
}
}
0x82 => {
commands.extend_from_slice(&[0, 10]);
commands.extend_from_slice(&rect);
}
_ => {
commands.extend_from_slice(&rect);
if opcode == 0x62 {
commands.extend_from_slice(&[0, 0, 1, 104]); }
}
}
let picture = finish_v1_picture((0, 0, 8, 8), &commands);
let pixels = render_text_picture(&picture, 8, 8);
let expected = if (pattern & 0x08 != 0) ^ swapped {
255
} else {
0
};
assert_eq!(
pixels[4 * 8 + 4],
expected,
"opcode={opcode:02X}, pattern={pattern:02X}, swapped={swapped}"
);
assert_eq!(pixels[0], 0, "outside shape must remain unchanged");
}
}
}
}
#[test]
fn streamed_picture_requests_stop_at_end_opcode() {
use super::{picture_stream_progress, PictureStreamProgress};
let mut picture = vec![0; 10];
picture.extend_from_slice(&[0x11, 2, 0xff, 0, 0x81, 0]);
picture.extend_from_slice(&70_000u32.to_be_bytes());
picture.extend(std::iter::repeat_n(0xff, 70_000));
picture.extend_from_slice(&[0, 0xff]);
let end = picture.len();
picture.extend_from_slice(&[0xaa; 16]);
let mut available = 10;
let mut requests = 0;
loop {
match picture_stream_progress(&picture[..available]) {
PictureStreamProgress::Need(next) => {
assert!(next > available && next <= end);
available = next;
requests += 1;
assert!(requests < 20, "payload must be requested as a block");
}
PictureStreamProgress::Complete(length) => {
assert_eq!(length, end);
assert_eq!(available, end);
break;
}
PictureStreamProgress::Invalid => panic!("valid streamed picture rejected"),
}
}
assert_eq!(super::picture_stream_len(&picture), Some(end));
assert_eq!(
picture_stream_progress(&[0; 9]),
PictureStreamProgress::Need(10)
);
let mut invalid = vec![0; 10];
invalid.push(0x17); assert_eq!(
picture_stream_progress(&invalid),
PictureStreamProgress::Invalid
);
}
#[test]
fn indexed_bits_region_masks_intersect_picture_clip_at_translated_scaled_destinations() {
for packed in [false, true] {
for scale in [1, 2] {
for mask_kind in 0..3 {
let mut bus = MacMemoryBus::new(2 * 1024 * 1024);
let source = 0x10000;
let screen = 0x80000;
let mut bytes = Vec::new();
for word in [0x8008u16, 0, 0, 2, 8, 0, 0] {
bytes.extend_from_slice(&word.to_be_bytes());
}
for long in [0u32, 0x0048_0000, 0x0048_0000] {
bytes.extend_from_slice(&long.to_be_bytes());
}
for word in [0u16, 8, 1, 8] {
bytes.extend_from_slice(&word.to_be_bytes());
}
bytes.extend_from_slice(&[0; 12]); bytes.extend_from_slice(&1234u32.to_be_bytes());
for word in [
0x8000u16, 1, 0, 0xffff, 0xffff, 0xffff, 1, 0, 0, 0, 0, 0, 2, 8, 0, 0, 2, 8, 0,
] {
bytes.extend_from_slice(&word.to_be_bytes());
}
if mask_kind == 0 {
for word in [
36u16, 0, 1, 2, 7, 0, 1, 3, 5, 7, 0x7fff, 2, 1, 3, 5, 7, 0x7fff, 0x7fff,
] {
bytes.extend_from_slice(&word.to_be_bytes());
}
} else if mask_kind == 1 {
for word in [10u16, 0, 0, 0, 0] {
bytes.extend_from_slice(&word.to_be_bytes());
}
}
for _ in 0..2 {
if packed {
bytes.extend_from_slice(&[2, 249, 1]); } else {
bytes.extend_from_slice(&[1; 8]);
}
}
bus.write_bytes(source, &bytes);
bus.write_bytes(screen, &[42; 32 * 16]);
let clip = PictureRegion {
top: 0,
left: 2,
bottom: 2,
right: 6,
rows: Vec::new(),
};
let clut = crate::trap::TrapDispatcher::standard_mac_8bpp_clut();
let (end, _) = super::parse_indexed_bits_rect(
&mut bus,
source,
mask_kind != 2,
packed,
2,
3,
0,
0,
f64::from(scale),
f64::from(scale),
(screen, 32, 32, 16, 8),
&clut,
0,
255,
0,
Some(&clip),
None,
);
assert_eq!(end, source + bytes.len() as u32);
for y in 0..16 {
for x in 0..32 {
let in_rows = y >= 2 && y < 2 + 2 * scale;
let in_columns = if mask_kind == 0 {
(x >= 3 + 2 * scale && x < 3 + 3 * scale)
|| (x >= 3 + 5 * scale && x < 3 + 6 * scale)
} else {
mask_kind == 2 && x >= 3 + 2 * scale && x < 3 + 6 * scale
};
let expected = if in_rows && in_columns { 255 } else { 42 };
assert_eq!(
bus.read_byte(screen + (y * 32 + x) as u32),
expected,
"packed={packed} scale={scale} mask={mask_kind} x={x} y={y}"
);
}
}
}
}
}
}
#[test]
fn callback_commands_preserve_v1_order_and_reject_partial_streams() {
let data = [
0, 0, 0, 0, 0, 0, 0, 8, 0, 8, 0x11, 1, 0xa0, 0, 150, 0x28, 0, 2, 0, 3, 3, b'a', b'b', b'c', 0xa0, 0, 151, 0x31, 0, 1, 0, 2, 0, 6, 0, 7, 0xff,
];
let commands = super::picture_commands(&data).unwrap();
assert_eq!(
commands
.iter()
.map(|command| command.opcode)
.collect::<Vec<_>>(),
[0x11, 0xa0, 0x28, 0xa0, 0x31, 0xff]
);
assert_eq!(commands[2].data, [0, 2, 0, 3, 3, b'a', b'b', b'c']);
assert_eq!(commands[4].data, [0, 1, 0, 2, 0, 6, 0, 7]);
for end in 0..data.len() {
assert!(super::picture_commands(&data[..end]).is_none(), "end={end}");
}
}
#[test]
fn callback_commands_validate_v2_comment_padding_and_following_shapes() {
let mut data = vec![0, 0, 0, 0, 0, 0, 0, 8, 0, 8, 0x11, 2, 0xff, 0];
data.extend_from_slice(&[0, 0xa1, 0, 150, 0, 3, 1, 2, 3, 0]);
data.extend_from_slice(&[0, 0x31, 0, 1, 0, 2, 0, 6, 0, 7, 0, 0xff]);
let commands = super::picture_commands(&data).unwrap();
assert_eq!(commands[1].opcode, 0xa1);
assert_eq!(commands[1].data, [0, 150, 0, 3, 1, 2, 3, 0]);
assert_eq!(commands[2].opcode, 0x31);
assert_eq!(commands[2].data, [0, 1, 0, 2, 0, 6, 0, 7]);
}