pmat 3.11.0

// Tests for dead_code_prover
// Included from dead_code_prover.rs - do NOT add `use` imports or `#!` attributes here.

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    #[test]
    fn test_ffi_detection() {
        let mut tracker = FFIReferenceTracker::new();

        let content = r#"
            #[no_mangle]
            pub extern "C" fn exported_function() -> i32 {
                42
            }

            #[export_name = "custom_name"]
            pub fn renamed_export() -> i32 {
                200
            }

            fn internal_function() -> i32 {
                100
            }
        "#;

        tracker.scan_for_ffi_exports(content, "test.rs");

        let exported_symbol = SymbolId {
            file_path: "test.rs".to_string(),
            function_name: "exported_function".to_string(),
            line_number: 3,
        };

        let renamed_symbol = SymbolId {
            file_path: "test.rs".to_string(),
            function_name: "renamed_export".to_string(),
            line_number: 8,
        };

        let internal_symbol = SymbolId {
            file_path: "test.rs".to_string(),
            function_name: "internal_function".to_string(),
            line_number: 12,
        };

        assert!(tracker.is_externally_visible(&exported_symbol));
        assert!(tracker.is_externally_visible(&renamed_symbol));
        assert!(!tracker.is_externally_visible(&internal_symbol));
    }

    #[tokio::test]
    async fn test_dead_code_prover() {
        let temp_dir = TempDir::new().unwrap();
        let test_file = temp_dir.path().join("test.rs");

        let content = r#"
            #[no_mangle]
            pub extern "C" fn exported_function() -> i32 {
                42
            }

            fn possibly_dead_function() -> i32 {
                100
            }
        "#;

        tokio::fs::write(&test_file, content).await.unwrap();

        let mut prover = DeadCodeProver::new();
        let proofs = prover.analyze_file(&test_file, content);

        // Should have at least 1 proof since we scan for functions line by line
        assert!(!proofs.is_empty());

        // Check that we have some proofs (the exact number depends on parsing)
        assert!(!proofs.is_empty());

        // Print proofs for debugging
        println!("Found {} proofs", proofs.len());
        for proof in &proofs {
            println!(
                "Proof: {} confidence={:.2} type={:?}",
                proof.item.function_name, proof.confidence, proof.proof_type
            );
        }

        // Verify at least one proof has reasonable confidence
        let reasonable_confidence_proofs = proofs.iter().filter(|p| p.confidence >= 0.6).count();
        assert!(reasonable_confidence_proofs >= 1);
    }
}

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod property_tests {
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn basic_property_stability(_input in ".*") {
            // Basic property test for coverage
            prop_assert!(true);
        }

        #[test]
        fn module_consistency_check(_x in 0u32..1000) {
            // Module consistency verification
            prop_assert!(_x < 1001);
        }
    }
}