mod support { pub mod random; } use prometeu_bytecode::registry::{BuiltinId, Ownership, TypeId}; use prometeu_bytecode::{ TRAP_NULL_REFERENCE, TRAP_NUMERIC_DOMAIN, TRAP_RESOURCE_LIMIT, TRAP_TYPE, Value, }; use prometeu_vm::resource_budget::{RuntimeLimits, RuntimeResource as Q}; use prometeu_vm::{ IntrinsicCostModel, IntrinsicImplementation, LogicalFrameEndingReason as End, VirtualMachine, VmInitError, lookup_builtin_type, lookup_intrinsic_by_id, }; use support::random::*; fn trap(r: &prometeu_vm::BudgetReport) -> &prometeu_bytecode::TrapInfo { let End::Trap(t) = &r.reason else { panic!("{r:?}") }; t } fn vectors(seed: i64) -> Vec<(u64, i64, u64)> { include_str!("fixtures/random-conformance.tsv") .lines() .skip(1) .filter_map(|l| { let cols: Vec<_> = l.split('\t').collect(); (cols[0].parse::().unwrap() == seed).then(|| { ( u64::from_str_radix(cols[2], 16).unwrap(), cols[3].parse().unwrap(), u64::from_str_radix(cols[4], 16).unwrap(), ) }) }) .collect() } #[test] fn independent_words_signed_and_float_bits_for_all_seed_patterns() { for seed in [0, 1, 42, -1, i64::MIN, i64::MAX] { for floating in [false, true] { let mut code = format!("PUSH_I64 {seed}\nINTRINSIC 16384\nSET_LOCAL 0\n"); for _ in 0..8 { code.push_str(if floating { "GET_LOCAL 0\nINTRINSIC 16386\n" } else { "GET_LOCAL 0\nINTRINSIC 16385\n" }); } code.push_str("RET"); let mut v = vm(&[(&code, sig(&[], &[if floating { 2 } else { 0 }; 8]), vec![], 1)]); let r = run(&mut v, 10000); assert_eq!(r.reason, End::EndOfRom); let expected: Vec<_> = vectors(seed) .iter() .rev() .map(|(_, signed, bits)| { if floating { Value::Float(f64::from_bits(*bits)) } else { Value::Int64(*signed) } }) .collect(); assert_eq!(v.operand_stack_top(8), expected, "seed={seed}, Float={floating}"); } } } #[test] fn interleaving_unit_range_aliases_and_equal_seed_independent_objects() { let mut v = vm(&[( "PUSH_I64 42\nINTRINSIC 16384\nDUP\nSET_LOCAL 0\nSET_GLOBAL 0\nPUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 1\nGET_LOCAL 0\nINTRINSIC 16385\nGET_GLOBAL 0\nINTRINSIC 16386\nGET_LOCAL 0\nPUSH_I64 -7\nPUSH_I64 -6\nINTRINSIC 16387\nGET_LOCAL 0\nINTRINSIC 16385\nGET_LOCAL 1\nINTRINSIC 16385\nRET", sig(&[], &[0, 2, 0, 0, 0]), vec![], 2, )]); assert_eq!(run(&mut v, 1000).reason, End::EndOfRom); let x = vectors(42); assert_eq!( v.operand_stack_top(5), vec![ Value::Int64(x[0].1), Value::Int64(x[3].1), Value::Int64(-7), Value::Float(f64::from_bits(x[1].2)), Value::Int64(x[0].1) ] ); assert_eq!(v.heap().len(), 2); } #[test] fn range_all_int64_spans_and_power_of_two_consumption() { for (min, max) in [(0, 1), (-10, -3), (-10, 10), (0, 16), (i64::MIN, 0), (-1, i64::MAX), (i64::MIN, i64::MAX)] { let code = format!( "PUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 0\nGET_LOCAL 0\nPUSH_I64 {min}\nPUSH_I64 {max}\nINTRINSIC 16387\nGET_LOCAL 0\nINTRINSIC 16385\nRET" ); let mut v = vm(&[(&code, sig(&[], &[0, 0]), vec![], 1)]); assert_eq!(run(&mut v, 1000).reason, End::EndOfRom); let span = (i128::from(max) - i128::from(min)) as u64; let first = vectors(42)[0].0; // This fixed first word is accepted for all these spans, including > i64 MAX. let expected = (i128::from(min) + i128::from(first % span)) as i64; assert_eq!( v.operand_stack_top(2), vec![Value::Int64(vectors(42)[1].1), Value::Int64(expected)] ); } } #[test] fn random_storage_dynamic_and_capture_preserve_shared_identity() { let body = "PUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 0\nSTRUCT_NEW 4\nDUP\nGET_LOCAL 0\nSTRUCT_SET type=4,field=0\nSET_LOCAL 1\nPUSH_I64 1\nARRAY_NEW 5\nDUP\nPUSH_I64 0\nGET_LOCAL 0\nARRAY_SET 5\nSET_LOCAL 2\nGET_LOCAL 0\nDYN_PACK 1\nDYN_UNPACK 1\nINTRINSIC 16385\nGET_LOCAL 1\nSTRUCT_GET type=4,field=0\nINTRINSIC 16385\nGET_LOCAL 2\nPUSH_I64 0\nARRAY_GET 5\nINTRINSIC 16385\nGET_LOCAL 0\nMAKE_CLOSURE fn=1,type=6\nCALL_CLOSURE 6\nRET"; let mut v = vm(&[ (body, sig(&[], &[0; 4]), vec![], 3), ("GET_CAPTURE 0\nINTRINSIC 16385\nRET", sig(&[], &[0]), vec![TypeId(1)], 0), ]); assert_eq!(run(&mut v, 2000).reason, End::EndOfRom); assert_eq!( v.operand_stack_top(4), vectors(42)[..4].iter().rev().map(|x| Value::Int64(x.1)).collect::>() ); // generator + Struct + Array + Closure; no Dynamic box for one-slot Random. assert_eq!(v.heap().allocation_count(), 4); } #[test] fn random_parameter_result_and_typed_null_have_exact_dynamic_type() { let mut v = vm(&[ ("PUSH_I64 42\nINTRINSIC 16384\nCALL 1\nINTRINSIC 16385\nRET", sig(&[], &[0]), vec![], 0), ("GET_LOCAL 0\nRET", sig(&[1], &[1]), vec![], 0), ]); assert_eq!(run(&mut v, 1000).reason, End::EndOfRom); assert_eq!(v.operand_stack_top(1), vec![Value::Int64(vectors(42)[0].1)]); let mut v = vm(&[("GET_LOCAL 0\nDYN_PACK 1\nDYN_UNPACK 1\nRET", sig(&[], &[1]), vec![], 1)]); assert_eq!(run(&mut v, 1000).reason, End::EndOfRom); assert_eq!(v.operand_stack_top(1), vec![Value::Null]); let mut v = vm(&[("GET_LOCAL 0\nDYN_PACK 1\nDYN_UNPACK 7\nRET", sig(&[], &[7]), vec![], 1)]); let r = run(&mut v, 1000); assert_eq!(trap(&r).code, TRAP_TYPE); } #[test] fn all_random_attempts_charge_before_validation_and_budget_overshoot() { for (id, cost) in [(16384, 32), (16385, 8), (16386, 12), (16387, 12)] { let body = if id == 16384 { "PUSH_I64 42\nINTRINSIC 16384\nPOP\nRET".into() } else { format!( "PUSH_I64 42\nINTRINSIC 16384\n{}INTRINSIC {id}\nPOP\nRET", if id == 16387 { "PUSH_I64 5\nPUSH_I64 6\n" } else { "" } ) }; let mut v = vm(&[(&body, sig(&[], &[]), vec![], 0)]); for _ in 0..if id == 16384 { 1 } else if id == 16387 { 4 } else { 2 } { step(&mut v); } let before = (v.pc(), v.operand_stack_top(10).to_vec(), v.heap().allocation_count()); let zero = run(&mut v, 0); assert_eq!((zero.cycles_used, zero.steps_executed), (0, 0)); assert_eq!((v.pc(), v.operand_stack_top(10).to_vec(), v.heap().allocation_count()), before); let one = run(&mut v, 1); assert_eq!((one.cycles_used, one.steps_executed), (cost, 1)); assert_eq!(one.reason, End::BudgetExhausted); } } #[test] fn range_domain_fault_preserves_operands_and_shared_stream() { for (min, max) in [(1, 1), (2, 1)] { let code = format!( "PUSH_I64 42\nINTRINSIC 16384\nDUP\nSET_GLOBAL 0\nPUSH_I64 {min}\nPUSH_I64 {max}\nINTRINSIC 16387\nRET" ); let mut v = vm(&[(&code, sig(&[], &[0]), vec![], 0)]); for _ in 0..6 { step(&mut v); } let args = v.operand_stack_top(3).to_vec(); let r = run(&mut v, 1); assert_eq!(trap(&r).code, TRAP_NUMERIC_DOMAIN); assert_eq!((r.cycles_used, r.steps_executed), (4, 0)); assert_eq!(v.operand_stack_top(3), args); } } #[test] fn quota_refusal_new_preserves_seed_and_publishes_no_handle() { let image = image(&[("PUSH_I64 42\nINTRINSIC 16384\nPOP\nRET", sig(&[], &[]), vec![], 0)]).unwrap(); for resource in [Q::GuestBytes, Q::HandleSlots, Q::TemporaryBytes] { let mut v = VirtualMachine::from_image( image.clone(), RuntimeLimits::default().lowered(resource, 0).unwrap(), ); v.prepare_boot_call().unwrap(); step(&mut v); let r = run(&mut v, 1); assert_eq!(trap(&r).code, TRAP_RESOURCE_LIMIT); assert_eq!(trap(&r).resource.as_ref().unwrap().resource, resource); assert_eq!((r.cycles_used, r.steps_executed), (32, 0)); assert_eq!(v.operand_stack_top(1), vec![Value::Int64(42)]); assert_eq!(v.heap().allocation_count(), 0); } } #[test] fn unknown_analysis_checks_null_receiver_at_runtime() { let mut v = vm(&[( "GET_LOCAL 0\nSET_GLOBAL 0\nGET_GLOBAL 0\nINTRINSIC 16385\nRET", sig(&[], &[0]), vec![], 1, )]); for _ in 0..3 { step(&mut v); } let r = run(&mut v, 1); assert_eq!(trap(&r).code, TRAP_NULL_REFERENCE); assert_eq!((r.cycles_used, r.steps_executed), (8, 0)); assert_eq!(v.operand_stack_top(1), vec![Value::Null]); } #[test] fn loader_rejects_unknown_unreachable_ids_and_new_random_construction() { for code in ["RET\nINTRINSIC 16388", "STRUCT_NEW 1\nRET", "PUSH_I32 42\nINTRINSIC 16384\nRET"] { let err = image(&[(code, sig(&[], &[]), vec![], 0)]).unwrap_err(); let VmInitError::RegistryLoadFailed(failure) = err else { panic!("{err:?}") }; if code.contains("16388") { assert_eq!(failure.code, prometeu_bytecode::load_limits::LoadCode::InvalidCode); assert_eq!(failure.reason, prometeu_bytecode::load_limits::LoadReason::NativeId); } } } #[test] fn catalog_reference_layout_effects_and_cost_models_are_exact() { let b = lookup_builtin_type("Random", 1).unwrap(); assert_eq!(b.id, 0x16); assert!(b.fields.is_empty()); let l = BuiltinId::RANDOM.layout().unwrap(); assert_eq!((l.size, l.alignment, l.slots, l.ownership), (8, 8, 1, Ownership::GuestReference)); assert_eq!(l.default_values(), &[Value::Null]); for (id, name, cost, slots) in [ (0x4000, "new", 32, 1), (0x4001, "next", 8, 1), (0x4002, "nextf", 12, 1), (0x4003, "range", 4, 3), ] { let m = lookup_intrinsic_by_id(id).unwrap(); assert_eq!( (m.owner, m.name, m.version, m.cost_cycles, m.arg_slots(), m.ret_slots()), ("random", name, 1, cost, slots, 1) ); assert!(m.deterministic && m.mutates_guest_state); assert_eq!(m.may_allocate, id == 0x4000); assert!(matches!(m.implementation, IntrinsicImplementation::VmOwned)); assert!(m.implementation.host_callback().is_none()); assert_eq!( (m.cost_model, m.attempt_cost_cycles, m.max_attempts), if id == 0x4003 { (IntrinsicCostModel::RandomRejectionV1, 8, 64) } else { (IntrinsicCostModel::Fixed, 0, 0) } ); } assert_eq!(lookup_intrinsic_by_id(0x4003).unwrap().parameter_names, &["rng", "min", "max"]); for m in prometeu_vm::intrinsic_catalog().filter(|m| m.id < 0x4000) { assert!(!m.mutates_guest_state); assert_eq!( (m.cost_model, m.attempt_cost_cycles, m.max_attempts), (IntrinsicCostModel::Fixed, 0, 0) ); } } #[test] fn real_pcg_rejection_consumes_two_words_and_one_instruction() { let mut v = vm(&[( "PUSH_I64 42\nINTRINSIC 16384\nSET_LOCAL 0\nGET_LOCAL 0\nINTRINSIC 16385\nSET_LOCAL 1\nGET_LOCAL 0\nPUSH_I64 -9223372036854775808\nPUSH_I64 1\nINTRINSIC 16387\nGET_LOCAL 0\nINTRINSIC 16385\nRET", sig(&[], &[0, 0]), vec![], 2, )]); for _ in 0..9 { step(&mut v); } let r = run(&mut v, 1); assert_eq!((r.cycles_used, r.steps_executed, r.reason), (20, 1, End::BudgetExhausted)); assert_eq!(run(&mut v, 1000).reason, End::EndOfRom); let x = vectors(42); let expected = (i128::from(i64::MIN) + i128::from(x[2].0 % ((1u64 << 63) + 1))) as i64; assert_eq!(v.operand_stack_top(2), vec![Value::Int64(x[3].1), Value::Int64(expected)]); } #[test] fn published_emission_example_matches_bits_consumption_and_total_cycles() { let doc = include_str!("../../../../docs/vm-arch/random-producer-handoff.md"); let code = doc.split("```text\n").nth(1).unwrap().split("```").next().unwrap(); let mut v = vm(&[(code, sig(&[], &[0, 2, 0]), vec![], 1)]); let r = run(&mut v, 1000); assert_eq!(r.reason, End::EndOfRom); assert_eq!(r.cycles_used, 82); assert_eq!( v.operand_stack_top(3), vec![ Value::Int64(-7), Value::Float(f64::from_bits(0x3fb3_04aa_46c9_8538)), Value::Int64(0x86b1_da1d_7206_2b68u64 as i64) ] ); }