testing: measure coverage inside boolean expressions

[josharian]

Test coverage works on basic blocks. It could be extended to short-circuiting boolean
expressions like f() && g().

Approach:

func GoCoverBool(ret bool, n int) bool {
  GoCover.Count[n] = 1
  return ret
}

Rewrite f() && g() to f() && GoCoverBool(true, 5) && g() and f()
|| g() to f() || GoCoverBool(false, 5) || g().

I don't know what adjustments to the downstream tools this might require.

[JayNakrani]

This looks possible. The only change needed would be instrumentation. Rest of the tool chain would simply work, because we already encode column info with each block.

$ cat -n haha.go 
     1  package haha
     2  
     3  func Hihi() {
     4    a := true
     5    b := true
     6  
     7    if a && b {
     8      _ = 42
     9    }
    10  
    11    if a || b {
    12      _ = 42
    13    }
    14  }

$ go tool cover -mode=count haha.go | cat -n
     1  package haha
     2  
     3  func Hihi() {
     4    GoCover.Count[0]++
     5    a := true
     6    b := true
     7  
     8    if a && b {
     9      GoCover.Count[2]++
    10      _ = 42
    11    }
    12    GoCover.Count[1]++
    13  
    14    if a || b {
    15      GoCover.Count[3]++
    16      _ = 42
    17    }
    18  }
    19  
    20  var GoCover = struct {
    21    Count     [4]uint32
    22    Pos       [3 * 4]uint32
    23    NumStmt   [4]uint16
    24  } {
    25    Pos: [3 * 4]uint32{
    26      3, 7, 0xc000d, // [0]
    27      11, 11, 0xc0002, // [1]
    28      7, 9, 0x3000c, // [2]
    29      11, 13, 0x3000c, // [3]
    30    },
    31    NumStmt: [4]uint16{
    32      3, // 0
    33      1, // 1
    34      1, // 2
    35      1, // 3
    36    },
    37  }

Here's how each block looks like from above instrumentation. A block is denoted with i[...].

package haha

func Hihi() 0[{
  a := true
  b := true

  if a && b] 2[{
    _ = 42
  ]}

  1[if a || b] 3[{
    _ = 42
  ]}
}

If we wanted to measure code coverage inside boolean expressions, new blocks would look like following.

package haha

func Hihi() 0[{
  a := true
  b := true

  if a] 1[&& b] 4[{
    _ = 42
  ]}

  2[if a] 3[|| b] 5[{
    _ = 42
  ]}
}

Now the question is, do we see enough value in doing this?