#[allow(deprecated)]
use super::*;
use vyre::ir::Node;
fn write_words(out: &mut Vec<u8>, words: &[u32]) {
out.clear();
for word in words {
out.extend_from_slice(&word.to_le_bytes());
}
}
fn read_word(bytes: &[u8], index: usize) -> u32 {
let start = index * 4;
let mut word = [0; 4];
word.copy_from_slice(&bytes[start..start + 4]);
u32::from_le_bytes(word)
}
#[test]
fn range_propagate_emits_program_with_op_id() {
let p = range_propagate_with_count("defs", "edges", "out", 4);
let has_region = p.entry().iter().any(|n| {
matches!(
n,
Node::Region { generator, .. } if generator.as_str() == OP_ID
)
});
assert!(
has_region,
"weir::range: Program body must contain a Region tagged `{OP_ID}`"
);
}
#[test]
fn range_propagate_buffer_slots_match_var_pairs() {
let p = range_propagate_with_count("defs", "edges", "out", 4);
for buf in p.buffers() {
assert_eq!(
buf.count(),
8,
"weir::range: buffer `{}` must have count=8 for 4 var-pairs",
buf.name()
);
}
}
#[test]
fn range_propagate_zero_vars_minimum_slot_one() {
let p = range_propagate_with_count("defs", "edges", "out", 0);
for buf in p.buffers() {
assert_eq!(
buf.count(),
1,
"weir::range: zero-var must produce slots=1 (the .max(1) floor)"
);
}
}
#[test]
fn range_propagate_three_buffers_declared() {
let p = range_propagate_with_count("defs", "edges", "out", 4);
assert_eq!(
p.buffers().len(),
3,
"weir::range: Program must declare exactly 3 buffers (defs, edges, out)"
);
}
#[test]
fn range_soundness_is_mayover() {
use super::super::soundness::SoundnessTagged;
assert_eq!(
Range.soundness(),
super::super::soundness::Soundness::MayOver,
"weir::range: interval domain is over-approximate"
);
}
#[test]
fn range_propagate_into_reuses_caller_output_slot() {
use std::cell::Cell;
let mut outputs = vec![Vec::with_capacity(16)];
let outputs_addr = outputs.as_ptr() as usize;
let slot_addr = outputs[0].as_ptr() as usize;
let observed = Cell::new(false);
let out = range_propagate_borrowed_into_via(
&|_, inputs, grid, outputs| {
assert_eq!(grid, Some([1, 1, 1]));
assert_eq!(inputs.len(), 3);
assert_eq!(outputs.len(), 1);
assert_eq!(outputs.as_ptr() as usize, outputs_addr);
assert_eq!(outputs[0].as_ptr() as usize, slot_addr);
let lo = read_word(inputs[0], 0);
let hi = read_word(inputs[0], 1);
let t_lo = read_word(inputs[1], 0);
let t_hi = read_word(inputs[1], 1);
write_words(&mut outputs[0], &[lo + t_lo, hi + t_hi]);
assert_eq!(outputs[0].as_ptr() as usize, slot_addr);
observed.set(true);
Ok(())
},
&[10, 20],
&[1, 2],
1,
&mut outputs,
)
.expect("caller-owned output scratch should decode");
assert!(observed.get());
assert_eq!(out, vec![11, 22]);
assert_eq!(outputs.len(), 1);
assert_eq!(outputs.as_ptr() as usize, outputs_addr);
assert_eq!(outputs[0].as_ptr() as usize, slot_addr);
}
#[test]
fn range_propagate_with_scratch_reuses_staging_and_output_slots() {
let mut scratch = RangePropagateScratch::default();
let dispatch = |_: &vyre::ir::Program,
inputs: &[&[u8]],
_: Option<[u32; 3]>|
-> Result<Vec<Vec<u8>>, String> {
let lo = read_word(inputs[0], 0);
let hi = read_word(inputs[0], 1);
let t_lo = read_word(inputs[1], 0);
let t_hi = read_word(inputs[1], 1);
let mut out = Vec::with_capacity(64);
write_words(&mut out, &[lo + t_lo, hi + t_hi]);
Ok(vec![out])
};
let first =
range_propagate_borrowed_with_scratch_via(&dispatch, &[10, 20], &[1, 2], 1, &mut scratch)
.expect("first scratch-backed range propagation should decode");
assert_eq!(first, vec![11, 22]);
let defs_capacity = scratch.defs_bytes.capacity();
let edges_capacity = scratch.edges_bytes.capacity();
let out_capacity = scratch.out_bytes.capacity();
let outputs_addr = scratch.outputs.as_ptr() as usize;
let slot_addr = scratch.outputs[0].as_ptr() as usize;
let second =
range_propagate_borrowed_with_scratch_via(&dispatch, &[30, 40], &[3, 4], 1, &mut scratch)
.expect("second scratch-backed range propagation should decode");
assert_eq!(second, vec![33, 44]);
assert_eq!(scratch.defs_bytes.capacity(), defs_capacity);
assert_eq!(scratch.edges_bytes.capacity(), edges_capacity);
assert_eq!(scratch.out_bytes.capacity(), out_capacity);
assert_eq!(scratch.outputs.as_ptr() as usize, outputs_addr);
assert_eq!(scratch.outputs[0].as_ptr() as usize, slot_addr);
}
#[test]
fn range_propagate_into_result_with_scratch_reuses_decoded_result() {
let mut scratch = RangePropagateScratch::default();
let mut result = Vec::with_capacity(8);
let result_addr = result.as_ptr() as usize;
let dispatch = |_: &vyre::ir::Program,
inputs: &[&[u8]],
_: Option<[u32; 3]>|
-> Result<Vec<Vec<u8>>, String> {
let lo = read_word(inputs[0], 0);
let hi = read_word(inputs[0], 1);
let t_lo = read_word(inputs[1], 0);
let t_hi = read_word(inputs[1], 1);
let mut out = Vec::with_capacity(64);
write_words(&mut out, &[lo + t_lo, hi + t_hi]);
Ok(vec![out])
};
range_propagate_borrowed_into_result_with_scratch_via(
&dispatch,
&[10, 20],
&[1, 2],
1,
&mut scratch,
&mut result,
)
.expect("first decoded-result scratch range propagation should decode");
assert_eq!(result, vec![11, 22]);
assert_eq!(result.as_ptr() as usize, result_addr);
range_propagate_borrowed_into_result_with_scratch_via(
&dispatch,
&[30, 40],
&[3, 4],
1,
&mut scratch,
&mut result,
)
.expect("second decoded-result scratch range propagation should decode");
assert_eq!(result, vec![33, 44]);
assert_eq!(result.as_ptr() as usize, result_addr);
}