mod support; use pbxgen_stress::{Preset, DEFAULT_SEED}; use support::*; #[test] fn presets_replay_native_state_without_churn_or_sprite_overflow() { for preset in [Preset::Light, Preset::Normal, Preset::Heavy] { let mut a = vm(preset, DEFAULT_SEED); let mut b = vm(preset, DEFAULT_SEED); let mut other = vm(preset, DEFAULT_SEED + 1); let mut na = Workload::default(); let mut nb = Workload::default(); let mut no = Workload::default(); let mut previous = vec![]; for f in 1..=6 { let cycles = frame(&mut a, &mut na); assert_eq!(cycles, frame(&mut b, &mut nb)); frame(&mut other, &mut no); let state = particle_bits(&a); assert_eq!(state, particle_bits(&b)); assert_ne!(state, particle_bits(&other)); assert_ne!(state, previous); previous = state; assert_eq!(previous.len(), preset.particles() as usize * 6); assert_eq!(a.heap().len(), preset.particles() as usize + 2); assert_eq!(na.submitted, f * (preset.particles() as usize + 128)); assert_eq!(na.sprites.sprite_count(), preset.particles() as usize + 128); assert_eq!(na.sprites.dropped_sprites(), 0); assert_eq!(na.errors, 0); } assert_eq!(na.binds, 1); assert_eq!(na.plays, 1); assert_eq!(na.camera, 6); assert_eq!(na.text, 24); let expected = match preset { Preset::Light => 0xa0277985ff4cefcd, Preset::Normal => 0x3a9cf871667c92ee, Preset::Heavy => 0x57257956419e88d2, }; assert_eq!(hash(&previous), expected, "guest numeric replay changed"); println!("replay={} hash={:016x}", preset.name(), hash(&previous)); } } #[test] fn actual_intrinsic_execution_and_particle_rebirth() { use prometeu_bytecode::{ decode_next, isa::core::CoreOpCode, load_limits::LoadBudget, registry_codec::PbxEnvelope, }; use prometeu_hal::HostContext; use prometeu_vm::LogicalFrameEndingReason as End; use std::collections::BTreeMap; let bytes = pbxgen_stress::build_program_with(Preset::Light, 42); let mut budget = LoadBudget::new(Default::default()); let envelope = PbxEnvelope::parse(&bytes, &mut budget).unwrap(); let section = envelope.section(2).unwrap(); let code = section.bytes; let mut sites = BTreeMap::new(); let mut pc = 0; while pc < code.len() { let i = decode_next(pc, code).unwrap(); if i.opcode == CoreOpCode::Intrinsic { sites.insert(pc, i.imm_u32().unwrap()); } pc = i.next_pc; } let mut v = vm(Preset::Light, 42); for &pc in sites.keys() { v.insert_breakpoint(pc); } let mut n = Workload::default(); v.prepare_boot_call().unwrap(); let mut calls = BTreeMap::::new(); loop { if let Some(&id) = sites.get(&v.pc()) { *calls.entry(id).or_default() += 1; v.step(&mut n, &mut HostContext::new(None)).unwrap(); continue; } let r = v.run_budget(250_000, &mut n, &mut HostContext::new(None)).unwrap(); match r.reason { End::Breakpoint | End::BudgetExhausted => {} End::EndOfRom => break, x => panic!("{x:?}"), } } println!("executed_intrinsic_calls={calls:?}"); for (owner, name, min) in [ ("random", "new", 1), ("random", "nextf", 256), ("random", "range", 64), ("random", "next", 64), ("mathf", "sin", 192), ("mathf", "cos", 192), ("mathf", "atan2", 64), ("mathf", "sqrt", 64), ("mathf", "clamp", 256), ("vec2", "dot", 64), ("vec2", "length", 64), ] { let id = prometeu_vm::lookup_intrinsic(owner, name, 1).unwrap().id; assert!(calls.get(&id).copied().unwrap_or(0) >= min, "{owner}.{name}: {calls:?}"); } for pc in sites.keys() { v.remove_breakpoint(*pc); } // Every initial lifetime is <225 frames: all particles must eventually be reborn. for _ in 1..230 { frame(&mut v, &mut n); } let lifetimes: Vec<_> = particle_bits(&v).as_chunks::<6>().0.iter().map(|s| s[4]).collect(); assert!(lifetimes.iter().all(|&life| (1..225).contains(&life))); assert_eq!(v.heap().len(), 66); assert_eq!(n.plays, 1); assert_eq!(n.errors, 0); } #[test] fn sprite_overflow_is_a_separate_bounded_controller_case() { let mut n = Workload::default(); let mut v = vm(Preset::Heavy, 42); frame(&mut v, &mut n); let sprite = prometeu_hal::sprite::Sprite { glyph: prometeu_hal::glyph::Glyph { glyph_id: 0, palette_id: 8 }, x: 0, y: 0, layer: 3, bank_id: 0, active: false, flip_x: false, flip_y: false, priority: 3, }; for _ in n.sprites.sprite_count()..512 { assert!(n.sprites.emit_sprite(sprite)); } assert!(!n.sprites.emit_sprite(sprite)); assert_eq!(n.sprites.sprite_count(), 512); assert_eq!(n.sprites.dropped_sprites(), 1); } #[test] fn guest_reports_a_failed_submission_instead_of_discarding_status() { let mut v = vm(Preset::Light, 42); let mut n = Workload { reject_first_sprite: true, ..Default::default() }; frame(&mut v, &mut n); assert_eq!(n.errors, 1); frame(&mut v, &mut n); assert_eq!(n.errors, 1, "frame status must reset after the failed frame"); } #[test] fn faster_travel_changes_actual_guest_positions() { use prometeu_bytecode::{ decode_next, isa::core::CoreOpCode, load_limits::LoadBudget, registry_codec::PbxEnvelope, }; use prometeu_hal::HostContext; use prometeu_vm::LogicalFrameEndingReason as End; let bytes = pbxgen_stress::build_program_with(Preset::Light, DEFAULT_SEED); let mut budget = LoadBudget::new(Default::default()); let envelope = PbxEnvelope::parse(&bytes, &mut budget).unwrap(); let code = envelope.section(2).unwrap().bytes; let mut pc = 0; let before_update = loop { let op = decode_next(pc, code).unwrap(); if op.opcode == CoreOpCode::Hostcall && op.imm_u32().unwrap() == 2 { break pc; } pc = op.next_pc; }; let mut v = vm(Preset::Light, DEFAULT_SEED); let mut n = Workload::default(); v.insert_breakpoint(before_update); v.prepare_boot_call().unwrap(); assert_eq!( v.run_budget(1_000_000, &mut n, &mut HostContext::new(None)).unwrap().reason, End::Breakpoint ); let initial = particle_bits(&v); v.remove_breakpoint(before_update); assert_eq!( v.run_budget(1_000_000, &mut n, &mut HostContext::new(None)).unwrap().reason, End::EndOfRom ); let updated = particle_bits(&v); assert_eq!(initial.len(), updated.len()); for (before, after) in initial.as_chunks::<6>().0.iter().zip(updated.as_chunks::<6>().0) { for (position, velocity) in [(0, 2), (1, 3)] { let old = f64::from_bits(before[position]); let speed = f64::from_bits(after[velocity]); let actual = f64::from_bits(after[position]); assert!( (actual - (old + 1.5 * speed)).abs() < 1e-10, "light preset has one pass: position must advance by 1.5 times velocity" ); } } }