File: lazy-boolean.coverage

package info (click to toggle)
rustc 1.85.0%2Bdfsg3-1
  • links: PTS, VCS
  • area: main
  • in suites: experimental, sid, trixie
  • size: 893,396 kB
  • sloc: xml: 158,127; python: 35,830; javascript: 19,497; cpp: 19,002; sh: 17,245; ansic: 13,127; asm: 4,376; makefile: 1,051; perl: 29; lisp: 29; ruby: 19; sql: 11
file content (113 lines) | stat: -rw-r--r-- 4,217 bytes parent folder | download | duplicates (3)
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
   LL|       |#![feature(coverage_attribute)]
   LL|       |//@ edition: 2021
   LL|       |//@ compile-flags: -Zcoverage-options=branch
   LL|       |//@ llvm-cov-flags: --show-branches=count
   LL|       |
   LL|       |// Tests for branch coverage of the lazy boolean operators `&&` and `||`,
   LL|       |// as ordinary expressions that aren't part of an `if` condition or similar.
   LL|       |
   LL|       |use core::hint::black_box;
   LL|       |
   LL|       |// Helper macro to prevent start-of-function spans from being merged into
   LL|       |// spans on the lines we care about.
   LL|       |macro_rules! no_merge {
   LL|       |    () => {
   LL|       |        for _ in 0..1 {}
   LL|       |    };
   LL|       |}
   LL|       |
   LL|     15|fn branch_and(a: bool, b: bool) {
   LL|     15|    no_merge!();
   LL|       |
   LL|       |    //      |13  |18 (no branch)
   LL|     15|    let c = a && b;
                               ^12
  ------------------
  |  Branch (LL:13): [True: 12, False: 3]
  ------------------
   LL|     15|    black_box(c);
   LL|     15|}
   LL|       |
   LL|     15|fn branch_or(a: bool, b: bool) {
   LL|     15|    no_merge!();
   LL|       |
   LL|       |    //      |13  |18 (no branch)
   LL|     15|    let c = a || b;
                               ^3
  ------------------
  |  Branch (LL:13): [True: 12, False: 3]
  ------------------
   LL|     15|    black_box(c);
   LL|     15|}
   LL|       |
   LL|       |// Test for chaining one operator several times.
   LL|     16|fn chain(x: u32) {
   LL|     16|    no_merge!();
   LL|       |
   LL|       |    //      |13      |22      |31      |40 (no branch)
   LL|     16|    let c = x > 1 && x > 2 && x > 4 && x > 8;
                                   ^14      ^13      ^11
  ------------------
  |  Branch (LL:13): [True: 14, False: 2]
  |  Branch (LL:22): [True: 13, False: 1]
  |  Branch (LL:31): [True: 11, False: 2]
  ------------------
   LL|     16|    black_box(c);
   LL|       |
   LL|       |    //      |13      |22      |31      |40 (no branch)
   LL|     16|    let d = x < 1 || x < 2 || x < 4 || x < 8;
                                   ^15      ^14      ^12
  ------------------
  |  Branch (LL:13): [True: 1, False: 15]
  |  Branch (LL:22): [True: 1, False: 14]
  |  Branch (LL:31): [True: 2, False: 12]
  ------------------
   LL|     16|    black_box(d);
   LL|     16|}
   LL|       |
   LL|       |// Test for nested combinations of different operators.
   LL|     16|fn nested_mixed(x: u32) {
   LL|     16|    no_merge!();
   LL|       |
   LL|       |    //       |14      |23         |35      |44 (no branch)
   LL|     16|    let c = (x < 4 || x >= 9) && (x < 2 || x >= 10);
                                    ^12         ^11      ^9
  ------------------
  |  Branch (LL:14): [True: 4, False: 12]
  |  Branch (LL:23): [True: 7, False: 5]
  |  Branch (LL:35): [True: 2, False: 9]
  ------------------
   LL|     16|    black_box(c);
   LL|       |
   LL|       |    //       |14      |23        |34       |44 (no branch)
   LL|     16|    let d = (x < 4 && x < 1) || (x >= 8 && x >= 10);
                                    ^4         ^15       ^8
  ------------------
  |  Branch (LL:14): [True: 4, False: 12]
  |  Branch (LL:23): [True: 1, False: 3]
  |  Branch (LL:34): [True: 8, False: 7]
  ------------------
   LL|     16|    black_box(d);
   LL|     16|}
   LL|       |
   LL|       |#[coverage(off)]
   LL|       |fn main() {
   LL|       |    // Use each set of arguments (2^n) times, so that each combination has a
   LL|       |    // unique sum, and we can use those sums to verify expected control flow.
   LL|       |    // 1x (false, false)
   LL|       |    // 2x (false, true)
   LL|       |    // 4x (true, false)
   LL|       |    // 8x (true, true)
   LL|       |    for a in [false, true, true, true, true] {
   LL|       |        for b in [false, true, true] {
   LL|       |            branch_and(a, b);
   LL|       |            branch_or(a, b);
   LL|       |        }
   LL|       |    }
   LL|       |
   LL|       |    for x in 0..16 {
   LL|       |        chain(x);
   LL|       |        nested_mixed(x);
   LL|       |    }
   LL|       |}