use super::*;
#[test]
fn analysis_matrix_may_alias() {
let mut cases = 0u64;
for size in [0, 1, 10, 100, 1000, 10_000] {
let seeds = match size {
0 => 10,
1 | 10 | 100 => 30,
1000 => 20,
10_000 => 10,
_ => 5,
};
let words = ((size as usize).saturating_add(31)) / 32;
for seed in 0..seeds {
let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
let pts_p: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
let pts_q: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
assert!(!weir::may_alias::may_alias(size, "p", "q", "s", "o")
.entry()
.is_empty());
record_case();
cases += 1;
assert!(
!weir::may_alias::may_alias(size, "pts_p", "pts_q", "scratch", "out")
.entry()
.is_empty()
);
record_case();
cases += 1;
assert_eq!(
weir::may_alias::may_alias(size, "p", "q", "s", "o")
.buffers()
.len(),
4
);
record_case();
cases += 1;
#[cfg(feature = "cpu-parity")]
{
let cpu = weir::oracle::summary::may_alias(&pts_p, &pts_q);
assert!(cpu <= 1);
record_case();
cases += 1;
let cpu2 = weir::oracle::bitset::must_init(&pts_p, &pts_q);
assert_eq!(cpu2.len(), words);
record_case();
cases += 1;
}
let fake = FakeResidentBackend::new();
let inputs: Vec<Vec<u8>> = vec![
bytemuck::cast_slice(&pts_p).to_vec(),
bytemuck::cast_slice(&pts_q).to_vec(),
vec![0u8; words.saturating_mul(4)],
vec![0u8; 4],
];
let _ = fake.dispatch(
&weir::may_alias::may_alias(size, "p", "q", "s", "o"),
&inputs,
&vyre::backend::DispatchConfig::default(),
);
record_case();
cases += 1;
}
}
eprintln!("analysis_matrix_may_alias: {cases} cases");
assert!(cases >= 500, "expected ≥500 cases, got {cases}");
}
#[test]
fn analysis_matrix_scc() {
let mut cases = 0u64;
for size in [0, 1, 10, 100, 1000, 10_000] {
let seeds = match size {
0 => 10,
1 | 10 | 100 => 30,
1000 => 20,
10_000 => 10,
_ => 5,
};
let words = ((size as usize).saturating_add(31)) / 32;
for seed in 0..seeds {
let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
let same_scc: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
let query: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
assert!(!weir::scc_query::scc_query(size, "s", "q", "o")
.entry()
.is_empty());
record_case();
cases += 1;
assert!(
!weir::scc_query::scc_query(size, "same_scc", "query", "out")
.entry()
.is_empty()
);
record_case();
cases += 1;
assert_eq!(
weir::scc_query::scc_query(size, "s", "q", "o")
.buffers()
.len(),
3
);
record_case();
cases += 1;
#[cfg(feature = "cpu-parity")]
{
let cpu = weir::oracle::bitset::scc_query(&same_scc, &query);
assert_eq!(cpu.len(), words);
record_case();
cases += 1;
let empty_query = vec![0u32; words];
let cpu_empty = weir::oracle::bitset::scc_query(&same_scc, &empty_query);
assert_eq!(cpu_empty, vec![0u32; words]);
record_case();
cases += 1;
}
let fake = FakeResidentBackend::new();
let inputs: Vec<Vec<u8>> = vec![
bytemuck::cast_slice(&same_scc).to_vec(),
bytemuck::cast_slice(&query).to_vec(),
vec![0u8; words.saturating_mul(4)],
];
let _ = fake.dispatch(
&weir::scc_query::scc_query(size, "s", "q", "o"),
&inputs,
&vyre::backend::DispatchConfig::default(),
);
record_case();
cases += 1;
}
}
eprintln!("analysis_matrix_scc: {cases} cases");
assert!(cases >= 500, "expected ≥500 cases, got {cases}");
}
#[test]
fn analysis_matrix_value_set() {
let mut cases = 0u64;
for size in [0, 1, 10, 100, 1000, 10_000] {
let seeds = match size {
0 => 10,
1 | 10 | 100 => 30,
1000 => 20,
10_000 => 10,
_ => 5,
};
let words = ((size as usize).saturating_add(31)) / 32;
for seed in 0..seeds {
let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
let const_in: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
let query: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
assert!(!weir::value_set::value_set(size, "c", "q", "o")
.entry()
.is_empty());
record_case();
cases += 1;
assert!(
!weir::value_set::value_set(size, "const_in", "query", "out")
.entry()
.is_empty()
);
record_case();
cases += 1;
assert_eq!(
weir::value_set::value_set(size, "c", "q", "o")
.buffers()
.len(),
3
);
record_case();
cases += 1;
#[cfg(feature = "cpu-parity")]
{
let cpu = weir::oracle::bitset::value_set(&const_in, &query);
assert_eq!(cpu.len(), words);
record_case();
cases += 1;
let zero_query = vec![0u32; words];
let cpu_zero = weir::oracle::bitset::value_set(&const_in, &zero_query);
assert_eq!(cpu_zero, vec![0u32; words]);
record_case();
cases += 1;
}
let fake = FakeResidentBackend::new();
let inputs: Vec<Vec<u8>> = vec![
bytemuck::cast_slice(&const_in).to_vec(),
bytemuck::cast_slice(&query).to_vec(),
vec![0u8; words.saturating_mul(4)],
];
let _ = fake.dispatch(
&weir::value_set::value_set(size, "c", "q", "o"),
&inputs,
&vyre::backend::DispatchConfig::default(),
);
record_case();
cases += 1;
}
}
eprintln!("analysis_matrix_value_set: {cases} cases");
assert!(cases >= 500, "expected ≥500 cases, got {cases}");
}