vyre-conform 0.1.0

use core::fmt;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn every_variant_has_a_unique_name() {
        let mut seen = std::collections::BTreeSet::new();
        for contract in OverflowContract::all() {
            assert!(
                seen.insert(contract.name()),
                "duplicate name for {:?}",
                contract
            );
        }
        assert_eq!(seen.len(), 4);
    }

    #[test]
    fn parse_round_trips_every_variant() {
        for contract in OverflowContract::all() {
            let parsed = OverflowContract::parse(contract.name())
                .expect("every canonical name must parse");
            assert_eq!(parsed, contract);
        }
    }

    #[test]
    fn parse_rejects_unknown_names() {
        assert_eq!(OverflowContract::parse("wrap"), None);
        assert_eq!(OverflowContract::parse("undefined"), None);
        assert_eq!(OverflowContract::parse(""), None);
        assert_eq!(OverflowContract::parse("Wrapping"), None);
    }

    #[test]
    fn display_matches_name() {
        for contract in OverflowContract::all() {
            assert_eq!(format!("{contract}"), contract.name());
        }
    }

    #[test]
    fn description_is_non_empty_for_every_variant() {
        for contract in OverflowContract::all() {
            let description = contract.description();
            assert!(
                !description.trim().is_empty(),
                "{:?} has an empty description — conform --explain would print nothing",
                contract
            );
        }
    }

    #[test]
    fn plain_declaration_has_no_justification() {
        let decl =
            OverflowDeclaration::plain(OverflowContract::Wrapping, "spec/primitive/add.rs");
        assert_eq!(decl.contract, OverflowContract::Wrapping);
        assert_eq!(decl.declared_in, "spec/primitive/add.rs");
        assert!(decl.justification.is_empty());
        assert_eq!(decl.cite(), "wrapping (declared in spec/primitive/add.rs)");
    }

    #[test]
    fn with_justification_is_preserved_and_cited() {
        let decl = OverflowDeclaration::with_justification(
            OverflowContract::Unchecked,
            "spec/primitive/add_checked.rs",
            "input range is statically constrained to [0, u32::MAX/2]",
        );
        let cited = decl.cite();
        assert!(cited.contains("unchecked"));
        assert!(cited.contains("spec/primitive/add_checked.rs"));
        assert!(cited.contains("statically constrained"));
    }

    #[test]
    fn all_enumerates_every_variant_exactly_once() {
        let variants = OverflowContract::all();
        let set: std::collections::BTreeSet<_> = variants.iter().collect();
        assert_eq!(set.len(), variants.len());
    }
}