use smtlite::{Bv, Solution, Solver, mask};
fn sat(s: &Solver) -> smtlite::Model {
match s.check() {
Solution::Sat(m) => m,
other => panic!("expected SAT, got {other:?}"),
}
}
#[test]
fn a_declared_variable_no_constraint_touches_still_reads_back() {
let mut s = Solver::new();
let x = s.var("x", 8);
let _unused = s.var("unused", 16);
s.assert(x.eq(&Bv::val(5, 8)));
let m = sat(&s);
assert_eq!(m.get("x"), Some(5));
let u = m.get("unused").expect("a declared variable reads back");
assert!(u <= 0xffff, "unused value {u} exceeds its 16-bit width");
}
#[test]
fn an_empty_constraint_set_yields_a_total_model() {
let mut s = Solver::new();
let _a = s.var("a", 1);
let _b = s.var("b", 64);
let m = sat(&s);
assert!(m.get("a").is_some());
assert!(m.get("b").is_some());
assert!(m.get("never_declared").is_none());
}
#[test]
fn every_declared_width_reads_back_exactly() {
for w in 1..=64u32 {
let v = mask(0xDEAD_BEEF_CAFE_BABE, w);
let mut s = Solver::new();
let x = s.var("x", w);
s.assert(x.eq(&Bv::val(v, w)));
let m = sat(&s);
assert_eq!(m.get("x"), Some(v), "width {w} did not read back");
}
}
#[test]
fn zero_clause_cap_yields_unknown_without_solving() {
let s = Solver::new().with_max_clauses(0);
assert!(matches!(s.check(), Solution::Unknown));
}
#[test]
fn zero_budget_refutes_by_propagation_but_cannot_branch() {
let mut s = Solver::new();
let x = s.var("x", 8);
s.assert(x.eq(&Bv::val(5, 8)));
s.assert(x.eq(&Bv::val(6, 8)));
assert!(matches!(s.check_with_budget(0), Solution::Unsat));
let mut t = Solver::new();
let y = t.var("y", 1);
let z = t.var("z", 1);
assert!(matches!(
t.check_all_with_budget(&[y.or(&z)], 0),
Solution::Unknown
));
}
#[test]
fn an_unconstrained_solver_answers_without_spending_a_decision() {
let mut s = Solver::new();
let _y = s.var("y", 8);
match s.check_with_budget(0) {
Solution::Sat(m) => assert!(m.get("y").is_some(), "the model is total"),
other => panic!("expected SAT, got {other:?}"),
}
}
#[test]
fn an_elapsed_deadline_yields_unknown_not_unsat() {
let mut s = Solver::new();
let x = s.var("x", 8);
let past = std::time::Instant::now()
.checked_sub(std::time::Duration::from_secs(1))
.unwrap_or_else(std::time::Instant::now);
assert!(matches!(
s.check_all_within(&[x.ne(&x)], 1_000_000, past),
Solution::Unknown
));
}
#[test]
fn an_elapsed_deadline_covers_the_background_blast_and_does_not_poison_it() {
let mut s = Solver::new().with_max_clauses(200_000);
let x = s.var("x", 64);
let y = s.var("y", 64);
s.assert(x.mul(&y).eq(&Bv::val(6, 64)));
let past = std::time::Instant::now()
.checked_sub(std::time::Duration::from_secs(1))
.unwrap_or_else(std::time::Instant::now);
assert!(matches!(
s.check_assumptions_within(&[], 1_000_000, past),
Solution::Unknown
));
let far = std::time::Instant::now() + std::time::Duration::from_secs(3600);
match s.check_assumptions_within(&[], 1_000_000, far) {
Solution::Sat(m) => {
let (v, w) = (m.get("x").unwrap(), m.get("y").unwrap());
assert_eq!(v.wrapping_mul(w), 6, "model {v} * {w} != 6");
}
other => panic!("expected SAT with a fresh deadline, got {other:?}"),
}
}
#[test]
fn an_over_cap_background_answers_unknown_on_every_check() {
let mut s = Solver::new().with_max_clauses(8);
let x = s.var("x", 8);
let y = s.var("y", 8);
s.assert(x.mul(&y).eq(&Bv::val(6, 8)));
for _ in 0..3 {
assert!(matches!(s.check(), Solution::Unknown));
}
}
#[test]
fn check_all_ignores_stored_asserts_and_does_not_mutate_them() {
let mut s = Solver::new();
let x = s.var("x", 8);
s.assert(x.eq(&Bv::val(5, 8)));
assert!(matches!(
s.check_all(&[x.eq(&Bv::val(9, 8))]),
Solution::Sat(_)
));
assert_eq!(sat(&s).get("x"), Some(5));
}
#[test]
fn assumptions_combine_with_the_stored_background_not_replace_it() {
let mut s = Solver::new();
let x = s.var("x", 8);
s.assert(x.eq(&Bv::val(5, 8)));
assert!(matches!(
s.check_assumptions(&[x.eq(&Bv::val(9, 8))]),
Solution::Unsat
));
assert!(matches!(
s.check_all(&[x.eq(&Bv::val(9, 8))]),
Solution::Sat(_)
));
}
#[test]
fn assumptions_do_not_leak_into_the_next_solve() {
let mut s = Solver::new();
let x = s.var("x", 8);
s.assert(x.ult(&Bv::val(10, 8)));
assert!(matches!(
s.check_assumptions(&[x.ugt(&Bv::val(5, 8))]),
Solution::Sat(_)
));
assert!(matches!(
s.check_assumptions(&[x.ult(&Bv::val(5, 8))]),
Solution::Sat(_)
));
}
#[test]
fn assert_invalidates_the_cached_background() {
let mut s = Solver::new();
let x = s.var("x", 8);
s.assert(x.eq(&Bv::val(5, 8)));
assert!(matches!(s.check(), Solution::Sat(_)));
s.assert(x.eq(&Bv::val(6, 8)));
assert!(matches!(s.check(), Solution::Unsat));
}
#[test]
fn var_invalidates_the_cached_background_so_the_model_stays_total() {
let mut s = Solver::new();
let x = s.var("x", 8);
s.assert(x.eq(&Bv::val(5, 8)));
assert!(matches!(s.check(), Solution::Sat(_)));
let y = s.var("y", 8);
match s.check() {
Solution::Sat(m) => {
assert_eq!(m.get("x"), Some(5));
assert!(m.get("y").is_some(), "a later-declared variable reads back");
}
other => panic!("expected SAT, got {other:?}"),
}
s.assert(y.eq(&Bv::val(7, 8)));
match s.check() {
Solution::Sat(m) => assert_eq!(m.get("y"), Some(7)),
other => panic!("expected SAT, got {other:?}"),
}
}
#[test]
fn assumption_budget_and_deadline_variants_degrade_the_same_way() {
let mut s = Solver::new();
let x = s.var("x", 8);
assert!(matches!(
s.check_assumptions_with_budget(&[x.eq(&Bv::val(1, 8)), x.eq(&Bv::val(2, 8))], 0),
Solution::Unsat
));
let past = std::time::Instant::now()
.checked_sub(std::time::Duration::from_secs(1))
.unwrap_or_else(std::time::Instant::now);
assert!(matches!(
s.check_assumptions_within(
&[x.eq(&Bv::val(1, 8)), x.eq(&Bv::val(2, 8))],
1_000_000,
past
),
Solution::Unknown
));
}
#[test]
fn assumption_models_read_back_background_only_variables() {
let mut s = Solver::new();
let x = s.var("x", 8);
let y = s.var("y", 8);
s.assert(x.eq(&Bv::val(5, 8)));
match s.check_assumptions(&[y.eq(&Bv::val(7, 8))]) {
Solution::Sat(m) => {
assert_eq!(m.get("x"), Some(5), "a background-only variable reads back");
assert_eq!(
m.get("y"),
Some(7),
"an assumption-only variable reads back"
);
}
other => panic!("expected SAT, got {other:?}"),
}
}
#[test]
fn the_incremental_path_matches_check_all_on_the_same_formula() {
let mut inc = Solver::new();
let x = inc.var("x", 8);
let y = inc.var("y", 8);
inc.assert(x.eq(&Bv::val(0x2a, 8))); inc.assert(y.eq(&Bv::val(0x77, 8)));
let mut direct = Solver::new();
let dx = direct.var("x", 8);
let dy = direct.var("y", 8);
let whole_formula = [
dx.eq(&Bv::val(0x2a, 8)),
dy.eq(&Bv::val(0x77, 8)),
dx.add(&dy).eq(&Bv::val(0x2a + 0x77, 8)),
];
match (
inc.check_assumptions(&[x.add(&y).eq(&Bv::val(0x2a + 0x77, 8))]),
direct.check_all(&whole_formula),
) {
(Solution::Sat(ma), Solution::Sat(md)) => {
assert_eq!(ma.get("x"), Some(0x2a));
assert_eq!(ma.get("y"), Some(0x77));
assert_eq!(md.get("x"), Some(0x2a));
assert_eq!(md.get("y"), Some(0x77));
}
(Solution::Unsat, Solution::Unsat) => {}
(a, b) => panic!("the two paths disagreed: {a:?} vs {b:?}"),
}
}
#[test]
fn depends_on_matches_by_name_prefix() {
let mut s = Solver::new();
let hdr = s.var("hdr.len", 16);
let init = s.var("init.base", 16);
let from_hdr = hdr.add(&Bv::val(1, 16));
assert!(s.depends_on(&from_hdr, "hdr."));
assert!(!s.depends_on(&from_hdr, "init"));
assert!(s.depends_on(&hdr, "hdr"));
assert!(!s.depends_on(&Bv::val(1, 16), "hdr"));
let both = hdr.add(&init);
assert!(s.depends_on(&both, "hdr."));
assert!(s.depends_on(&both, "init."));
}
#[test]
fn var_ids_deduplicates_shared_subgraphs() {
let mut s = Solver::new();
let a = s.var("a", 8);
let b = s.var("b", 8);
assert_eq!(a.add(&a).var_ids().len(), 1);
let mut ids = a.add(&b).var_ids();
ids.sort_unstable();
assert_eq!(ids, vec![0, 1]);
}
#[test]
fn var_ids_walks_a_deep_chain_without_overflowing_the_stack() {
let mut s = Solver::new();
let v = s.var("v", 8);
let mut deep = v;
for _ in 0..100_000 {
deep = deep.shl(1);
}
assert_eq!(deep.var_ids(), vec![0]);
assert!(s.depends_on(&deep, "v"));
std::mem::forget(deep);
}
#[test]
fn mask_truncates_to_the_low_bits() {
assert_eq!(mask(0xabcd, 8), 0xcd);
assert_eq!(mask(0xabcd, 16), 0xabcd);
assert_eq!(mask(0xff, 4), 0xf);
assert_eq!(mask(u64::MAX, 64), u64::MAX);
}
#[test]
fn ptr_eq_is_identity_not_structure() {
let a = Bv::val(1, 8);
assert!(a.ptr_eq(&a));
let b = Bv::val(1, 8);
assert!(!a.ptr_eq(&b));
let c = a.add(&b);
assert!(c.ptr_eq(&c));
}
#[test]
fn as_const_folds_constant_expressions() {
assert_eq!(Bv::val(7, 8).as_const(), Some(7));
assert_eq!(Bv::val(0x1ff, 8).as_const(), Some(0xff)); assert_eq!(Bv::val(1, 8).add(&Bv::val(1, 8)).as_const(), Some(2));
assert_eq!(Bv::val(9, 8).udiv(&Bv::val(0, 8)).as_const(), Some(0xff));
let mut s = Solver::new();
let x = s.var("x", 8);
assert_eq!(x.add(&Bv::val(0, 8)).as_const(), None);
}
#[test]
fn display_and_debug_are_stable() {
assert_eq!(Bv::val(5, 8).to_string(), "#5:8");
assert_eq!(format!("{:?}", Bv::val(5, 8)), "Bv(#5:8)");
}
#[test]
fn widths_compose_as_documented() {
let mut s = Solver::new();
let x = s.var("x", 8);
assert_eq!(x.width(), 8);
assert_eq!(x.extract(3, 0).width(), 4);
assert_eq!(x.zext(16).width(), 16);
assert_eq!(x.sext(16).width(), 16);
assert_eq!(x.concat(&x).width(), 16);
assert_eq!(x.eq(&x).width(), 1);
assert_eq!(Bv::ite(&x.eq(&x), &x, &x).width(), 8);
}