Skip to content

Commit 45d7ccc

Browse files
ZalatharZalathar
committed
coverage: Add branch coverage tests (with branch coverage disabled)
1 parent 094a620 commit 45d7ccc

9 files changed

+607
-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| |
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+
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: 136 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,136 @@
1+
Function name: branch_if::branch_and
2+
Raw bytes (40): 0x[01, 01, 03, 06, 0d, 05, 09, 11, 03, 06, 01, 2b, 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 + 43, 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_not_as
78+
Raw bytes (91): 0x[01, 01, 10, 05, 09, 09, 02, 3f, 0d, 09, 02, 0d, 3a, 3f, 0d, 09, 02, 37, 11, 0d, 3a, 3f, 0d, 09, 02, 11, 32, 37, 11, 0d, 3a, 3f, 0d, 09, 02, 0b, 01, 1d, 01, 01, 10, 05, 03, 08, 00, 14, 02, 00, 15, 02, 06, 09, 02, 06, 00, 07, 3f, 01, 08, 00, 15, 0d, 00, 16, 02, 06, 3a, 02, 06, 00, 07, 37, 01, 08, 00, 16, 32, 00, 17, 02, 06, 11, 02, 06, 00, 07, 2f, 01, 01, 00, 02]
79+
Number of files: 1
80+
- file 0 => global file 1
81+
Number of expressions: 16
82+
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
83+
- expression 1 operands: lhs = Counter(2), rhs = Expression(0, Sub)
84+
- expression 2 operands: lhs = Expression(15, Add), rhs = Counter(3)
85+
- expression 3 operands: lhs = Counter(2), rhs = Expression(0, Sub)
86+
- expression 4 operands: lhs = Counter(3), rhs = Expression(14, Sub)
87+
- expression 5 operands: lhs = Expression(15, Add), rhs = Counter(3)
88+
- expression 6 operands: lhs = Counter(2), rhs = Expression(0, Sub)
89+
- expression 7 operands: lhs = Expression(13, Add), rhs = Counter(4)
90+
- expression 8 operands: lhs = Counter(3), rhs = Expression(14, Sub)
91+
- expression 9 operands: lhs = Expression(15, Add), rhs = Counter(3)
92+
- expression 10 operands: lhs = Counter(2), rhs = Expression(0, Sub)
93+
- expression 11 operands: lhs = Counter(4), rhs = Expression(12, Sub)
94+
- expression 12 operands: lhs = Expression(13, Add), rhs = Counter(4)
95+
- expression 13 operands: lhs = Counter(3), rhs = Expression(14, Sub)
96+
- expression 14 operands: lhs = Expression(15, Add), rhs = Counter(3)
97+
- expression 15 operands: lhs = Counter(2), rhs = Expression(0, Sub)
98+
Number of file 0 mappings: 11
99+
- Code(Counter(0)) at (prev + 29, 1) to (start + 1, 16)
100+
- Code(Counter(1)) at (prev + 3, 8) to (start + 0, 20)
101+
- Code(Expression(0, Sub)) at (prev + 0, 21) to (start + 2, 6)
102+
= (c1 - c2)
103+
- Code(Counter(2)) at (prev + 2, 6) to (start + 0, 7)
104+
- Code(Expression(15, Add)) at (prev + 1, 8) to (start + 0, 21)
105+
= (c2 + (c1 - c2))
106+
- Code(Counter(3)) at (prev + 0, 22) to (start + 2, 6)
107+
- Code(Expression(14, Sub)) at (prev + 2, 6) to (start + 0, 7)
108+
= ((c2 + (c1 - c2)) - c3)
109+
- Code(Expression(13, Add)) at (prev + 1, 8) to (start + 0, 22)
110+
= (c3 + ((c2 + (c1 - c2)) - c3))
111+
- Code(Expression(12, Sub)) at (prev + 0, 23) to (start + 2, 6)
112+
= ((c3 + ((c2 + (c1 - c2)) - c3)) - c4)
113+
- Code(Counter(4)) at (prev + 2, 6) to (start + 0, 7)
114+
- Code(Expression(11, Add)) at (prev + 1, 1) to (start + 0, 2)
115+
= (c4 + ((c3 + ((c2 + (c1 - c2)) - c3)) - c4))
116+
117+
Function name: branch_if::branch_or
118+
Raw bytes (42): 0x[01, 01, 04, 05, 09, 09, 0d, 0f, 11, 09, 0d, 06, 01, 35, 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]
119+
Number of files: 1
120+
- file 0 => global file 1
121+
Number of expressions: 4
122+
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
123+
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
124+
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(4)
125+
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
126+
Number of file 0 mappings: 6
127+
- Code(Counter(0)) at (prev + 53, 1) to (start + 1, 16)
128+
- Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
129+
- Code(Expression(0, Sub)) at (prev + 0, 13) to (start + 0, 14)
130+
= (c1 - c2)
131+
- Code(Expression(3, Add)) at (prev + 0, 15) to (start + 2, 6)
132+
= (c2 + c3)
133+
- Code(Counter(4)) at (prev + 2, 12) to (start + 2, 6)
134+
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
135+
= ((c2 + c3) + c4)
136+

‎tests/coverage/branch_if.coverage

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
LL| |#![feature(coverage_attribute)]
2+
LL| |//@ edition: 2021
3+
LL| |
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| 3|fn branch_not_as(a: bool) {
31+
LL| 3| no_merge!();
32+
LL| |
33+
LL| 3| if !(a as bool) {
34+
LL| 1| say("not (a as bool)");
35+
LL| 2| }
36+
LL| 3| if !!(a as bool) {
37+
LL| 2| say("not not (a as bool)");
38+
LL| 2| }
39+
^1
40+
LL| 3| if !!!(a as bool) {
41+
LL| 1| say("not not (a as bool)");
42+
LL| 2| }
43+
LL| 3|}
44+
LL| |
45+
LL| 15|fn branch_and(a: bool, b: bool) {
46+
LL| 15| no_merge!();
47+
LL| |
48+
LL| 15| if a && b {
49+
^12
50+
LL| 8| say("both");
51+
LL| 8| } else {
52+
LL| 7| say("not both");
53+
LL| 7| }
54+
LL| 15|}
55+
LL| |
56+
LL| 15|fn branch_or(a: bool, b: bool) {
57+
LL| 15| no_merge!();
58+
LL| |
59+
LL| 15| if a || b {
60+
^3
61+
LL| 14| say("either");
62+
LL| 14| } else {
63+
LL| 1| say("neither");
64+
LL| 1| }
65+
LL| 15|}
66+
LL| |
67+
LL| |#[coverage(off)]
68+
LL| |fn say(message: &str) {
69+
LL| | core::hint::black_box(message);
70+
LL| |}
71+
LL| |
72+
LL| |#[coverage(off)]
73+
LL| |fn main() {
74+
LL| | for a in [false, true, true] {
75+
LL| | branch_not(a);
76+
LL| | branch_not_as(a);
77+
LL| | }
78+
LL| |
79+
LL| | for a in [false, true, true, true, true] {
80+
LL| | for b in [false, true, true] {
81+
LL| | branch_and(a, b);
82+
LL| | branch_or(a, b);
83+
LL| | }
84+
LL| | }
85+
LL| |}
86+

0 commit comments

Comments
 (0)