systemless 0.95.2

High-Level Emulation for classic Macintosh applications
Documentation
use super::*;
use crate::machine_profile::{POWERPC_CARBON_VERSION_BCD, REFERENCE_POWERPC_CPU_CLOCK_HZ};

#[test]
fn new_gestalt_value_registers_selector_and_rejects_duplicates() {
    let pef = synthetic_pef_with_import(b"NewGestaltValue");
    let mut loaded = load_pef_application(&pef).unwrap();
    let selector = u32::from_be_bytes(*b"HEAP");
    let value = 0x1234_5678;
    assert_eq!(
        loaded.imports[0].dispatcher_target,
        PpcImportDispatcherTarget::NewGestaltValue
    );

    loaded.cpu.gpr[3] = selector;
    loaded.cpu.gpr[4] = value;
    run_test_import(&mut loaded, PpcImportDispatcherTarget::NewGestaltValue);
    assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));

    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 4]);
    loaded.cpu.gpr[3] = selector;
    loaded.cpu.gpr[4] = response_ptr;
    run_test_import(&mut loaded, PpcImportDispatcherTarget::Gestalt);
    assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
    assert_eq!(loaded.memory.read_u32_be(response_ptr), Some(value));

    loaded.cpu.gpr[3] = selector;
    loaded.cpu.gpr[4] = 1;
    run_test_import(&mut loaded, PpcImportDispatcherTarget::NewGestaltValue);
    assert_eq!(
        loaded.cpu.gpr[3],
        ppc_i16_result(PPC_GESTALT_DUP_SELECTOR_ERR)
    );

    loaded.cpu.gpr[3] = u32::from_be_bytes(*b"sysv");
    run_test_import(&mut loaded, PpcImportDispatcherTarget::NewGestaltValue);
    assert_eq!(
        loaded.cpu.gpr[3],
        ppc_i16_result(PPC_GESTALT_DUP_SELECTOR_ERR)
    );

    loaded.cpu.gpr[3] = selector;
    loaded.cpu.gpr[4] = response_ptr;
    run_test_import(&mut loaded, PpcImportDispatcherTarget::Gestalt);
    assert_eq!(loaded.memory.read_u32_be(response_ptr), Some(value));
}

#[test]
fn gestalt_keyboard_type_is_builtin_extended_adb_keyboard() {
    let mut loaded = load_pef_application(&synthetic_pef_with_import(b"Gestalt")).unwrap();
    let selector = u32::from_be_bytes(*b"kbd ");
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0xaa; 4]);

    loaded.cpu.gpr[3] = selector;
    loaded.cpu.gpr[4] = response_ptr;
    run_test_import(&mut loaded, PpcImportDispatcherTarget::Gestalt);
    assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
    assert_eq!(loaded.memory.read_u32_be(response_ptr), Some(4));

    loaded.cpu.gpr[3] = selector;
    loaded.cpu.gpr[4] = 9;
    run_test_import(&mut loaded, PpcImportDispatcherTarget::NewGestaltValue);
    assert_eq!(
        loaded.cpu.gpr[3],
        ppc_i16_result(PPC_GESTALT_DUP_SELECTOR_ERR)
    );

    loaded.cpu.gpr[3] = selector;
    loaded.cpu.gpr[4] = response_ptr;
    run_test_import(&mut loaded, PpcImportDispatcherTarget::Gestalt);
    assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
    assert_eq!(loaded.memory.read_u32_be(response_ptr), Some(4));
}

#[test]
fn fresh_powerpc_keyboard_type_is_a_physical_type_byte() {
    let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
    assert_eq!(loaded.memory.read_u8(0x021e), Some(2));
    assert_eq!(loaded.memory.read_u8(0x021d), Some(0));
    assert_eq!(loaded.memory.read_u8(0x021f), Some(0));
}

#[test]
fn gestalt_logical_ram_matches_physical_ram_without_virtual_memory() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    loaded.toolbox_startup.physical_ram_size = 256 * 1024 * 1024;
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 4]);

    for selector in [*b"ram ", *b"lram"] {
        loaded.cpu.pc = loaded.entry_pc;
        loaded.cpu.lr = PPC_HALT_PC;
        loaded.cpu.gpr[3] = u32::from_be_bytes(selector);
        loaded.cpu.gpr[4] = response_ptr;
        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(response_ptr),
            Some(256 * 1024 * 1024)
        );
    }
}

#[test]
fn gestalt_appearance_version_matches_advertised_manager() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 4]);

    for (selector, expected) in [
        (*b"appr", 1),
        (
            *b"apvr",
            u32::from(crate::machine_profile::APPEARANCE_MANAGER_VERSION_BCD),
        ),
    ] {
        loaded.cpu.pc = loaded.entry_pc;
        loaded.cpu.lr = PPC_HALT_PC;
        loaded.cpu.gpr[3] = u32::from_be_bytes(selector);
        loaded.cpu.gpr[4] = response_ptr;
        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(response_ptr), Some(expected));
    }
}

#[test]
fn gestalt_quicktime_matches_reference_extension_version() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 4]);
    loaded.cpu.gpr[3] = u32::from_be_bytes(*b"qtim");
    loaded.cpu.gpr[4] = response_ptr;

    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(response_ptr), Some(0x0403_8000));
}

#[test]
fn gestalt_reports_powerpc_quicktime_library() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 4]);
    loaded.cpu.gpr[3] = u32::from_be_bytes(*b"qtrs");
    loaded.cpu.gpr[4] = response_ptr;

    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(response_ptr), Some(1));
}

#[test]
fn hle_import_runner_handles_gestalt_powerpc_capabilities() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 16]);

    for (selector, expected_error, expected_response) in [
        (*b"sysv", PPC_NO_ERR, u32::from(POWERPC_SYSTEM_VERSION_BCD)),
        (*b"cbon", PPC_NO_ERR, u32::from(POWERPC_CARBON_VERSION_BCD)),
        (*b"cput", PPC_NO_ERR, 0x0104),
        (*b"cpuf", PPC_NO_ERR, 0x0104),
        (*b"pclk", PPC_NO_ERR, REFERENCE_POWERPC_CPU_CLOCK_HZ),
        (*b"proc", PPC_NO_ERR, 3),
        (
            *b"mach",
            PPC_NO_ERR,
            u32::from(crate::machine_profile::POWERPC_GESTALT_MACHINE_TYPE),
        ),
        (
            *b"hdwr",
            PPC_NO_ERR,
            (1 << 0) | (1 << 1) | (1 << 4) | (1 << 19) | (1 << 21) | (1 << 22),
        ),
        (*b"ppcf", PPC_NO_ERR, 0),
        (*b"fpu ", PPC_NO_ERR, 3),
        (*b"mmu ", PPC_NO_ERR, 4),
        (*b"sysa", PPC_NO_ERR, 2),
    ] {
        loaded.cpu.gpr[3] = u32::from_be_bytes(selector);
        loaded.cpu.gpr[4] = response_ptr;
        run_test_import(&mut loaded, PpcImportDispatcherTarget::Gestalt);

        assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(expected_error));
        assert_eq!(
            loaded.memory.read_u32_be(response_ptr),
            Some(expected_response)
        );
    }
    assert_eq!(REFERENCE_MACHINE_PROFILE.system_version_bcd, 0x0810);
}

#[test]
fn hle_import_runner_handles_gestalt_cfm_present() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 16]);
    loaded.cpu.gpr[3] = u32::from_be_bytes(*b"cfrg");
    loaded.cpu.gpr[4] = response_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(response_ptr), Some(1));
}

#[test]
fn hle_import_runner_reports_powerpc_threads_library() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 4]);
    loaded.cpu.gpr[3] = u32::from_be_bytes(*b"thds");
    loaded.cpu.gpr[4] = response_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(response_ptr), Some(0b101));
}

#[test]
fn hle_import_runner_reports_system7_color_quickdraw_13() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 16]);
    loaded.cpu.gpr[3] = u32::from_be_bytes(*b"qd  ");
    loaded.cpu.gpr[4] = response_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(response_ptr), Some(0x0230));
}

#[test]
fn hle_import_runner_handles_gestalt_qd3d_present_and_version() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 16]);

    for (selector, expected_response) in [(*b"qd3d", 1), (*b"q3v ", PPC_QD3D_VERSION)] {
        loaded.cpu.pc = loaded.entry_pc;
        loaded.cpu.lr = PPC_HALT_PC;
        loaded.memory.write_u32_be(response_ptr, 0).unwrap();
        loaded.cpu.gpr[3] = u32::from_be_bytes(selector);
        loaded.cpu.gpr[4] = response_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(response_ptr),
            Some(expected_response)
        );
    }
}

#[test]
fn hle_import_runner_reports_unknown_gestalt_selector() {
    let pef = synthetic_pef_with_import(b"Gestalt");
    let mut loaded = load_pef_application(&pef).unwrap();
    let response_ptr = PPC_HEAP_BASE;
    loaded.memory.add_region(response_ptr, vec![0; 16]);
    loaded
        .memory
        .write_u32_be(response_ptr, 0xfeed_face)
        .unwrap();
    loaded.cpu.gpr[3] = u32::from_be_bytes(*b"zzzz");
    loaded.cpu.gpr[4] = response_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_GESTALT_UNDEF_SELECTOR_ERR)
    );
    assert_eq!(loaded.memory.read_u32_be(response_ptr), Some(0));
}

#[test]
fn hle_import_runner_handles_sys_environs() {
    let pef = synthetic_pef_with_import(b"SysEnvirons");
    let mut loaded = load_pef_application(&pef).unwrap();
    let sys_env_ptr = PPC_DATA_BASE + 0x1000;
    loaded.memory.add_region(sys_env_ptr - 1, vec![0xaa; 18]);
    loaded.cpu.gpr[3] = 2;
    loaded.cpu.gpr[4] = sys_env_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_u16_be(sys_env_ptr), Some(2));
    assert_eq!(
        loaded.memory.read_u16_be(sys_env_ptr + 2),
        Some(crate::machine_profile::POWERPC_GESTALT_MACHINE_TYPE)
    );
    assert_eq!(
        loaded.memory.read_u16_be(sys_env_ptr + 4),
        Some(POWERPC_SYSTEM_VERSION_BCD)
    );
    assert_eq!(
        loaded.memory.read_u16_be(sys_env_ptr + 6),
        Some(REFERENCE_MACHINE_PROFILE.gestalt_processor_type as u16)
    );
    assert_eq!(
        loaded.memory.read_u8(sys_env_ptr + 8),
        Some(u8::from(REFERENCE_MACHINE_PROFILE.has_fpu()))
    );
    assert_eq!(loaded.memory.read_u8(sys_env_ptr + 9), Some(1));
    assert_eq!(loaded.memory.read_u16_be(sys_env_ptr + 10), Some(4)); // envAExtendKbd
    assert_eq!(loaded.memory.read_u16_be(sys_env_ptr + 12), Some(0));
    assert_eq!(loaded.memory.read_u16_be(sys_env_ptr + 14), Some(0));
    assert_eq!(loaded.memory.read_u8(sys_env_ptr - 1), Some(0xaa));
    assert_eq!(loaded.memory.read_u8(sys_env_ptr + 16), Some(0xaa));

    loaded.cpu.pc = loaded.entry_pc;
    loaded.cpu.lr = PPC_HALT_PC;
    loaded.cpu.gpr[4] = 0x30;

    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] as i32, i32::from(PPC_PARAM_ERR));
}