#[path = "support/identity.rs"] mod support; use prometeu_bytecode::{Value, model::ConstantPoolEntry as K}; use prometeu_vm::{HostContext, LogicalFrameEndingReason as End}; use support::*; #[test] fn scalar_pbx_execution_matches_independent_c_reference_vectors() { let mut count = 0; for row in include_str!("fixtures/hash-conformance.tsv").lines().skip(1) { let fields: Vec<_> = row.split('\t').collect(); let expected = u64::from_str_radix(fields[2], 16).unwrap() as i64; let (value, id, bytes) = match fields[0] { "i64" => (K::Int64(fields[1].parse().unwrap()), 0x4100, 0), "float" => { (K::Float64(f64::from_bits(u64::from_str_radix(fields[1], 16).unwrap())), 0x4101, 0) } "string" => { let bytes = hex_bytes(fields[1]); let size = bytes.len(); (K::String(String::from_utf8(bytes).unwrap()), 0x4102, size) } "null" => (K::Null, 0x4102, 0), _ => continue, }; let source = format!("PUSH_CONST 0\nINTRINSIC {id}\nRET"); let mut vm = vm(&[(&source, sig(&[], &[0]))], &[value]); step(&mut vm).unwrap(); let report = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap(); assert_eq!(report.reason, End::BudgetExhausted); assert_eq!(report.cycles_used, 8 + bytes as u64, "{row}"); assert_eq!(&*vm.operand_stack_top(1), &[Value::Int64(expected)], "{row}"); assert_eq!(run(&mut vm).reason, End::EndOfRom); count += 1; } assert_eq!(count, 31); } #[test] fn identities_survive_mutation_and_views_validate_implementation_zero() { let source = "STRUCT_NEW 5\nSET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_HASH 5\nSET_LOCAL 1\nGET_LOCAL 0\nPUSH_I64 73\nSTRUCT_SET type=5,field=0\nGET_LOCAL 0\nREF_IDENTITY_HASH 5\nGET_LOCAL 1\nEQ\nGET_LOCAL 0\nREF_TO_TRAIT source=5,target=7\nREF_IDENTITY_HASH 7\nGET_LOCAL 1\nEQ\nGET_LOCAL 0\nREF_TO_TRAIT source=5,target=7\nGET_LOCAL 0\nREF_TO_TRAIT source=5,target=8\nREF_IDENTITY_EQ left=7,right=8\nGET_LOCAL 0\nSTRUCT_NEW 5\nREF_IDENTITY_EQ left=5,right=5\nRET"; let mut vm = vm(&[(source, sig(&[], &[2, 2, 2, 2]))], &[]); assert_eq!(run(&mut vm).reason, End::EndOfRom); assert_eq!( &*vm.operand_stack_top(4), &[Value::Boolean(false), Value::Boolean(true), Value::Boolean(true), Value::Boolean(true)] ); } #[test] fn array_closure_and_random_have_instance_identity() { for (source, bodies) in [ ( "PUSH_I64 1\nARRAY_NEW 6\nSET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_HASH 6\nSET_LOCAL 1\nGET_LOCAL 0\nPUSH_I64 0\nPUSH_I64 42\nARRAY_SET 6\nGET_LOCAL 0\nREF_IDENTITY_HASH 6\nGET_LOCAL 1\nEQ\nRET", false, ), ( "PUSH_I64 42\nINTRINSIC 0x4000\nSET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_HASH 10\nSET_LOCAL 1\nGET_LOCAL 0\nINTRINSIC 0x4001\nPOP\nGET_LOCAL 0\nREF_IDENTITY_HASH 10\nGET_LOCAL 1\nEQ\nRET", false, ), ( "MAKE_CLOSURE fn=1,type=9\nSET_LOCAL 0\nGET_LOCAL 0\nGET_LOCAL 0\nREF_IDENTITY_EQ left=9,right=9\nGET_LOCAL 0\nMAKE_CLOSURE fn=1,type=9\nREF_IDENTITY_EQ left=9,right=9\nNOT\nAND\nRET", true, ), ] { let mut functions = vec![(source, sig(&[], &[2]))]; if bodies { functions.push(("RET", sig(&[], &[]))); } let mut vm = vm(&functions, &[]); assert_eq!(run(&mut vm).reason, End::EndOfRom); assert_eq!(&*vm.operand_stack_top(1), &[Value::Boolean(true)]); } } #[test] fn canonical_null_groups_compare_and_hash_without_instance_faults() { let source = "PUSH_CONST 0\nPUSH_CONST 0\nREF_IDENTITY_HASH 7\nPUSH_CONST 0\nPUSH_CONST 0\nPUSH_CONST 0\nREF_IDENTITY_EQ left=6,right=7\nRET"; let mut vm = vm(&[(source, sig(&[], &[0, 2]))], &[K::Null]); assert_eq!(run(&mut vm).reason, End::EndOfRom); assert_eq!(&*vm.operand_stack_top(2), &[Value::Boolean(true), Value::Int64(0)]); } #[test] fn admission_rejects_ineligible_sources_and_bad_native_ids_even_when_dead() { for instruction in [ "REF_IDENTITY_HASH 0", "REF_IDENTITY_HASH 3", "REF_IDENTITY_HASH 4", "REF_IDENTITY_HASH 12", "REF_IDENTITY_HASH 13", "REF_IDENTITY_HASH 14", "REF_IDENTITY_HASH 9999", "REF_IDENTITY_EQ left=5,right=3", "INTRINSIC 0x41FF", ] { let text = format!("HALT\n{instruction}"); assert!(image(&[(&text, sig(&[], &[]))], &[]).is_err(), "{instruction}"); } assert!(image(&[("PUSH_CONST 0\nINTRINSIC 0x4102\nRET", sig(&[], &[0]))], &[K::Null]).is_ok()); for id in [0x1103, 0x4100, 0x4101] { let text = format!("PUSH_CONST 0\nINTRINSIC {id}\nPOP\nRET"); assert!(image(&[(&text, sig(&[], &[]))], &[K::Null]).is_err(), "{id}"); } assert!(image(&[("PUSH_I64 3\nREF_IDENTITY_HASH 5\nRET", sig(&[], &[0]))], &[]).is_err()); } #[test] fn whole_instruction_budget_admission_preserves_zero_and_overshoot() { let mut vm = vm( &[("PUSH_CONST 0\nINTRINSIC 0x4102\nRET", sig(&[], &[0]))], &[K::String("x".repeat(65))], ); step(&mut vm).unwrap(); let before = vm.pc(); let zero = vm.run_budget(0, &mut Native, &mut HostContext::new(None)).unwrap(); assert_eq!(zero.cycles_used, 0); assert_eq!(vm.pc(), before); let one = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap(); assert_eq!(one.reason, End::BudgetExhausted); assert_eq!(one.cycles_used, 73); assert_eq!(one.steps_executed, 1); } #[test] fn every_eligible_absence_has_zero_hash_and_exact_identity_instruction_cost() { for (ty, width) in [(5, 1), (6, 1), (7, 2), (9, 1), (10, 1)] { let source = format!("{}REF_IDENTITY_HASH {ty}\nRET", "PUSH_CONST 0\n".repeat(width)); let mut vm = vm(&[(&source, sig(&[], &[0]))], &[K::Null]); for _ in 0..width { step(&mut vm).unwrap(); } let before = vm.pc(); let zero = vm.run_budget(0, &mut Native, &mut HostContext::new(None)).unwrap(); assert_eq!((zero.cycles_used, zero.steps_executed), (0, 0)); assert_eq!(vm.pc(), before); let one = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap(); assert_eq!((one.cycles_used, one.steps_executed), (8 + width as u64, 1)); assert_eq!(&*vm.operand_stack_top(1), &[Value::Int64(0)]); } for source in [ "PUSH_CONST 0\nSTRUCT_NEW 5\nREF_IDENTITY_EQ left=6,right=5\nRET", "STRUCT_NEW 5\nSTRUCT_NEW 11\nREF_IDENTITY_EQ left=5,right=11\nRET", ] { let mut vm = vm(&[(source, sig(&[], &[2]))], &[K::Null]); step(&mut vm).unwrap(); step(&mut vm).unwrap(); let one = vm.run_budget(1, &mut Native, &mut HostContext::new(None)).unwrap(); assert_eq!((one.cycles_used, one.steps_executed), (6, 1)); assert_eq!(&*vm.operand_stack_top(1), &[Value::Boolean(false)]); } }