covrs 0.2.3

Code coverage ingestion and reporting
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Uniform in-memory representation of coverage data, independent of any
//! specific format. Parsers produce a `CoverageData` which is then inserted
//! into the SQLite store.

/// Compute a coverage rate, returning 0.0 when the total is zero.
#[must_use]
pub fn rate(covered: u64, total: u64) -> f64 {
    if total == 0 {
        0.0
    } else {
        covered as f64 / total as f64
    }
}

/// A single line that was instrumentable.
#[derive(Debug, Clone)]
pub struct LineCoverage {
    pub line_number: u32,
    pub hit_count: u64,
}

/// A single branch arm on a given line.
#[derive(Debug, Clone)]
pub struct BranchCoverage {
    pub line_number: u32,
    pub branch_index: u32,
    pub hit_count: u64,
}

/// A function/method that was instrumentable.
#[derive(Debug, Clone)]
pub struct FunctionCoverage {
    pub name: String,
    pub start_line: Option<u32>,
    pub end_line: Option<u32>,
    pub hit_count: u64,
}

/// Coverage data for a single source file.
#[derive(Debug, Clone, Default)]
pub struct FileCoverage {
    pub path: String,
    pub lines: Vec<LineCoverage>,
    pub branches: Vec<BranchCoverage>,
    pub functions: Vec<FunctionCoverage>,
}

impl FileCoverage {
    pub fn new(path: String) -> Self {
        Self {
            path,
            ..Default::default()
        }
    }
}

/// The complete result of parsing a single coverage file.
#[derive(Debug, Clone, Default)]
pub struct CoverageData {
    pub files: Vec<FileCoverage>,
}

impl CoverageData {
    pub fn new() -> Self {
        Self::default()
    }
}

/// Summary stats across all reports in the database.
#[derive(Debug)]
pub struct ReportSummary {
    pub total_files: u64,
    pub total_lines: u64,
    pub covered_lines: u64,
    pub total_branches: u64,
    pub covered_branches: u64,
    pub total_functions: u64,
    pub covered_functions: u64,
}

impl ReportSummary {
    #[must_use]
    pub fn line_rate(&self) -> f64 {
        rate(self.covered_lines, self.total_lines)
    }

    #[must_use]
    pub fn branch_rate(&self) -> f64 {
        rate(self.covered_branches, self.total_branches)
    }

    #[must_use]
    pub fn function_rate(&self) -> f64 {
        rate(self.covered_functions, self.total_functions)
    }
}

/// Per-file summary row.
#[derive(Debug)]
pub struct FileSummary {
    pub path: String,
    pub total_lines: u64,
    pub covered_lines: u64,
    pub total_branches: u64,
    pub covered_branches: u64,
}

impl FileSummary {
    #[must_use]
    pub fn line_rate(&self) -> f64 {
        rate(self.covered_lines, self.total_lines)
    }
}

/// Line-level detail for a source file.
#[derive(Debug)]
pub struct LineDetail {
    pub line_number: u32,
    pub hit_count: u64,
}

/// Metadata for a stored report.
#[derive(Debug)]
pub struct ReportInfo {
    pub name: String,
    pub format: String,
    pub created_at: String,
}

/// Per-file diff coverage detail.
#[derive(Debug)]
pub struct FileDiffCoverage {
    pub path: String,
    /// Diff lines that are instrumentable and covered.
    pub covered_lines: Vec<u32>,
    /// Diff lines that are instrumentable and NOT covered.
    pub missed_lines: Vec<u32>,
}

impl FileDiffCoverage {
    #[must_use]
    pub fn total(&self) -> usize {
        self.covered_lines.len() + self.missed_lines.len()
    }

    #[must_use]
    pub fn rate(&self) -> f64 {
        rate(self.covered_lines.len() as u64, self.total() as u64)
    }
}