lcov 0.8.2

LCOV tracefile parser/merger/filter in pure Rust.
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

use super::Record;
use super::Record::*;

fn check_parse_ok(s: &str, rec: &Record) {
    assert_eq!(s.parse::<Record>().unwrap(), *rec);
    assert_eq!(format!("{}\n", s).parse::<Record>().unwrap(), *rec);
    assert_eq!(format!("{}\r\n", s).parse::<Record>().unwrap(), *rec);
    assert_eq!(rec.to_string(), s);
}

#[test]
fn test_name() {
    fn check_ok(s: &str) {
        check_parse_ok(&format!("TN:{}", s), &TestName { name: s.into() });
    }
    check_ok("foo");
    check_ok("foo:bar");
    check_ok("foo:bar,baz");
}

#[test]
fn source_file() {
    fn check_ok(s: &str) {
        check_parse_ok(&format!("SF:{}", s), &SourceFile { path: s.into() })
    }
    check_ok("/foo/bar/baz");
    check_ok("C:/foo/bar/baz");
    check_ok(r"C:\foo\bar\baz");
}

#[test]
fn function_name() {
    fn check_ok(name: &str, line: u32) {
        check_parse_ok(
            &format!("FN:{},{}", line, name),
            &FunctionName {
                name: name.into(),
                start_line: line,
            },
        )
    }
    check_ok("hogehoge", 3);
    check_ok("3,5", 1);
}

#[test]
fn function_data() {
    fn check_ok(name: &str, count: u64) {
        check_parse_ok(
            &format!("FNDA:{},{}", count, name),
            &FunctionData {
                name: name.into(),
                count,
            },
        );
    }
    check_ok("hogehoge", 12345);
    check_ok("hoge,hoge", 98765);
}

#[test]
fn functions_found_hit() {
    fn check_ok(n: u32) {
        check_parse_ok(&format!("FNF:{}", n), &FunctionsFound { found: n });
        check_parse_ok(&format!("FNH:{}", n), &FunctionsHit { hit: n });
    }
    check_ok(0);
    check_ok(100);
    check_ok(u32::MAX);
}

#[test]
fn branch_data() {
    fn check_ok(line: u32, block: u32, branch: u32, taken: Option<u64>) {
        let s = if let Some(taken) = taken {
            format!("BRDA:{},{},{},{}", line, block, branch, taken)
        } else {
            format!("BRDA:{},{},{},-", line, block, branch)
        };
        check_parse_ok(
            &s,
            &BranchData {
                line,
                block,
                branch,
                taken,
            },
        );
    }
    check_ok(10, 20, 30, Some(40));
    check_ok(100, 200, 300, None);
}

#[test]
fn branches_found_hit() {
    fn check_ok(n: u32) {
        check_parse_ok(&format!("BRF:{}", n), &BranchesFound { found: n });
        check_parse_ok(&format!("BRH:{}", n), &BranchesHit { hit: n });
    }
    check_ok(0);
    check_ok(100);
    check_ok(u32::MAX);
}

#[test]
fn line_data() {
    fn check_ok(line: u32, count: u64, checksum: Option<String>) {
        let s = if let Some(ref checksum) = checksum {
            format!("DA:{},{},{}", line, count, checksum)
        } else {
            format!("DA:{},{}", line, count)
        };
        check_parse_ok(
            &s,
            &LineData {
                line,
                count,
                checksum,
            },
        );
    }
    check_ok(10, 20, None);
    check_ok(u32::MAX, u64::MAX, Some("hogehoge".into()));
    check_ok(u32::MAX, u64::MAX, Some("foo,bar,baz".into()));
}

#[test]
fn lines_found_hit() {
    fn check_ok(n: u32) {
        check_parse_ok(&format!("LF:{}", n), &LinesFound { found: n });
        check_parse_ok(&format!("LH:{}", n), &LinesHit { hit: n });
    }
    check_ok(0);
    check_ok(100);
    check_ok(u32::MAX);
}

#[test]
fn end_of_record() {
    check_parse_ok("end_of_record", &EndOfRecord);
}