vyre-conform 0.1.0

use super::*;

const INDEPENDENT_LITERAL: &str = r#"
#[test]
fn add_identity_row() {
    let expected = 5u32;
    assert_eq!(dispatch(&program, &[2u32, 3u32]), expected);
}
"#;

const INDEPENDENT_REFERENCE: &str = r#"
#[test]
fn add_reference_parity() {
    let expected = match vyre_reference::run(&program, &inputs) {
        Ok(value) => value,
        Err(error) => return Err(error),
    };
    assert_eq!(backend.run(&program, &inputs), expected);
}
"#;

const TAUTOLOGY_DIRECT_CPUFN: &str = r#"
#[test]
fn add_tautology() {
    let expected = specs::primitive::add::spec().cpu_fn(&input);
    assert_eq!(backend.dispatch(&input), expected);
}
"#;

const TAUTOLOGY_OP_NAMED_CALL: &str = r#"
#[test]
fn add_tautology_named() {
    let expected = add(a, b);
    assert_eq!(backend.dispatch_add(a, b), expected);
}
"#;

const TAUTOLOGY_METHOD_CALL: &str = r#"
#[test]
fn add_tautology_method() {
    let expected = spec.cpu_fn(&input);
    assert_eq!(backend.dispatch(&input), expected);
}
"#;

#[test]
fn literal_expected_is_independent() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(INDEPENDENT_LITERAL, "add")?;
    assert_eq!(cert.verdict, CertificateVerdict::Independent);
    Ok(())
}

#[test]
fn reference_interpreter_is_independent() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(INDEPENDENT_REFERENCE, "add")?;
    assert_eq!(cert.verdict, CertificateVerdict::Independent);
    Ok(())
}

#[test]
fn direct_cpu_fn_call_is_tautological() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_DIRECT_CPUFN, "add")?;
    assert!(matches!(
        cert.verdict,
        CertificateVerdict::SuspectedTautology { .. }
    ));
    Ok(())
}

#[test]
fn op_named_call_is_tautological() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_OP_NAMED_CALL, "add")?;
    assert!(matches!(
        cert.verdict,
        CertificateVerdict::SuspectedTautology { .. }
    ));
    Ok(())
}

#[test]
fn method_call_is_tautological() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_METHOD_CALL, "add")?;
    assert!(matches!(
        cert.verdict,
        CertificateVerdict::SuspectedTautology { .. }
    ));
    Ok(())
}

#[test]
fn dotted_op_id_handles_last_segment() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_OP_NAMED_CALL, "primitive.bitwise.add")?;
    assert!(matches!(
        cert.verdict,
        CertificateVerdict::SuspectedTautology { .. }
    ));
    Ok(())
}

#[test]
fn unrelated_op_name_does_not_falsely_flag() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(INDEPENDENT_LITERAL, "xor")?;
    assert_eq!(cert.verdict, CertificateVerdict::Independent);
    Ok(())
}

// -----------------------------------------------------------------
// F3 fix coverage — binding names outside the old EXPECTED_NAMES
// -----------------------------------------------------------------

const TAUTOLOGY_UNUSUAL_NAME: &str = r#"
#[test]
fn add_via_unusual_name() {
    let answer = specs::primitive::add::spec().cpu_fn(&input);
    assert_eq!(backend.dispatch(&input), answer);
}
"#;

const TAUTOLOGY_RESULT_NAME: &str = r#"
#[test]
fn add_via_result_name() {
    let result = add(a, b);
    assert_eq!(backend.dispatch_add(a, b), result);
}
"#;

#[test]
fn unusual_name_binding_is_still_caught() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_UNUSUAL_NAME, "add")?;
    assert!(
        matches!(cert.verdict, CertificateVerdict::SuspectedTautology { .. }),
        "F3: a local binding named `answer` still resolves into cpu_fn — \
             must be caught regardless of the binding's name. Verdict: {:?}",
        cert.verdict
    );
    Ok(())
}

#[test]
fn result_name_binding_is_still_caught() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_RESULT_NAME, "add")?;
    assert!(
        matches!(cert.verdict, CertificateVerdict::SuspectedTautology { .. }),
        "F3: `let result = add(a, b)` must be caught because the path \
             terminal segment matches the op id. Verdict: {:?}",
        cert.verdict
    );
    Ok(())
}

// -----------------------------------------------------------------
// F1 fix coverage — helper function laundering
// -----------------------------------------------------------------

const TAUTOLOGY_HELPER_FN: &str = r#"
fn compute(i: &[u8]) -> Vec<u8> {
    specs::primitive::add::spec().cpu_fn(i)
}

#[test]
fn add_via_helper() {
    let expected = compute(&input);
    assert_eq!(backend.dispatch(&input), expected);
}
"#;

#[test]
fn helper_fn_laundering_is_caught() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_HELPER_FN, "add")?;
    assert!(
        matches!(cert.verdict, CertificateVerdict::SuspectedTautology { .. }),
        "F1: calling a local helper that invokes cpu_fn must be caught \
             via intra-source call graph scanning. Verdict: {:?}",
        cert.verdict
    );
    Ok(())
}

// -----------------------------------------------------------------
// F2 fix coverage — closure laundering
// -----------------------------------------------------------------

const TAUTOLOGY_CLOSURE: &str = r#"
#[test]
fn add_via_closure() {
    let f = |i: &[u8]| specs::primitive::add::spec().cpu_fn(i);
    let expected = f(&input);
    assert_eq!(backend.dispatch(&input), expected);
}
"#;

#[test]
fn closure_laundering_is_caught() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_CLOSURE, "add")?;
    assert!(
        matches!(cert.verdict, CertificateVerdict::SuspectedTautology { .. }),
        "F2: calling a local closure that invokes cpu_fn must be caught. \
             Verdict: {:?}",
        cert.verdict
    );
    Ok(())
}

// -----------------------------------------------------------------
// F3 fix coverage — non-binding usages
// -----------------------------------------------------------------

const TAUTOLOGY_NON_BINDING: &str = r#"
#[test]
fn add_tautology_non_binding() {
    assert_eq!(backend.dispatch(&input), specs::primitive::add::spec().cpu_fn(&input));
}
"#;

#[test]
fn non_binding_tautology_is_caught() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_NON_BINDING, "add")?;
    assert!(
        matches!(cert.verdict, CertificateVerdict::SuspectedTautology { .. }),
        "F3: tautology in an expression that is NOT a let binding (e.g. \
             direct macro argument) must be caught. Verdict: {:?}",
        cert.verdict
    );
    Ok(())
}

// -----------------------------------------------------------------
// Nested block-local binding laundering
// -----------------------------------------------------------------

const TAUTOLOGY_NESTED_BLOCK: &str = r#"
#[test]
fn add_via_nested_block() {
    let expected = {
        let tmp = specs::primitive::add::spec().cpu_fn(&input);
        tmp
    };
    assert_eq!(backend.dispatch(&input), expected);
}
"#;

#[test]
fn nested_block_rebinding_is_caught() -> Result<(), IndependenceError> {
    let cert = verify_test_independence(TAUTOLOGY_NESTED_BLOCK, "add")?;
    assert!(
        matches!(cert.verdict, CertificateVerdict::SuspectedTautology { .. }),
        "F1: a `{{ let tmp = cpu_fn(...); tmp }}` block hides the call \
             inside a local. Verdict: {:?}",
        cert.verdict
    );
    Ok(())
}