Skip to content

Commit cbcbf31

Browse files
ZalatharZalathar
committed
coverage: Add branch coverage tests
1 parent 816cbbc commit cbcbf31

9 files changed

+536
-0
lines changed

‎tests/coverage/branch_generics.cov-map

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
Function name: branch_generics::print_size::<()>
2+
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 06, 01, 01, 24, 05, 01, 25, 02, 06, 02, 02, 0c, 02, 06, 07, 03, 01, 00, 02]
3+
Number of files: 1
4+
- file 0 => global file 1
5+
Number of expressions: 2
6+
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
7+
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
8+
Number of file 0 mappings: 4
9+
- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 36)
10+
- Code(Counter(1)) at (prev + 1, 37) to (start + 2, 6)
11+
- Code(Expression(0, Sub)) at (prev + 2, 12) to (start + 2, 6)
12+
= (c0 - c1)
13+
- Code(Expression(1, Add)) at (prev + 3, 1) to (start + 0, 2)
14+
= (c1 + (c0 - c1))
15+
16+
Function name: branch_generics::print_size::<u32>
17+
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 06, 01, 01, 24, 05, 01, 25, 02, 06, 02, 02, 0c, 02, 06, 07, 03, 01, 00, 02]
18+
Number of files: 1
19+
- file 0 => global file 1
20+
Number of expressions: 2
21+
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
22+
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
23+
Number of file 0 mappings: 4
24+
- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 36)
25+
- Code(Counter(1)) at (prev + 1, 37) to (start + 2, 6)
26+
- Code(Expression(0, Sub)) at (prev + 2, 12) to (start + 2, 6)
27+
= (c0 - c1)
28+
- Code(Expression(1, Add)) at (prev + 3, 1) to (start + 0, 2)
29+
= (c1 + (c0 - c1))
30+
31+
Function name: branch_generics::print_size::<u64>
32+
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 06, 01, 01, 24, 05, 01, 25, 02, 06, 02, 02, 0c, 02, 06, 07, 03, 01, 00, 02]
33+
Number of files: 1
34+
- file 0 => global file 1
35+
Number of expressions: 2
36+
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
37+
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
38+
Number of file 0 mappings: 4
39+
- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 36)
40+
- Code(Counter(1)) at (prev + 1, 37) to (start + 2, 6)
41+
- Code(Expression(0, Sub)) at (prev + 2, 12) to (start + 2, 6)
42+
= (c0 - c1)
43+
- Code(Expression(1, Add)) at (prev + 3, 1) to (start + 0, 2)
44+
= (c1 + (c0 - c1))
45+

‎tests/coverage/branch_generics.coverage

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
LL| |#![feature(coverage_attribute)]
2+
LL| |//@ edition: 2021
3+
LL| |//@ compile-flags: -Zunstable-options -Cinstrument-coverage=branch
4+
LL| |//@ llvm-cov-flags: --show-branches=count
5+
LL| |
6+
LL| 3|fn print_size<T>() {
7+
LL| 3| if std::mem::size_of::<T>() > 4 {
8+
LL| 1| println!("size > 4");
9+
LL| 2| } else {
10+
LL| 2| println!("size <= 4");
11+
LL| 2| }
12+
LL| 3|}
13+
------------------
14+
| branch_generics::print_size::<()>:
15+
| LL| 1|fn print_size<T>() {
16+
| LL| 1| if std::mem::size_of::<T>() > 4 {
17+
| LL| 0| println!("size > 4");
18+
| LL| 1| } else {
19+
| LL| 1| println!("size <= 4");
20+
| LL| 1| }
21+
| LL| 1|}
22+
------------------
23+
| branch_generics::print_size::<u32>:
24+
| LL| 1|fn print_size<T>() {
25+
| LL| 1| if std::mem::size_of::<T>() > 4 {
26+
| LL| 0| println!("size > 4");
27+
| LL| 1| } else {
28+
| LL| 1| println!("size <= 4");
29+
| LL| 1| }
30+
| LL| 1|}
31+
------------------
32+
| branch_generics::print_size::<u64>:
33+
| LL| 1|fn print_size<T>() {
34+
| LL| 1| if std::mem::size_of::<T>() > 4 {
35+
| LL| 1| println!("size > 4");
36+
| LL| 1| } else {
37+
| LL| 0| println!("size <= 4");
38+
| LL| 0| }
39+
| LL| 1|}
40+
------------------
41+
LL| |
42+
LL| |#[coverage(off)]
43+
LL| |fn main() {
44+
LL| | print_size::<()>();
45+
LL| | print_size::<u32>();
46+
LL| | print_size::<u64>();
47+
LL| |}
48+

‎tests/coverage/branch_generics.rs

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
#![feature(coverage_attribute)]
2+
//@ edition: 2021
3+
//@ compile-flags: -Zunstable-options -Cinstrument-coverage=branch
4+
//@ llvm-cov-flags: --show-branches=count
5+
6+
fn print_size<T>() {
7+
if std::mem::size_of::<T>() > 4 {
8+
println!("size > 4");
9+
} else {
10+
println!("size <= 4");
11+
}
12+
}
13+
14+
#[coverage(off)]
15+
fn main() {
16+
print_size::<()>();
17+
print_size::<u32>();
18+
print_size::<u64>();
19+
}

‎tests/coverage/branch_if.cov-map

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,96 @@
1+
Function name: branch_if::branch_and
2+
Raw bytes (40): 0x[01, 01, 03, 06, 0d, 05, 09, 11, 03, 06, 01, 1d, 01, 01, 10, 05, 03, 08, 00, 09, 09, 00, 0d, 00, 0e, 11, 00, 0f, 02, 06, 03, 02, 0c, 02, 06, 0b, 03, 01, 00, 02]
3+
Number of files: 1
4+
- file 0 => global file 1
5+
Number of expressions: 3
6+
- expression 0 operands: lhs = Expression(1, Sub), rhs = Counter(3)
7+
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
8+
- expression 2 operands: lhs = Counter(4), rhs = Expression(0, Add)
9+
Number of file 0 mappings: 6
10+
- Code(Counter(0)) at (prev + 29, 1) to (start + 1, 16)
11+
- Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
12+
- Code(Counter(2)) at (prev + 0, 13) to (start + 0, 14)
13+
- Code(Counter(4)) at (prev + 0, 15) to (start + 2, 6)
14+
- Code(Expression(0, Add)) at (prev + 2, 12) to (start + 2, 6)
15+
= ((c1 - c2) + c3)
16+
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
17+
= (c4 + ((c1 - c2) + c3))
18+
19+
Function name: branch_if::branch_not
20+
Raw bytes (132): 0x[01, 01, 1d, 05, 09, 09, 02, 73, 0d, 09, 02, 0d, 6e, 73, 0d, 09, 02, 6b, 11, 0d, 6e, 73, 0d, 09, 02, 11, 66, 6b, 11, 0d, 6e, 73, 0d, 09, 02, 63, 15, 11, 66, 6b, 11, 0d, 6e, 73, 0d, 09, 02, 15, 5e, 63, 15, 11, 66, 6b, 11, 0d, 6e, 73, 0d, 09, 02, 0e, 01, 0c, 01, 01, 10, 05, 03, 08, 00, 09, 09, 01, 09, 00, 11, 02, 01, 06, 00, 07, 73, 01, 08, 00, 0a, 6e, 00, 0b, 02, 06, 0d, 02, 06, 00, 07, 6b, 01, 08, 00, 0b, 11, 00, 0c, 02, 06, 66, 02, 06, 00, 07, 63, 01, 08, 00, 0c, 5e, 00, 0d, 02, 06, 15, 02, 06, 00, 07, 5b, 01, 01, 00, 02]
21+
Number of files: 1
22+
- file 0 => global file 1
23+
Number of expressions: 29
24+
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
25+
- expression 1 operands: lhs = Counter(2), rhs = Expression(0, Sub)
26+
- expression 2 operands: lhs = Expression(28, Add), rhs = Counter(3)
27+
- expression 3 operands: lhs = Counter(2), rhs = Expression(0, Sub)
28+
- expression 4 operands: lhs = Counter(3), rhs = Expression(27, Sub)
29+
- expression 5 operands: lhs = Expression(28, Add), rhs = Counter(3)
30+
- expression 6 operands: lhs = Counter(2), rhs = Expression(0, Sub)
31+
- expression 7 operands: lhs = Expression(26, Add), rhs = Counter(4)
32+
- expression 8 operands: lhs = Counter(3), rhs = Expression(27, Sub)
33+
- expression 9 operands: lhs = Expression(28, Add), rhs = Counter(3)
34+
- expression 10 operands: lhs = Counter(2), rhs = Expression(0, Sub)
35+
- expression 11 operands: lhs = Counter(4), rhs = Expression(25, Sub)
36+
- expression 12 operands: lhs = Expression(26, Add), rhs = Counter(4)
37+
- expression 13 operands: lhs = Counter(3), rhs = Expression(27, Sub)
38+
- expression 14 operands: lhs = Expression(28, Add), rhs = Counter(3)
39+
- expression 15 operands: lhs = Counter(2), rhs = Expression(0, Sub)
40+
- expression 16 operands: lhs = Expression(24, Add), rhs = Counter(5)
41+
- expression 17 operands: lhs = Counter(4), rhs = Expression(25, Sub)
42+
- expression 18 operands: lhs = Expression(26, Add), rhs = Counter(4)
43+
- expression 19 operands: lhs = Counter(3), rhs = Expression(27, Sub)
44+
- expression 20 operands: lhs = Expression(28, Add), rhs = Counter(3)
45+
- expression 21 operands: lhs = Counter(2), rhs = Expression(0, Sub)
46+
- expression 22 operands: lhs = Counter(5), rhs = Expression(23, Sub)
47+
- expression 23 operands: lhs = Expression(24, Add), rhs = Counter(5)
48+
- expression 24 operands: lhs = Counter(4), rhs = Expression(25, Sub)
49+
- expression 25 operands: lhs = Expression(26, Add), rhs = Counter(4)
50+
- expression 26 operands: lhs = Counter(3), rhs = Expression(27, Sub)
51+
- expression 27 operands: lhs = Expression(28, Add), rhs = Counter(3)
52+
- expression 28 operands: lhs = Counter(2), rhs = Expression(0, Sub)
53+
Number of file 0 mappings: 14
54+
- Code(Counter(0)) at (prev + 12, 1) to (start + 1, 16)
55+
- Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
56+
- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 17)
57+
- Code(Expression(0, Sub)) at (prev + 1, 6) to (start + 0, 7)
58+
= (c1 - c2)
59+
- Code(Expression(28, Add)) at (prev + 1, 8) to (start + 0, 10)
60+
= (c2 + (c1 - c2))
61+
- Code(Expression(27, Sub)) at (prev + 0, 11) to (start + 2, 6)
62+
= ((c2 + (c1 - c2)) - c3)
63+
- Code(Counter(3)) at (prev + 2, 6) to (start + 0, 7)
64+
- Code(Expression(26, Add)) at (prev + 1, 8) to (start + 0, 11)
65+
= (c3 + ((c2 + (c1 - c2)) - c3))
66+
- Code(Counter(4)) at (prev + 0, 12) to (start + 2, 6)
67+
- Code(Expression(25, Sub)) at (prev + 2, 6) to (start + 0, 7)
68+
= ((c3 + ((c2 + (c1 - c2)) - c3)) - c4)
69+
- Code(Expression(24, Add)) at (prev + 1, 8) to (start + 0, 12)
70+
= (c4 + ((c3 + ((c2 + (c1 - c2)) - c3)) - c4))
71+
- Code(Expression(23, Sub)) at (prev + 0, 13) to (start + 2, 6)
72+
= ((c4 + ((c3 + ((c2 + (c1 - c2)) - c3)) - c4)) - c5)
73+
- Code(Counter(5)) at (prev + 2, 6) to (start + 0, 7)
74+
- Code(Expression(22, Add)) at (prev + 1, 1) to (start + 0, 2)
75+
= (c5 + ((c4 + ((c3 + ((c2 + (c1 - c2)) - c3)) - c4)) - c5))
76+
77+
Function name: branch_if::branch_or
78+
Raw bytes (42): 0x[01, 01, 04, 05, 09, 09, 0d, 0f, 11, 09, 0d, 06, 01, 27, 01, 01, 10, 05, 03, 08, 00, 09, 02, 00, 0d, 00, 0e, 0f, 00, 0f, 02, 06, 11, 02, 0c, 02, 06, 0b, 03, 01, 00, 02]
79+
Number of files: 1
80+
- file 0 => global file 1
81+
Number of expressions: 4
82+
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
83+
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
84+
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(4)
85+
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
86+
Number of file 0 mappings: 6
87+
- Code(Counter(0)) at (prev + 39, 1) to (start + 1, 16)
88+
- Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
89+
- Code(Expression(0, Sub)) at (prev + 0, 13) to (start + 0, 14)
90+
= (c1 - c2)
91+
- Code(Expression(3, Add)) at (prev + 0, 15) to (start + 2, 6)
92+
= (c2 + c3)
93+
- Code(Counter(4)) at (prev + 2, 12) to (start + 2, 6)
94+
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
95+
= ((c2 + c3) + c4)
96+

‎tests/coverage/branch_if.coverage

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
LL| |#![feature(coverage_attribute)]
2+
LL| |//@ edition: 2021
3+
LL| |//@ compile-flags: -Zunstable-options -Cinstrument-coverage=branch
4+
LL| |//@ llvm-cov-flags: --show-branches=count
5+
LL| |
6+
LL| |macro_rules! no_merge {
7+
LL| | () => {
8+
LL| | for _ in 0..1 {}
9+
LL| | };
10+
LL| |}
11+
LL| |
12+
LL| 3|fn branch_not(a: bool) {
13+
LL| 3| no_merge!();
14+
LL| |
15+
LL| 3| if a {
16+
LL| 2| say("a")
17+
LL| 1| }
18+
LL| 3| if !a {
19+
LL| 1| say("not a");
20+
LL| 2| }
21+
LL| 3| if !!a {
22+
LL| 2| say("not not a");
23+
LL| 2| }
24+
^1
25+
LL| 3| if !!!a {
26+
LL| 1| say("not not not a");
27+
LL| 2| }
28+
LL| 3|}
29+
LL| |
30+
LL| 15|fn branch_and(a: bool, b: bool) {
31+
LL| 15| no_merge!();
32+
LL| |
33+
LL| 15| if a && b {
34+
^12
35+
LL| 8| say("both");
36+
LL| 8| } else {
37+
LL| 7| say("not both");
38+
LL| 7| }
39+
LL| 15|}
40+
LL| |
41+
LL| 15|fn branch_or(a: bool, b: bool) {
42+
LL| 15| no_merge!();
43+
LL| |
44+
LL| 15| if a || b {
45+
^3
46+
LL| 14| say("either");
47+
LL| 14| } else {
48+
LL| 1| say("neither");
49+
LL| 1| }
50+
LL| 15|}
51+
LL| |
52+
LL| |#[coverage(off)]
53+
LL| |fn say(message: &str) {
54+
LL| | core::hint::black_box(message);
55+
LL| |}
56+
LL| |
57+
LL| |#[coverage(off)]
58+
LL| |fn main() {
59+
LL| | for a in [false, true, true] {
60+
LL| | branch_not(a);
61+
LL| | }
62+
LL| |
63+
LL| | for a in [false, true, true, true, true] {
64+
LL| | for b in [false, true, true] {
65+
LL| | branch_and(a, b);
66+
LL| | branch_or(a, b);
67+
LL| | }
68+
LL| | }
69+
LL| |}
70+

‎tests/coverage/branch_if.rs

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
#![feature(coverage_attribute)]
2+
//@ edition: 2021
3+
//@ compile-flags: -Zunstable-options -Cinstrument-coverage=branch
4+
//@ llvm-cov-flags: --show-branches=count
5+
6+
macro_rules! no_merge {
7+
() => {
8+
for _ in 0..1 {}
9+
};
10+
}
11+
12+
fn branch_not(a: bool) {
13+
no_merge!();
14+
15+
if a {
16+
say("a")
17+
}
18+
if !a {
19+
say("not a");
20+
}
21+
if !!a {
22+
say("not not a");
23+
}
24+
if !!!a {
25+
say("not not not a");
26+
}
27+
}
28+
29+
fn branch_and(a: bool, b: bool) {
30+
no_merge!();
31+
32+
if a && b {
33+
say("both");
34+
} else {
35+
say("not both");
36+
}
37+
}
38+
39+
fn branch_or(a: bool, b: bool) {
40+
no_merge!();
41+
42+
if a || b {
43+
say("either");
44+
} else {
45+
say("neither");
46+
}
47+
}
48+
49+
#[coverage(off)]
50+
fn say(message: &str) {
51+
core::hint::black_box(message);
52+
}
53+
54+
#[coverage(off)]
55+
fn main() {
56+
for a in [false, true, true] {
57+
branch_not(a);
58+
}
59+
60+
for a in [false, true, true, true, true] {
61+
for b in [false, true, true] {
62+
branch_and(a, b);
63+
branch_or(a, b);
64+
}
65+
}
66+
}

0 commit comments

Comments
 (0)