llvm-native-core 0.1.10

//! IR Generation Tests
//!
//! Tests that validate the LLVM IR generated by the clang codegen for
//! various C constructs. Each test verifies specific IR patterns:
//! - Alloca for local variables, load/store, GEP for aggregates
//! - Branch/switch/phi nodes for control flow
//! - Type lowering (i32 for int, double for double)
//! - Constant expression folding
//! - Debug info presence (llvm.dbg.declare, llvm.dbg.value)
//! - Function attributes (noinline, alwaysinline, optnone, ssp)
//! - Calling conventions
//! - Global variables (constant/non-constant, initializers, linkage)

use std::collections::BTreeMap;

// ── IR Verification Types ─────────────────────────────────────────────────

/// An IR check that validates a specific construct in generated IR.
#[derive(Debug, Clone)]
pub struct IrGenCheck {
    /// Description of what this check verifies.
    pub description: String,
    /// The IR pattern to look for.
    pub pattern: String,
    /// Whether the pattern must appear.
    pub required: bool,
    /// Minimum number of occurrences.
    pub min_count: usize,
    /// Whether this is an exact match (not substring).
    pub exact: bool,
    /// Category of this check.
    pub category: IrCheckCategory,
}

/// Categories of IR generation checks.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IrCheckCategory {
    /// Alloca/load/store for locals.
    MemoryAccess,
    /// Branch/switch/phi for control flow.
    ControlFlow,
    /// Type mapping (i32→int, double→double).
    TypeLowering,
    /// Constant expressions and folding.
    Constants,
    /// Debug information.
    DebugInfo,
    /// Function attributes.
    Attributes,
    /// Calling conventions.
    CallingConv,
    /// Global variables.
    Globals,
    /// GEP for struct/array accesses.
    AggregateAccess,
}

impl IrCheckCategory {
    /// Return a human-readable category name.
    pub fn name(&self) -> &'static str {
        match self {
            Self::MemoryAccess => "memory-access",
            Self::ControlFlow => "control-flow",
            Self::TypeLowering => "type-lowering",
            Self::Constants => "constants",
            Self::DebugInfo => "debug-info",
            Self::Attributes => "attributes",
            Self::CallingConv => "calling-conv",
            Self::Globals => "globals",
            Self::AggregateAccess => "aggregate-access",
        }
    }
}

impl IrGenCheck {
    /// Create a required check.
    pub fn required(description: &str, pattern: &str, category: IrCheckCategory) -> Self {
        Self {
            description: description.to_string(),
            pattern: pattern.to_string(),
            required: true,
            min_count: 1,
            exact: false,
            category,
        }
    }

    /// Create an optional check.
    pub fn optional(description: &str, pattern: &str, category: IrCheckCategory) -> Self {
        Self {
            description: description.to_string(),
            pattern: pattern.to_string(),
            required: false,
            min_count: 0,
            exact: false,
            category,
        }
    }

    /// Create an exact-match required check.
    pub fn required_exact(description: &str, pattern: &str, category: IrCheckCategory) -> Self {
        Self {
            description: description.to_string(),
            pattern: pattern.to_string(),
            required: true,
            min_count: 1,
            exact: true,
            category,
        }
    }

    /// Check the pattern against IR text.
    pub fn check(&self, ir: &str) -> bool {
        let count = if self.exact {
            ir.lines()
                .filter(|l| l.trim() == self.pattern.trim())
                .count()
        } else {
            ir.matches(&self.pattern).count()
        };
        if self.required {
            count >= self.min_count
        } else {
            true
        }
    }

    /// Count occurrences in IR text.
    pub fn count_in(&self, ir: &str) -> usize {
        if self.exact {
            ir.lines()
                .filter(|l| l.trim() == self.pattern.trim())
                .count()
        } else {
            ir.matches(&self.pattern).count()
        }
    }
}

/// Result of an IR generation verification test.
#[derive(Debug, Clone)]
pub struct IrGenTestResult {
    /// Test name.
    pub name: String,
    /// Whether all checks passed.
    pub passed: bool,
    /// The generated IR text.
    pub ir_text: String,
    /// Results for each check.
    pub check_results: Vec<IrCheckResult>,
}

/// Result of a single IR check.
#[derive(Debug, Clone)]
pub struct IrCheckResult {
    /// The check description.
    pub description: String,
    /// Whether the check passed.
    pub passed: bool,
    /// How many times the pattern was found.
    pub count: usize,
    /// The category.
    pub category: IrCheckCategory,
}

impl IrGenTestResult {
    /// Create a new test result from checks.
    pub fn from_checks(name: &str, ir_text: &str, checks: &[IrGenCheck]) -> Self {
        let mut results = Vec::new();
        let mut all_passed = true;
        for check in checks {
            let passed = check.check(ir_text);
            let count = check.count_in(ir_text);
            if !passed {
                all_passed = false;
            }
            results.push(IrCheckResult {
                description: check.description.clone(),
                passed,
                count,
                category: check.category,
            });
        }
        Self {
            name: name.to_string(),
            passed: all_passed,
            ir_text: ir_text.to_string(),
            check_results: results,
        }
    }

    /// Format a summary.
    pub fn summary(&self) -> String {
        let passed = self.check_results.iter().filter(|r| r.passed).count();
        let total = self.check_results.len();
        format!("{}: {}/{} checks passed", self.name, passed, total)
    }

    /// Get failed checks.
    pub fn failed_checks(&self) -> Vec<&IrCheckResult> {
        self.check_results.iter().filter(|r| !r.passed).collect()
    }
}

// ── C IR Generation Test Sources ──────────────────────────────────────────

/// Source: simple local variable (alloca + store + load).
pub fn ir_local_var_source() -> &'static str {
    "int main() { int x = 42; return x; }"
}

/// Expected IR checks for local variable.
pub fn ir_local_var_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "%x = alloca i32",
            "alloca for local variable",
            IrCheckCategory::MemoryAccess,
        ),
        IrGenCheck::required(
            "store i32 42",
            "store constant to local",
            IrCheckCategory::MemoryAccess,
        ),
        IrGenCheck::required("load i32", "load from local", IrCheckCategory::MemoryAccess),
        IrGenCheck::required("ret i32", "return i32 value", IrCheckCategory::ControlFlow),
    ]
}

/// Source: GEP for struct field access.
pub fn ir_struct_gep_source() -> &'static str {
    r#"
struct Point { int x; int y; };
int main() { struct Point p = {10, 20}; return p.x + p.y; }
"#
}

/// Expected IR checks for struct GEP.
pub fn ir_struct_gep_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "alloca %struct.Point",
            "alloca for struct",
            IrCheckCategory::MemoryAccess,
        ),
        IrGenCheck::required(
            "getelementptr",
            "GEP for struct field access",
            IrCheckCategory::AggregateAccess,
        ),
        IrGenCheck::required(
            "store i32 10",
            "store first field",
            IrCheckCategory::MemoryAccess,
        ),
        IrGenCheck::required(
            "store i32 20",
            "store second field",
            IrCheckCategory::MemoryAccess,
        ),
        IrGenCheck::required("add", "addition for x+y", IrCheckCategory::ControlFlow),
    ]
}

/// Source: array access with GEP.
pub fn ir_array_gep_source() -> &'static str {
    "int main() { int arr[3] = {1, 2, 3}; return arr[1]; }"
}

/// Expected IR checks for array GEP.
pub fn ir_array_gep_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "alloca [3 x i32]",
            "alloca for array",
            IrCheckCategory::MemoryAccess,
        ),
        IrGenCheck::required(
            "getelementptr",
            "GEP for array indexing",
            IrCheckCategory::AggregateAccess,
        ),
        IrGenCheck::required(
            "load i32",
            "load from array element",
            IrCheckCategory::MemoryAccess,
        ),
    ]
}

/// Source: if-else control flow (br + phi).
pub fn ir_if_else_source() -> &'static str {
    "int max(int a, int b) { if (a > b) return a; else return b; }"
}

/// Expected IR checks for if-else.
pub fn ir_if_else_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required("icmp", "integer comparison", IrCheckCategory::ControlFlow),
        IrGenCheck::required("br i1", "conditional branch", IrCheckCategory::ControlFlow),
        IrGenCheck::required(
            "ret i32",
            "return instruction",
            IrCheckCategory::ControlFlow,
        ),
    ]
}

/// Source: for loop (phi node for induction variable).
pub fn ir_for_loop_source() -> &'static str {
    "int sum(int n) { int s = 0; for (int i = 0; i < n; i++) { s += i; } return s; }"
}

/// Expected IR checks for for loop.
pub fn ir_for_loop_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "phi i32",
            "phi node for induction variable",
            IrCheckCategory::ControlFlow,
        ),
        IrGenCheck::required("br", "branch for loop", IrCheckCategory::ControlFlow),
        IrGenCheck::required(
            "icmp",
            "comparison for loop condition",
            IrCheckCategory::ControlFlow,
        ),
        IrGenCheck::required(
            "add",
            "addition for sum accumulation",
            IrCheckCategory::ControlFlow,
        ),
    ]
}

/// Source: switch statement.
pub fn ir_switch_source() -> &'static str {
    "int f(int x) { switch (x) { case 0: return 1; case 1: return 2; default: return 0; } }"
}

/// Expected IR checks for switch.
pub fn ir_switch_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "switch i32",
            "switch instruction",
            IrCheckCategory::ControlFlow,
        ),
        IrGenCheck::required("i32 0, label", "case 0 label", IrCheckCategory::ControlFlow),
        IrGenCheck::required("i32 1, label", "case 1 label", IrCheckCategory::ControlFlow),
    ]
}

/// Source: function call.
pub fn ir_function_call_source() -> &'static str {
    r#"
int add(int a, int b) { return a + b; }
int main() { return add(3, 4); }
"#
}

/// Expected IR checks for function call.
pub fn ir_function_call_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "call i32 @add",
            "function call",
            IrCheckCategory::ControlFlow,
        ),
        IrGenCheck::required(
            "define i32 @add",
            "function definition",
            IrCheckCategory::ControlFlow,
        ),
    ]
}

// ── Type Lowering Checks ──────────────────────────────────────────────────

/// Source: various type lowerings.
pub fn ir_type_lowering_source() -> &'static str {
    r#"
int main() {
    int i = 1;
    double d = 3.14;
    char c = 'A';
    long l = 123L;
    float f = 1.5f;
    int *p = &i;
    return i + (int)d + (int)c;
}
"#
}

/// Expected IR checks for type lowering.
pub fn ir_type_lowering_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "alloca i32",
            "int → i32 lowering",
            IrCheckCategory::TypeLowering,
        ),
        IrGenCheck::required(
            "alloca double",
            "double → double lowering",
            IrCheckCategory::TypeLowering,
        ),
        IrGenCheck::required(
            "alloca i8",
            "char → i8 lowering",
            IrCheckCategory::TypeLowering,
        ),
        IrGenCheck::required(
            "alloca i64",
            "long → i64 lowering",
            IrCheckCategory::TypeLowering,
        ),
        IrGenCheck::required(
            "alloca float",
            "float → float lowering",
            IrCheckCategory::TypeLowering,
        ),
        IrGenCheck::required("alloca ptr", "pointer type", IrCheckCategory::TypeLowering),
        IrGenCheck::required(
            "sitofp",
            "int to float conversion",
            IrCheckCategory::TypeLowering,
        ),
        IrGenCheck::required(
            "fptosi",
            "float to int conversion",
            IrCheckCategory::TypeLowering,
        ),
    ]
}

// ── Constant Expression Checks ────────────────────────────────────────────

/// Source: compile-time constant folding.
pub fn ir_const_fold_source() -> &'static str {
    "int main() { return 1 + 2 * 3 - 4 / 2; }"
}

/// Expected IR checks for constant folding.
pub fn ir_const_fold_checks() -> Vec<IrGenCheck> {
    vec![IrGenCheck::required(
        "ret i32 5",
        "constant folded to 5",
        IrCheckCategory::Constants,
    )]
}

/// Source: global constant.
pub fn ir_global_const_source() -> &'static str {
    r#"
const int MAX = 100;
int main() { return MAX; }
"#
}

/// Expected IR checks for global constant.
pub fn ir_global_const_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "@MAX =",
            "global constant declaration",
            IrCheckCategory::Constants,
        ),
        IrGenCheck::optional("constant", "constant qualifier", IrCheckCategory::Constants),
    ]
}

// ── Debug Info Checks ─────────────────────────────────────────────────────

/// Source: a function with debug info.
pub fn ir_debug_info_source() -> &'static str {
    "int main(int argc, char **argv) { int x = 42; return x; }"
}

/// Expected IR checks for debug info.
pub fn ir_debug_info_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "!dbg",
            "debug location metadata",
            IrCheckCategory::DebugInfo,
        ),
        IrGenCheck::required(
            "llvm.dbg.declare",
            "debug declare intrinsic",
            IrCheckCategory::DebugInfo,
        ),
        IrGenCheck::optional(
            "llvm.dbg.value",
            "debug value intrinsic",
            IrCheckCategory::DebugInfo,
        ),
        IrGenCheck::required("!DI", "debug info metadata", IrCheckCategory::DebugInfo),
    ]
}

// ── Function Attribute Checks ─────────────────────────────────────────────

/// Source: function with attributes.
pub fn ir_attrs_source() -> &'static str {
    r#"
__attribute__((noinline)) int foo(int x) { return x * 2; }
__attribute__((always_inline)) int bar(int x) { return x + 1; }
int main() { return foo(1) + bar(2); }
"#
}

/// Expected IR checks for function attributes.
pub fn ir_attrs_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "noinline",
            "noinline attribute",
            IrCheckCategory::Attributes,
        ),
        IrGenCheck::required(
            "alwaysinline",
            "alwaysinline attribute",
            IrCheckCategory::Attributes,
        ),
        IrGenCheck::optional("optnone", "optnone attribute", IrCheckCategory::Attributes),
        IrGenCheck::optional(
            "ssp",
            "stack protector attribute",
            IrCheckCategory::Attributes,
        ),
    ]
}

/// Check for optnone attribute.
pub fn ir_optnone_source() -> &'static str {
    "__attribute__((optnone)) int slow() { return 0; }"
}

/// Expected IR checks for optnone.
pub fn ir_optnone_checks() -> Vec<IrGenCheck> {
    vec![IrGenCheck::required(
        "optnone",
        "optnone attribute present",
        IrCheckCategory::Attributes,
    )]
}

// ── Calling Convention Checks ─────────────────────────────────────────────

/// Source: functions with different calling conventions.
pub fn ir_cc_source() -> &'static str {
    r#"
int cdecl_func(int a, int b) { return a + b; }
int __attribute__((fastcall)) fast_func(int a, int b) { return a * b; }
int main() { return cdecl_func(1, 2) + fast_func(3, 4); }
"#
}

/// Expected IR checks for calling conventions.
pub fn ir_cc_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required(
            "define",
            "function definition",
            IrCheckCategory::CallingConv,
        ),
        IrGenCheck::required("call", "function call", IrCheckCategory::CallingConv),
        IrGenCheck::optional(
            "fastcall",
            "fastcall convention",
            IrCheckCategory::CallingConv,
        ),
    ]
}

// ── Global Variable Checks ────────────────────────────────────────────────

/// Source: various global variable declarations.
pub fn ir_globals_source() -> &'static str {
    r#"
int global_int = 42;
const int global_const = 100;
static int static_int = 0;
int uninitialized;
extern int external_var;
int main() { return global_int; }
"#
}

/// Expected IR checks for global variables.
pub fn ir_globals_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required("@global_int =", "global variable", IrCheckCategory::Globals),
        IrGenCheck::required(
            "@global_const =",
            "const global variable",
            IrCheckCategory::Globals,
        ),
        IrGenCheck::required(
            "@static_int =",
            "static global variable",
            IrCheckCategory::Globals,
        ),
        IrGenCheck::required(
            "@uninitialized =",
            "uninitialized global",
            IrCheckCategory::Globals,
        ),
        IrGenCheck::optional(
            "@external_var =",
            "external variable",
            IrCheckCategory::Globals,
        ),
        IrGenCheck::required("dso_local", "dso_local linkage", IrCheckCategory::Globals),
    ]
}

/// Source: global with initializer.
pub fn ir_global_init_source() -> &'static str {
    "int arr[3] = {1, 2, 3}; int main() { return arr[0]; }"
}

/// Expected IR checks for global initializer.
pub fn ir_global_init_checks() -> Vec<IrGenCheck> {
    vec![
        IrGenCheck::required("@arr =", "global array", IrCheckCategory::Globals),
        IrGenCheck::required(
            "i32 1, i32 2, i32 3",
            "array initializer",
            IrCheckCategory::Globals,
        ),
    ]
}

// ── Test Suite Builder ────────────────────────────────────────────────────

/// A named IR generation test case.
#[derive(Debug, Clone)]
pub struct IrGenTestCase {
    /// Name of the test.
    pub name: String,
    /// C source code.
    pub source: String,
    /// Expected IR checks.
    pub checks: Vec<IrGenCheck>,
    /// Category.
    pub category: IrCheckCategory,
}

impl IrGenTestCase {
    /// Create a new test case.
    pub fn new(
        name: &str,
        source: &str,
        checks: Vec<IrGenCheck>,
        category: IrCheckCategory,
    ) -> Self {
        Self {
            name: name.to_string(),
            source: source.to_string(),
            checks,
            category,
        }
    }
}

/// Build the complete IR generation test suite.
pub fn build_ir_gen_test_suite() -> Vec<IrGenTestCase> {
    vec![
        // Memory access tests
        IrGenTestCase::new(
            "local_variable",
            ir_local_var_source(),
            ir_local_var_checks(),
            IrCheckCategory::MemoryAccess,
        ),
        // Aggregate access tests
        IrGenTestCase::new(
            "struct_gep",
            ir_struct_gep_source(),
            ir_struct_gep_checks(),
            IrCheckCategory::AggregateAccess,
        ),
        IrGenTestCase::new(
            "array_gep",
            ir_array_gep_source(),
            ir_array_gep_checks(),
            IrCheckCategory::AggregateAccess,
        ),
        // Control flow tests
        IrGenTestCase::new(
            "if_else",
            ir_if_else_source(),
            ir_if_else_checks(),
            IrCheckCategory::ControlFlow,
        ),
        IrGenTestCase::new(
            "for_loop",
            ir_for_loop_source(),
            ir_for_loop_checks(),
            IrCheckCategory::ControlFlow,
        ),
        IrGenTestCase::new(
            "switch",
            ir_switch_source(),
            ir_switch_checks(),
            IrCheckCategory::ControlFlow,
        ),
        IrGenTestCase::new(
            "function_call",
            ir_function_call_source(),
            ir_function_call_checks(),
            IrCheckCategory::ControlFlow,
        ),
        // Type lowering tests
        IrGenTestCase::new(
            "type_lowering",
            ir_type_lowering_source(),
            ir_type_lowering_checks(),
            IrCheckCategory::TypeLowering,
        ),
        // Constants tests
        IrGenTestCase::new(
            "const_fold",
            ir_const_fold_source(),
            ir_const_fold_checks(),
            IrCheckCategory::Constants,
        ),
        IrGenTestCase::new(
            "global_const",
            ir_global_const_source(),
            ir_global_const_checks(),
            IrCheckCategory::Constants,
        ),
        // Debug info tests
        IrGenTestCase::new(
            "debug_info",
            ir_debug_info_source(),
            ir_debug_info_checks(),
            IrCheckCategory::DebugInfo,
        ),
        // Attribute tests
        IrGenTestCase::new(
            "function_attrs",
            ir_attrs_source(),
            ir_attrs_checks(),
            IrCheckCategory::Attributes,
        ),
        IrGenTestCase::new(
            "optnone",
            ir_optnone_source(),
            ir_optnone_checks(),
            IrCheckCategory::Attributes,
        ),
        // Calling convention tests
        IrGenTestCase::new(
            "calling_conv",
            ir_cc_source(),
            ir_cc_checks(),
            IrCheckCategory::CallingConv,
        ),
        // Global variable tests
        IrGenTestCase::new(
            "globals",
            ir_globals_source(),
            ir_globals_checks(),
            IrCheckCategory::Globals,
        ),
        IrGenTestCase::new(
            "global_init",
            ir_global_init_source(),
            ir_global_init_checks(),
            IrCheckCategory::Globals,
        ),
    ]
}

// ── Tests ─────────────────────────────────────────────────────────────────

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

    // ── IrGenCheck tests ───────────────────────────────────────────────

    #[test]
    fn test_ir_gen_check_required() {
        let check = IrGenCheck::required("alloc test", "alloca", IrCheckCategory::MemoryAccess);
        assert!(check.required);
        assert_eq!(check.min_count, 1);
    }

    #[test]
    fn test_ir_gen_check_optional() {
        let check = IrGenCheck::optional("opt test", "phi", IrCheckCategory::ControlFlow);
        assert!(!check.required);
    }

    #[test]
    fn test_ir_gen_check_present() {
        let check = IrGenCheck::required("test", "alloca", IrCheckCategory::MemoryAccess);
        let ir = "alloca i32\nstore i32 0, i32* %1\nret i32 0";
        assert!(check.check(ir));
    }

    #[test]
    fn test_ir_gen_check_absent() {
        let check = IrGenCheck::required("test", "fadd", IrCheckCategory::TypeLowering);
        let ir = "alloca i32\nret i32 0";
        assert!(!check.check(ir));
    }

    #[test]
    fn test_ir_gen_check_count() {
        let check = IrGenCheck::required("test", "alloca", IrCheckCategory::MemoryAccess);
        let ir = "alloca i32\nalloca i64\nalloca double";
        assert_eq!(check.count_in(ir), 3);
    }

    #[test]
    fn test_ir_gen_check_exact() {
        let check = IrGenCheck::required_exact("exact", "ret i32 0", IrCheckCategory::ControlFlow);
        let ir = "  ret i32 0\n  ret i32 1";
        assert!(!check.check(ir)); // Doesn't match exactly due to whitespace
        let ir2 = "ret i32 0";
        assert!(check.check(ir2));
    }

    // ── IrCheckCategory tests ──────────────────────────────────────────

    #[test]
    fn test_ir_check_category_name() {
        assert_eq!(IrCheckCategory::MemoryAccess.name(), "memory-access");
        assert_eq!(IrCheckCategory::ControlFlow.name(), "control-flow");
        assert_eq!(IrCheckCategory::DebugInfo.name(), "debug-info");
        assert_eq!(IrCheckCategory::Globals.name(), "globals");
    }

    // ── IrGenTestResult tests ──────────────────────────────────────────

    #[test]
    fn test_ir_gen_test_result_all_pass() {
        let checks = vec![
            IrGenCheck::required("alloc", "alloca", IrCheckCategory::MemoryAccess),
            IrGenCheck::required("ret", "ret", IrCheckCategory::ControlFlow),
        ];
        let ir = "alloca i32\nret i32 0";
        let result = IrGenTestResult::from_checks("test", ir, &checks);
        assert!(result.passed);
    }

    #[test]
    fn test_ir_gen_test_result_some_fail() {
        let checks = vec![
            IrGenCheck::required("alloc", "alloca", IrCheckCategory::MemoryAccess),
            IrGenCheck::required("fadd", "fadd", IrCheckCategory::TypeLowering),
        ];
        let ir = "alloca i32\nret i32 0";
        let result = IrGenTestResult::from_checks("test", ir, &checks);
        assert!(!result.passed);
        assert_eq!(result.failed_checks().len(), 1);
    }

    #[test]
    fn test_ir_gen_test_result_summary() {
        let checks = vec![IrGenCheck::required(
            "t1",
            "alloca",
            IrCheckCategory::MemoryAccess,
        )];
        let ir = "alloca i32";
        let result = IrGenTestResult::from_checks("mytest", ir, &checks);
        assert!(result.summary().contains("mytest"));
        assert!(result.summary().contains("1/1"));
    }

    // ── Source/test source checks ──────────────────────────────────────

    #[test]
    fn test_ir_local_var_source() {
        let src = ir_local_var_source();
        assert!(src.contains("int x = 42"));
    }

    #[test]
    fn test_ir_struct_gep_source() {
        let src = ir_struct_gep_source();
        assert!(src.contains("struct Point"));
        assert!(src.contains("p.x"));
    }

    #[test]
    fn test_ir_array_gep_source() {
        let src = ir_array_gep_source();
        assert!(src.contains("arr[3]"));
        assert!(src.contains("arr[1]"));
    }

    #[test]
    fn test_ir_if_else_source() {
        let src = ir_if_else_source();
        assert!(src.contains("a > b"));
    }

    #[test]
    fn test_ir_for_loop_source() {
        let src = ir_for_loop_source();
        assert!(src.contains("for"));
        assert!(src.contains("i++"));
    }

    #[test]
    fn test_ir_switch_source() {
        let src = ir_switch_source();
        assert!(src.contains("switch"));
        assert!(src.contains("case 0"));
    }

    #[test]
    fn test_ir_function_call_source() {
        let src = ir_function_call_source();
        assert!(src.contains("add(3, 4)"));
    }

    #[test]
    fn test_ir_type_lowering_source() {
        let src = ir_type_lowering_source();
        assert!(src.contains("double d"));
        assert!(src.contains("char c"));
        assert!(src.contains("long l"));
    }

    #[test]
    fn test_ir_const_fold_source() {
        let src = ir_const_fold_source();
        // 1 + 2*3 - 4/2 = 1 + 6 - 2 = 5
        assert!(src.contains("1 + 2 * 3 - 4 / 2"));
    }

    #[test]
    fn test_ir_debug_info_source() {
        let src = ir_debug_info_source();
        assert!(src.contains("argc"));
        assert!(src.contains("argv"));
    }

    #[test]
    fn test_ir_attrs_source() {
        let src = ir_attrs_source();
        assert!(src.contains("noinline"));
        assert!(src.contains("always_inline"));
    }

    // ── Check sets ─────────────────────────────────────────────────────

    #[test]
    fn test_ir_local_var_checks_not_empty() {
        assert!(!ir_local_var_checks().is_empty());
    }

    #[test]
    fn test_ir_struct_gep_checks_has_gep() {
        let checks = ir_struct_gep_checks();
        assert!(checks.iter().any(|c| c.pattern.contains("getelementptr")));
    }

    #[test]
    fn test_ir_for_loop_checks_has_phi() {
        let checks = ir_for_loop_checks();
        assert!(checks.iter().any(|c| c.pattern.contains("phi")));
    }

    #[test]
    fn test_ir_type_lowering_checks_covers_types() {
        let checks = ir_type_lowering_checks();
        assert!(checks.iter().any(|c| c.pattern.contains("i32")));
        assert!(checks.iter().any(|c| c.pattern.contains("double")));
        assert!(checks.iter().any(|c| c.pattern.contains("i8")));
        assert!(checks.iter().any(|c| c.pattern.contains("i64")));
    }

    #[test]
    fn test_ir_debug_info_checks() {
        let checks = ir_debug_info_checks();
        assert!(checks.iter().any(|c| c.pattern.contains("!dbg")));
        assert!(checks.iter().any(|c| c.pattern.contains("dbg.declare")));
    }

    #[test]
    fn test_ir_attrs_checks() {
        let checks = ir_attrs_checks();
        assert!(checks.iter().any(|c| c.pattern.contains("noinline")));
        assert!(checks.iter().any(|c| c.pattern.contains("alwaysinline")));
    }

    // ── Suite builder tests ────────────────────────────────────────────

    #[test]
    fn test_build_ir_gen_test_suite_not_empty() {
        let suite = build_ir_gen_test_suite();
        assert!(!suite.is_empty());
    }

    #[test]
    fn test_build_ir_gen_test_suite_covers_categories() {
        let suite = build_ir_gen_test_suite();
        let cats: Vec<IrCheckCategory> = suite.iter().map(|t| t.category).collect();
        assert!(cats.contains(&IrCheckCategory::MemoryAccess));
        assert!(cats.contains(&IrCheckCategory::ControlFlow));
        assert!(cats.contains(&IrCheckCategory::TypeLowering));
        assert!(cats.contains(&IrCheckCategory::Constants));
        assert!(cats.contains(&IrCheckCategory::DebugInfo));
        assert!(cats.contains(&IrCheckCategory::Attributes));
        assert!(cats.contains(&IrCheckCategory::CallingConv));
        assert!(cats.contains(&IrCheckCategory::Globals));
        assert!(cats.contains(&IrCheckCategory::AggregateAccess));
    }

    #[test]
    fn test_ir_gen_test_case_new() {
        let tc = IrGenTestCase::new(
            "test",
            "int main() { return 0; }",
            vec![],
            IrCheckCategory::ControlFlow,
        );
        assert_eq!(tc.name, "test");
        assert_eq!(tc.category, IrCheckCategory::ControlFlow);
    }

    #[test]
    fn test_ir_gen_all_checks_valid() {
        let suite = build_ir_gen_test_suite();
        for test in &suite {
            assert!(!test.name.is_empty());
            assert!(!test.source.is_empty());
            assert!(!test.checks.is_empty(), "test {} has no checks", test.name);
        }
    }
}