use std::fs; use std::path::Path; use std::time::{Duration, Instant}; use prometeu_bytecode::assembler::assemble; use prometeu_bytecode::model::{BytecodeModule, DebugInfo, Export, FunctionMeta, SyscallDecl}; use prometeu_hal::color::Color; use prometeu_host_headless::{CapturedFrame, HeadlessHost, HostState}; use prometeu_system::CrashReport; const RED: u32 = Color::RED.raw(); const BLUE: u32 = Color::BLUE.raw(); #[test] fn step_does_not_complete_a_logical_frame() { let mut host = boot_color(); let before = host.get_state().frame_index; host.step(); assert_eq!(host.get_state().frame_index, before); } #[test] fn clear_input_drops_right() { let mut host = boot_color(); host.set_right(true); host.clear_input(); host.advance_frame().expect("frame"); assert_color(&host.capture_frame().expect("frame"), BLUE); } #[test] fn right_hold_then_release_changes_pixels() { let mut host = boot_color(); let before = host.get_state().frame_index; host.set_right(true); host.advance_frames(60).expect("hold"); let held = host.capture_frame().expect("held frame"); assert_eq!(host.get_state().frame_index, before + 60); assert_color(&held, RED); assert!(host.get_fault().is_none()); host.set_right(false); host.advance_frames(1).expect("release"); let released = host.capture_frame().expect("released frame"); assert_eq!(released.logical_frame_index, before + 61); assert_color(&released, BLUE); assert!(host.get_fault().is_none()); } #[test] fn two_runs_match_oracle() { let first = run_color_sequence(); let second = run_color_sequence(); assert_eq!(first.held.logical_frame_index, second.held.logical_frame_index); assert_eq!(first.held.frame.pixels, second.held.frame.pixels); assert_eq!(first.held.frame.frame_id, second.held.frame.frame_id); assert_eq!(first.released.frame.pixels, second.released.frame.pixels); assert_eq!(first.released.frame.frame_id, second.released.frame.frame_id); assert_eq!(first.released.logical_frame_index, second.released.logical_frame_index); assert_same_state(&first.state, &second.state); assert_eq!(first.fault, second.fault); } #[test] fn reset_matches_fresh_host() { let mut host = boot_color(); let _ = run_on(&mut host); host.reset(); host.boot(color_cartridge()).expect("reboot"); let after_reset = run_on(&mut host); let fresh = run_color_sequence(); assert_eq!(after_reset.held.frame.pixels, fresh.held.frame.pixels); assert_eq!(after_reset.released.frame.pixels, fresh.released.frame.pixels); assert_eq!(after_reset.held.frame.frame_id, fresh.held.frame.frame_id); assert_eq!(after_reset.released.frame.frame_id, fresh.released.frame.frame_id); assert_eq!(after_reset.released.logical_frame_index, fresh.released.logical_frame_index); assert_same_state(&after_reset.state, &fresh.state); assert_eq!(after_reset.fault, fresh.fault); } #[test] fn trap_is_structured() { let dir = temp_cart("fault"); write_cartridge(&dir, 42, "Fault", &fault_program(), &[]); let mut host = HeadlessHost::new(); host.boot(&dir).expect("boot fault cartridge"); host.advance_frame().expect("faulting frame"); match host.get_fault() { Some(report @ CrashReport::VmTrap { .. }) => { assert!(report.pc().is_some()); } other => panic!("expected VmTrap, got {other:?}"), } } #[test] fn three_hundred_frames_finish_without_refresh_sleep() { let mut host = boot_color(); let started = Instant::now(); host.advance_frames(300).expect("fast frames"); assert!(started.elapsed() < Duration::from_secs(2)); } #[test] fn audio_play_does_not_need_a_device() { let mut host = boot_color(); host.advance_frame().expect("frame with audio.play"); assert!(host.get_fault().is_none()); assert_color(&host.capture_frame().expect("frame"), BLUE); } struct ColorOracle { held: CapturedFrame, released: CapturedFrame, state: HostState, fault: Option, } fn boot_color() -> HeadlessHost { let mut host = HeadlessHost::new(); host.boot(color_cartridge()).expect("boot color cartridge"); host } fn color_cartridge() -> String { let dir = temp_cart("color"); write_cartridge(&dir, 41, "Right Pixel", &color_program(), &color_syscalls()); dir } fn run_color_sequence() -> ColorOracle { let mut host = boot_color(); run_on(&mut host) } fn run_on(host: &mut HeadlessHost) -> ColorOracle { host.set_right(true); host.advance_frames(60).expect("hold"); let held = host.capture_frame().expect("held"); host.set_right(false); host.advance_frames(1).expect("release"); let released = host.capture_frame().expect("released"); let state = host.get_state(); let fault = host.get_fault(); ColorOracle { held, released, state, fault } } fn assert_color(captured: &CapturedFrame, color: u32) { assert_eq!(captured.frame.width, 480); assert_eq!(captured.frame.height, 270); assert!(captured.frame.pixels.iter().all(|pixel| *pixel == color)); } fn assert_same_state(left: &HostState, right: &HostState) { assert_eq!(left.pc, right.pc); assert_eq!(left.frame_index, right.frame_index); assert_eq!(left.app_id, right.app_id); assert_eq!(format!("{:?}", left.stack_top), format!("{:?}", right.stack_top)); } fn temp_cart(name: &str) -> String { let dir = std::env::temp_dir().join(format!( "prometeu-headless-{name}-{}-{}", std::process::id(), std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() )); fs::create_dir_all(&dir).expect("temp cartridge dir"); dir.to_string_lossy().into_owned() } fn write_cartridge(dir: &str, app_id: u32, title: &str, program: &[u8], syscalls: &[SyscallDecl]) { let path = Path::new(dir); fs::write(path.join("program.pbx"), program).expect("program"); fs::write( path.join("manifest.json"), format!( "{{\n \"magic\": \"PMTU\",\n \"cartridge_version\": 1,\n \"app_id\": {app_id},\n \"title\": \"{title}\",\n \"app_version\": \"0.1.0\",\n \"app_mode\": \"Game\",\n \"capabilities\": [\"gfx2d\", \"audio\"]\n}}\n" ), ) .expect("manifest"); let _ = syscalls; } fn color_program() -> Vec { let mut rom = Vec::new(); rom.extend(asm("PUSH_I32 0\n\ PUSH_I32 0\n\ PUSH_I32 0\n\ PUSH_I32 255\n\ PUSH_I32 128\n\ PUSH_I32 1\n\ PUSH_I32 0\n\ HOSTCALL 1\n\ POP_N 1\n\ INTRINSIC 0x2000\n\ INTRINSIC 0x2013\n\ INTRINSIC 0x2032\n")); let jump_to_blue = rom.len() + 2; rom.extend(asm("JMP_IF_FALSE 0")); rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n"))); let blue_at = rom.len() as u32; rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n"))); rom[jump_to_blue..jump_to_blue + 4].copy_from_slice(&blue_at.to_le_bytes()); module(rom, color_syscalls()) } fn fault_program() -> Vec { // `INTRINSIC 0xDEADBEEF` is rejected by the loader as `VerificationFailed`. // `TRAP` is a legal instruction that becomes `CrashReport::VmTrap` at runtime. module(asm("TRAP\nFRAME_SYNC\nRET\n"), vec![]) } fn color_syscalls() -> Vec { vec![ SyscallDecl { module: "gfx2d".into(), name: "clear".into(), version: 1, arg_slots: 1, ret_slots: 0, }, SyscallDecl { module: "audio".into(), name: "play".into(), version: 1, arg_slots: 7, ret_slots: 1, }, ] } fn module(code: Vec, syscalls: Vec) -> Vec { BytecodeModule { version: 0, const_pool: vec![], functions: vec![FunctionMeta { code_offset: 0, code_len: code.len() as u32, param_slots: 0, local_slots: 0, return_slots: 0, max_stack_slots: 8, }], code, debug_info: Some(DebugInfo { pc_to_span: vec![], function_names: vec![(0, "main".into())], }), exports: vec![Export { symbol: "main".into(), func_idx: 0 }], syscalls, } .serialize() } fn asm(source: &str) -> Vec { assemble(source).expect("assemble") }