232 lines
8.7 KiB
Rust
232 lines
8.7 KiB
Rust
//! Independent catalogue and execution oracles for the fixed input ABI.
|
|
use prometeu_bytecode::{TRAP_INVALID_INTRINSIC, TRAP_UNAVAILABLE, Value, assembler::assemble};
|
|
use prometeu_drivers::TestPlatform;
|
|
use prometeu_hal::{InputSignals, RuntimePlatform, vm_fault::VmFault};
|
|
use prometeu_vm::{
|
|
AbiType, BuiltinScalarType, HostContext, HostReturn, IntrinsicExecutionError,
|
|
LogicalFrameEndingReason, NativeInterface, VirtualMachine, lookup_builtin_type,
|
|
lookup_intrinsic, lookup_intrinsic_by_id,
|
|
};
|
|
|
|
const BUTTONS: [(&str, u32); 13] = [
|
|
("input.pad.up", 0x2100),
|
|
("input.pad.down", 0x2104),
|
|
("input.pad.left", 0x2108),
|
|
("input.pad.right", 0x210C),
|
|
("input.pad.a", 0x2110),
|
|
("input.pad.b", 0x2114),
|
|
("input.pad.x", 0x2118),
|
|
("input.pad.y", 0x211C),
|
|
("input.pad.l", 0x2120),
|
|
("input.pad.r", 0x2124),
|
|
("input.pad.start", 0x2128),
|
|
("input.pad.select", 0x212C),
|
|
("input.touch.button", 0x2130),
|
|
];
|
|
|
|
struct NoSyscalls;
|
|
impl NativeInterface for NoSyscalls {
|
|
fn syscall(
|
|
&mut self,
|
|
_: u32,
|
|
_: &[Value],
|
|
_: &mut HostReturn,
|
|
_: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
panic!("input must not invoke a syscall")
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn catalogue_has_exact_names_ids_signatures_and_no_endpoint_aliases() {
|
|
let mut ids = std::collections::BTreeSet::new();
|
|
for (owner, base) in BUTTONS {
|
|
for (offset, property) in ["pressed", "released", "down", "hold"].into_iter().enumerate() {
|
|
let meta = lookup_intrinsic(owner, property, 1).unwrap();
|
|
assert_eq!(meta.id, base + offset as u32);
|
|
assert!(ids.insert(meta.id));
|
|
assert_eq!(lookup_intrinsic_by_id(meta.id).unwrap().key(), meta.key());
|
|
assert!(meta.arg_layout.is_empty());
|
|
assert_eq!(
|
|
meta.ret_layout,
|
|
&[AbiType::Scalar(if offset == 3 {
|
|
BuiltinScalarType::Int64
|
|
} else {
|
|
BuiltinScalarType::Bool
|
|
})]
|
|
);
|
|
assert!(meta.deterministic);
|
|
assert!(!meta.may_allocate);
|
|
assert!(lookup_intrinsic(owner, property, 2).is_none());
|
|
}
|
|
}
|
|
for (name, id) in [("x", 0x2134), ("y", 0x2135)] {
|
|
let meta = lookup_intrinsic("input.touch", name, 1).unwrap();
|
|
assert_eq!(meta.id, id);
|
|
assert!(ids.insert(id));
|
|
assert!(meta.arg_layout.is_empty());
|
|
assert_eq!(meta.ret_layout, &[AbiType::Scalar(BuiltinScalarType::Int64)]);
|
|
}
|
|
assert_eq!(ids.len(), 54);
|
|
assert!(lookup_intrinsic_by_id(0x2136).is_none());
|
|
for id in [0x2000, 0x2001]
|
|
.into_iter()
|
|
.chain(0x2010..=0x201B)
|
|
.chain(0x2020..=0x2022)
|
|
.chain(0x2030..=0x2033)
|
|
{
|
|
assert!(lookup_intrinsic_by_id(id).is_none(), "removed ID {id:#x}");
|
|
}
|
|
for name in ["input.pad", "input.touch", "input.button", "input.touch.button"] {
|
|
assert!(lookup_builtin_type(name, 1).is_none());
|
|
}
|
|
for (owner, name) in [
|
|
("input", "pad"),
|
|
("input", "touch"),
|
|
("input.pad", "up"),
|
|
("input.touch", "button"),
|
|
("input.button", "down"),
|
|
] {
|
|
assert!(lookup_intrinsic(owner, name, 1).is_none());
|
|
}
|
|
let csv = include_str!("../../../../docs/vm-arch/INTRINSICS.csv");
|
|
let mut documented = std::collections::BTreeSet::new();
|
|
for row in csv.lines().skip(1) {
|
|
let columns: Vec<_> = row.split(',').collect();
|
|
if !columns[2].starts_with("input.") {
|
|
continue;
|
|
}
|
|
let id = columns[1].parse::<u32>().unwrap();
|
|
let meta = lookup_intrinsic(columns[4], columns[5], 1).unwrap();
|
|
assert_eq!(id, meta.id);
|
|
assert_eq!(columns[2], format!("{}.{}", meta.owner, meta.name));
|
|
assert_eq!(&columns[6..9], &["0", "1", ""]);
|
|
assert_eq!(
|
|
columns[9],
|
|
if meta.name == "hold" || meta.owner == "input.touch" { "Int64" } else { "Bool" }
|
|
);
|
|
assert!(documented.insert(id));
|
|
}
|
|
assert_eq!(ids, documented);
|
|
}
|
|
|
|
fn set_frame(platform: &mut TestPlatform, active: Option<usize>) {
|
|
let mut signals = InputSignals { x_pos: -123, y_pos: i32::MAX, ..Default::default() };
|
|
if let Some(index) = active {
|
|
let fields = [
|
|
&mut signals.up_signal,
|
|
&mut signals.down_signal,
|
|
&mut signals.left_signal,
|
|
&mut signals.right_signal,
|
|
&mut signals.a_signal,
|
|
&mut signals.b_signal,
|
|
&mut signals.x_signal,
|
|
&mut signals.y_signal,
|
|
&mut signals.l_signal,
|
|
&mut signals.r_signal,
|
|
&mut signals.start_signal,
|
|
&mut signals.select_signal,
|
|
&mut signals.f_signal,
|
|
];
|
|
*fields[index] = true;
|
|
}
|
|
platform.input_mut().pad_mut().begin_frame(&signals);
|
|
platform.input_mut().touch_mut().begin_frame(&signals);
|
|
}
|
|
|
|
fn query_all(platform: &mut TestPlatform) -> Vec<Value> {
|
|
let mut ctx = HostContext::new(Some(platform));
|
|
(0x2100..=0x2135)
|
|
.map(|id| {
|
|
let meta = lookup_intrinsic_by_id(id).unwrap();
|
|
let result = (meta.implementation)(&[], &mut ctx).unwrap();
|
|
meta.validate_result_values(&result).unwrap();
|
|
result.into_iter().next().unwrap()
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn every_button_uses_its_own_snapshot_and_queries_do_not_advance_frames() {
|
|
let mut platform = TestPlatform::new();
|
|
for active in 0..13 {
|
|
set_frame(&mut platform, None);
|
|
for (pressed, released, down, hold) in [
|
|
(true, false, true, 1),
|
|
(false, false, true, 2),
|
|
(false, true, false, 0),
|
|
(false, false, false, 0),
|
|
] {
|
|
set_frame(&mut platform, down.then_some(active));
|
|
let result = query_all(&mut platform);
|
|
assert_eq!(query_all(&mut platform), result, "same-frame queries changed state");
|
|
for index in 0..13 {
|
|
let values = if index == active {
|
|
(pressed, released, down, hold)
|
|
} else {
|
|
(false, false, false, 0)
|
|
};
|
|
assert_eq!(
|
|
&result[index * 4..index * 4 + 4],
|
|
&[
|
|
Value::Boolean(values.0),
|
|
Value::Boolean(values.1),
|
|
Value::Boolean(values.2),
|
|
Value::Int64(values.3),
|
|
],
|
|
"button {index}, active {active}"
|
|
);
|
|
}
|
|
assert_eq!(&result[52..], &[Value::Int64(-123), Value::Int64(i32::MAX as i64)]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn vm_queries_charge_one_cycle_each_and_allocate_no_guest_objects() {
|
|
let mut source = String::new();
|
|
for id in 0x2100..=0x2135 {
|
|
source.push_str(&format!("INTRINSIC {id}\n"));
|
|
}
|
|
let mut vm = VirtualMachine::new(assemble(&source).unwrap(), vec![]);
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let objects = vm.heap().len();
|
|
let mut platform = TestPlatform::new();
|
|
set_frame(&mut platform, Some(3));
|
|
let expected = query_all(&mut platform);
|
|
let report =
|
|
vm.run_budget(54, &mut NoSyscalls, &mut HostContext::new(Some(&mut platform))).unwrap();
|
|
assert_eq!(report.cycles_used, 54);
|
|
assert_eq!(report.steps_executed, 54);
|
|
assert_eq!(vm.heap().len(), objects);
|
|
// Inspection returns the topmost slot first.
|
|
assert_eq!(vm.operand_stack_top(54), expected.into_iter().rev().collect::<Vec<_>>());
|
|
}
|
|
|
|
#[test]
|
|
fn every_known_query_faults_when_unavailable_and_rejects_arguments() {
|
|
for id in 0x2100..=0x2135 {
|
|
let meta = lookup_intrinsic_by_id(id).unwrap();
|
|
let mut ctx = HostContext::new(None);
|
|
assert_eq!(
|
|
(meta.implementation)(&[], &mut ctx),
|
|
Err(IntrinsicExecutionError::HardwareUnavailable)
|
|
);
|
|
assert_eq!(
|
|
(meta.implementation)(&[Value::Int64(0)], &mut ctx),
|
|
Err(IntrinsicExecutionError::ArityMismatch { expected: 0, got: 1 })
|
|
);
|
|
let mut vm = VirtualMachine::new(assemble(&format!("INTRINSIC {id}\n")).unwrap(), vec![]);
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(10, &mut NoSyscalls, &mut ctx).unwrap();
|
|
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
|
if trap.code == TRAP_UNAVAILABLE && trap.pc == 0));
|
|
assert!(vm.operand_stack_top(1).is_empty());
|
|
}
|
|
let mut vm = VirtualMachine::new(assemble("INTRINSIC 0x2136\n").unwrap(), vec![]);
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(10, &mut NoSyscalls, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
|
if trap.code == TRAP_INVALID_INTRINSIC));
|
|
}
|