ferrous-forge 1.9.6

System-wide Rust development standards enforcer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Test coverage module tests

#[cfg(test)]
#[allow(
    clippy::unwrap_used,
    clippy::expect_used,
    clippy::panic,
    clippy::module_inception
)]
mod tests {
    use super::super::*;
    use std::collections::HashMap;

    #[test]
    fn test_coverage_config_default() {
        let config = CoverageConfig::default();
        assert_eq!(config.min_line_coverage, 80.0);
        assert_eq!(config.min_function_coverage, 85.0);
        assert_eq!(config.min_branch_coverage, 75.0);
        assert!(config.fail_on_low_coverage);
    }

    #[test]
    fn test_coverage_analyzer_creation() {
        let analyzer = CoverageAnalyzer::new();
        assert_eq!(analyzer.config().min_line_coverage, 80.0);

        let custom_config = CoverageConfig {
            min_line_coverage: 90.0,
            ..Default::default()
        };
        let custom_analyzer = CoverageAnalyzer::with_config(custom_config);
        assert_eq!(custom_analyzer.config().min_line_coverage, 90.0);
    }

    #[test]
    fn test_validate_coverage_success() {
        let analyzer = CoverageAnalyzer::new();
        let report = CoverageReport {
            line_coverage: 85.0,
            function_coverage: 90.0,
            branch_coverage: 80.0,
            file_coverage: HashMap::new(),
            lines_tested: 85,
            total_lines: 100,
            functions_tested: 18,
            total_functions: 20,
            branches_tested: 8,
            total_branches: 10,
        };

        assert!(analyzer.validate_coverage(&report).is_ok());
    }

    #[test]
    fn test_validate_coverage_failure() {
        let analyzer = CoverageAnalyzer::new();
        let report = CoverageReport {
            line_coverage: 70.0, // Below 80% minimum
            function_coverage: 90.0,
            branch_coverage: 80.0,
            file_coverage: HashMap::new(),
            lines_tested: 70,
            total_lines: 100,
            functions_tested: 18,
            total_functions: 20,
            branches_tested: 8,
            total_branches: 10,
        };

        assert!(analyzer.validate_coverage(&report).is_err());
    }

    #[test]
    fn test_format_coverage_report() {
        let analyzer = CoverageAnalyzer::new();
        let report = CoverageReport {
            line_coverage: 85.0,
            function_coverage: 90.0,
            branch_coverage: 80.0,
            file_coverage: HashMap::new(),
            lines_tested: 85,
            total_lines: 100,
            functions_tested: 18,
            total_functions: 20,
            branches_tested: 8,
            total_branches: 10,
        };

        let formatted = analyzer.format_coverage_report(&report);
        assert!(formatted.contains("Test Coverage Report"));
        assert!(formatted.contains("85.0%"));
        assert!(formatted.contains("90.0%"));
        assert!(formatted.contains("80.0%"));
    }
}