mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
runtime/coverage: apis to emit counter data under user control
Add hooks/apis to support writing of coverage counter data and meta-data under user control (from within an executing "-cover" binary), so as to provide a way to obtain coverage data from programs that do not terminate. This patch also adds a hook for clearing the coverage counter data for a running program, something that can be helpful when the intent is to capture coverage info from a specific window of program execution. Updates #51430. Change-Id: I34ee6cee52e5597fa3698b8b04f1b34a2a2a418f Reviewed-on: https://go-review.googlesource.com/c/go/+/401236 Reviewed-by: David Chase <drchase@google.com>
This commit is contained in:
Than McIntosh
parent
f2ee341468
commit
ecd112c0d1
5 changed files with 887 additions and 1 deletions
404
src/runtime/coverage/emitdata_test.go
Normal file
404
src/runtime/coverage/emitdata_test.go
Normal file
|
|
@ -0,0 +1,404 @@
|
|||
// Copyright 2022 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package coverage
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"internal/coverage"
|
||||
"internal/goexperiment"
|
||||
"internal/testenv"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Set to true for debugging (linux only).
|
||||
const fixedTestDir = false
|
||||
|
||||
func TestCoverageApis(t *testing.T) {
|
||||
if !goexperiment.CoverageRedesign {
|
||||
t.Skipf("skipping new coverage tests (experiment not enabled)")
|
||||
}
|
||||
testenv.MustHaveGoBuild(t)
|
||||
dir := t.TempDir()
|
||||
if fixedTestDir {
|
||||
dir = "/tmp/qqqzzz"
|
||||
os.RemoveAll(dir)
|
||||
mkdir(t, dir)
|
||||
}
|
||||
|
||||
// Build harness.
|
||||
bdir := mkdir(t, filepath.Join(dir, "build"))
|
||||
hargs := []string{"-cover", "-coverpkg=all"}
|
||||
if testing.CoverMode() != "" {
|
||||
hargs = append(hargs, "-covermode="+testing.CoverMode())
|
||||
}
|
||||
harnessPath := buildHarness(t, bdir, hargs)
|
||||
|
||||
t.Logf("harness path is %s", harnessPath)
|
||||
|
||||
// Sub-tests for each API we want to inspect, plus
|
||||
// extras for error testing.
|
||||
t.Run("emitToDir", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
testEmitToDir(t, harnessPath, dir)
|
||||
})
|
||||
t.Run("emitToWriter", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
testEmitToWriter(t, harnessPath, dir)
|
||||
})
|
||||
t.Run("emitToNonexistentDir", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
testEmitToNonexistentDir(t, harnessPath, dir)
|
||||
})
|
||||
t.Run("emitToNilWriter", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
testEmitToNilWriter(t, harnessPath, dir)
|
||||
})
|
||||
t.Run("emitToFailingWriter", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
testEmitToFailingWriter(t, harnessPath, dir)
|
||||
})
|
||||
t.Run("emitWithCounterClear", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
testEmitWithCounterClear(t, harnessPath, dir)
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
// upmergeCoverData helps improve coverage data for this package
|
||||
// itself. If this test itself is being invoked with "-cover", then
|
||||
// what we'd like is for package coverage data (that is, coverage for
|
||||
// routines in "runtime/coverage") to be incorporated into the test
|
||||
// run from the "harness.exe" runs we've just done. We can accomplish
|
||||
// this by doing a merge from the harness gocoverdir's to the test
|
||||
// gocoverdir.
|
||||
func upmergeCoverData(t *testing.T, gocoverdir string) {
|
||||
if testing.CoverMode() == "" {
|
||||
return
|
||||
}
|
||||
testGoCoverDir := os.Getenv("GOCOVERDIR")
|
||||
if testGoCoverDir == "" {
|
||||
return
|
||||
}
|
||||
args := []string{"tool", "covdata", "merge", "-pkg=runtime/coverage",
|
||||
"-o", testGoCoverDir, "-i", gocoverdir}
|
||||
t.Logf("up-merge of covdata from %s to %s", gocoverdir, testGoCoverDir)
|
||||
t.Logf("executing: go %+v", args)
|
||||
cmd := exec.Command(testenv.GoToolPath(t), args...)
|
||||
if b, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("covdata merge failed (%v): %s", err, b)
|
||||
}
|
||||
}
|
||||
|
||||
// buildHarness builds the helper program "harness.exe".
|
||||
func buildHarness(t *testing.T, dir string, opts []string) string {
|
||||
harnessPath := filepath.Join(dir, "harness.exe")
|
||||
harnessSrc := filepath.Join("testdata", "harness.go")
|
||||
args := []string{"build", "-o", harnessPath}
|
||||
args = append(args, opts...)
|
||||
args = append(args, harnessSrc)
|
||||
//t.Logf("harness build: go %+v\n", args)
|
||||
cmd := exec.Command(testenv.GoToolPath(t), args...)
|
||||
if b, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("build failed (%v): %s", err, b)
|
||||
}
|
||||
return harnessPath
|
||||
}
|
||||
|
||||
func mkdir(t *testing.T, d string) string {
|
||||
t.Helper()
|
||||
if err := os.Mkdir(d, 0777); err != nil {
|
||||
t.Fatalf("mkdir failed: %v", err)
|
||||
}
|
||||
return d
|
||||
}
|
||||
|
||||
// updateGoCoverDir updates the specified environment 'env' to set
|
||||
// GOCOVERDIR to 'gcd' (if setGoCoverDir is TRUE) or removes
|
||||
// GOCOVERDIR from the environment (if setGoCoverDir is false).
|
||||
func updateGoCoverDir(env []string, gcd string, setGoCoverDir bool) []string {
|
||||
rv := []string{}
|
||||
found := false
|
||||
for _, v := range env {
|
||||
if strings.HasPrefix(v, "GOCOVERDIR=") {
|
||||
if !setGoCoverDir {
|
||||
continue
|
||||
}
|
||||
v = "GOCOVERDIR=" + gcd
|
||||
found = true
|
||||
}
|
||||
rv = append(rv, v)
|
||||
}
|
||||
if !found && setGoCoverDir {
|
||||
rv = append(rv, "GOCOVERDIR="+gcd)
|
||||
}
|
||||
return rv
|
||||
}
|
||||
|
||||
func runHarness(t *testing.T, harnessPath string, tp string, setGoCoverDir bool, rdir, edir string) (string, error) {
|
||||
t.Logf("running: %s -tp %s -o %s with rdir=%s and GOCOVERDIR=%v", harnessPath, tp, edir, rdir, setGoCoverDir)
|
||||
cmd := exec.Command(harnessPath, "-tp", tp, "-o", edir)
|
||||
cmd.Dir = rdir
|
||||
cmd.Env = updateGoCoverDir(os.Environ(), rdir, setGoCoverDir)
|
||||
b, err := cmd.CombinedOutput()
|
||||
//t.Logf("harness run output: %s\n", string(b))
|
||||
return string(b), err
|
||||
}
|
||||
|
||||
func testForSpecificFunctions(t *testing.T, dir string, want []string, avoid []string) string {
|
||||
args := []string{"tool", "covdata", "debugdump",
|
||||
"-live", "-pkg=main", "-i=" + dir}
|
||||
t.Logf("running: go %v\n", args)
|
||||
cmd := exec.Command(testenv.GoToolPath(t), args...)
|
||||
b, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("'go tool covdata failed (%v): %s", err, b)
|
||||
}
|
||||
output := string(b)
|
||||
rval := ""
|
||||
for _, f := range want {
|
||||
wf := "Func: " + f
|
||||
if strings.Contains(output, wf) {
|
||||
continue
|
||||
}
|
||||
rval += fmt.Sprintf("error: output should contain %q but does not\n", wf)
|
||||
}
|
||||
for _, f := range avoid {
|
||||
wf := "Func: " + f
|
||||
if strings.Contains(output, wf) {
|
||||
rval += fmt.Sprintf("error: output should not contain %q but does\n", wf)
|
||||
}
|
||||
}
|
||||
return rval
|
||||
}
|
||||
|
||||
func withAndWithoutRunner(f func(setit bool, tag string)) {
|
||||
// Run 'f' with and without GOCOVERDIR set.
|
||||
for i := 0; i < 2; i++ {
|
||||
tag := "x"
|
||||
setGoCoverDir := true
|
||||
if i == 0 {
|
||||
setGoCoverDir = false
|
||||
tag = "y"
|
||||
}
|
||||
f(setGoCoverDir, tag)
|
||||
}
|
||||
}
|
||||
|
||||
func mktestdirs(t *testing.T, tag, tp, dir string) (string, string) {
|
||||
t.Helper()
|
||||
rdir := mkdir(t, filepath.Join(dir, tp+"-rdir-"+tag))
|
||||
edir := mkdir(t, filepath.Join(dir, tp+"-edir-"+tag))
|
||||
return rdir, edir
|
||||
}
|
||||
|
||||
func testEmitToDir(t *testing.T, harnessPath string, dir string) {
|
||||
withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
|
||||
tp := "emitToDir"
|
||||
rdir, edir := mktestdirs(t, tag, tp, dir)
|
||||
output, err := runHarness(t, harnessPath, tp,
|
||||
setGoCoverDir, rdir, edir)
|
||||
if err != nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running 'harness -tp emitDir': %v", err)
|
||||
}
|
||||
|
||||
// Just check to make sure meta-data file and counter data file were
|
||||
// written. Another alternative would be to run "go tool covdata"
|
||||
// or equivalent, but for now, this is what we've got.
|
||||
dents, err := os.ReadDir(edir)
|
||||
if err != nil {
|
||||
t.Fatalf("os.ReadDir(%s) failed: %v", edir, err)
|
||||
}
|
||||
mfc := 0
|
||||
cdc := 0
|
||||
for _, e := range dents {
|
||||
if e.IsDir() {
|
||||
continue
|
||||
}
|
||||
if strings.HasPrefix(e.Name(), coverage.MetaFilePref) {
|
||||
mfc++
|
||||
} else if strings.HasPrefix(e.Name(), coverage.CounterFilePref) {
|
||||
cdc++
|
||||
}
|
||||
}
|
||||
wantmf := 1
|
||||
wantcf := 1
|
||||
if mfc != wantmf {
|
||||
t.Errorf("EmitToDir: want %d meta-data files, got %d\n", wantmf, mfc)
|
||||
}
|
||||
if cdc != wantcf {
|
||||
t.Errorf("EmitToDir: want %d counter-data files, got %d\n", wantcf, cdc)
|
||||
}
|
||||
upmergeCoverData(t, edir)
|
||||
upmergeCoverData(t, rdir)
|
||||
})
|
||||
}
|
||||
|
||||
func testEmitToWriter(t *testing.T, harnessPath string, dir string) {
|
||||
withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
|
||||
tp := "emitToWriter"
|
||||
rdir, edir := mktestdirs(t, tag, tp, dir)
|
||||
output, err := runHarness(t, harnessPath, tp, setGoCoverDir, rdir, edir)
|
||||
if err != nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running 'harness -tp %s': %v", tp, err)
|
||||
}
|
||||
want := []string{"main", tp}
|
||||
avoid := []string{"final"}
|
||||
if msg := testForSpecificFunctions(t, edir, want, avoid); msg != "" {
|
||||
t.Errorf("coverage data from %q output match failed: %s", tp, msg)
|
||||
}
|
||||
upmergeCoverData(t, edir)
|
||||
upmergeCoverData(t, rdir)
|
||||
})
|
||||
}
|
||||
|
||||
func testEmitToNonexistentDir(t *testing.T, harnessPath string, dir string) {
|
||||
withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
|
||||
tp := "emitToNonexistentDir"
|
||||
rdir, edir := mktestdirs(t, tag, tp, dir)
|
||||
output, err := runHarness(t, harnessPath, tp, setGoCoverDir, rdir, edir)
|
||||
if err != nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running 'harness -tp %s': %v", tp, err)
|
||||
}
|
||||
upmergeCoverData(t, edir)
|
||||
upmergeCoverData(t, rdir)
|
||||
})
|
||||
}
|
||||
|
||||
func testEmitToUnwritableDir(t *testing.T, harnessPath string, dir string) {
|
||||
withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
|
||||
|
||||
tp := "emitToUnwritableDir"
|
||||
rdir, edir := mktestdirs(t, tag, tp, dir)
|
||||
|
||||
// Make edir unwritable.
|
||||
if err := os.Chmod(edir, 0555); err != nil {
|
||||
t.Fatalf("chmod failed: %v", err)
|
||||
}
|
||||
defer os.Chmod(edir, 0777)
|
||||
|
||||
output, err := runHarness(t, harnessPath, tp, setGoCoverDir, rdir, edir)
|
||||
if err != nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running 'harness -tp %s': %v", tp, err)
|
||||
}
|
||||
upmergeCoverData(t, edir)
|
||||
upmergeCoverData(t, rdir)
|
||||
})
|
||||
}
|
||||
|
||||
func testEmitToNilWriter(t *testing.T, harnessPath string, dir string) {
|
||||
withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
|
||||
tp := "emitToNilWriter"
|
||||
rdir, edir := mktestdirs(t, tag, tp, dir)
|
||||
output, err := runHarness(t, harnessPath, tp, setGoCoverDir, rdir, edir)
|
||||
if err != nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running 'harness -tp %s': %v", tp, err)
|
||||
}
|
||||
upmergeCoverData(t, edir)
|
||||
upmergeCoverData(t, rdir)
|
||||
})
|
||||
}
|
||||
|
||||
func testEmitToFailingWriter(t *testing.T, harnessPath string, dir string) {
|
||||
withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
|
||||
tp := "emitToFailingWriter"
|
||||
rdir, edir := mktestdirs(t, tag, tp, dir)
|
||||
output, err := runHarness(t, harnessPath, tp, setGoCoverDir, rdir, edir)
|
||||
if err != nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running 'harness -tp %s': %v", tp, err)
|
||||
}
|
||||
upmergeCoverData(t, edir)
|
||||
upmergeCoverData(t, rdir)
|
||||
})
|
||||
}
|
||||
|
||||
func testEmitWithCounterClear(t *testing.T, harnessPath string, dir string) {
|
||||
// Ensure that we have two versions of the harness: one built with
|
||||
// -covermode=atomic and one built with -covermode=set (we need
|
||||
// both modes to test all of the functionality).
|
||||
var nonatomicHarnessPath, atomicHarnessPath string
|
||||
if testing.CoverMode() != "atomic" {
|
||||
nonatomicHarnessPath = harnessPath
|
||||
bdir2 := mkdir(t, filepath.Join(dir, "build2"))
|
||||
hargs := []string{"-covermode=atomic", "-coverpkg=all"}
|
||||
atomicHarnessPath = buildHarness(t, bdir2, hargs)
|
||||
} else {
|
||||
atomicHarnessPath = harnessPath
|
||||
mode := "set"
|
||||
if testing.CoverMode() != "" && testing.CoverMode() != "atomic" {
|
||||
mode = testing.CoverMode()
|
||||
}
|
||||
// Build a special nonatomic covermode version of the harness
|
||||
// (we need both modes to test all of the functionality).
|
||||
bdir2 := mkdir(t, filepath.Join(dir, "build2"))
|
||||
hargs := []string{"-covermode=" + mode, "-coverpkg=all"}
|
||||
nonatomicHarnessPath = buildHarness(t, bdir2, hargs)
|
||||
}
|
||||
|
||||
withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
|
||||
// First a run with the nonatomic harness path, which we
|
||||
// expect to fail.
|
||||
tp := "emitWithCounterClear"
|
||||
rdir1, edir1 := mktestdirs(t, tag, tp+"1", dir)
|
||||
output, err := runHarness(t, nonatomicHarnessPath, tp,
|
||||
setGoCoverDir, rdir1, edir1)
|
||||
if err == nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running '%s -tp %s': unexpected success",
|
||||
nonatomicHarnessPath, tp)
|
||||
}
|
||||
|
||||
// Next a run with the atomic harness path, which we
|
||||
// expect to succeed.
|
||||
rdir2, edir2 := mktestdirs(t, tag, tp+"2", dir)
|
||||
output, err = runHarness(t, atomicHarnessPath, tp,
|
||||
setGoCoverDir, rdir2, edir2)
|
||||
if err != nil {
|
||||
t.Logf("%s", output)
|
||||
t.Fatalf("running 'harness -tp %s': %v", tp, err)
|
||||
}
|
||||
want := []string{tp, "postClear"}
|
||||
avoid := []string{"preClear", "main", "final"}
|
||||
if msg := testForSpecificFunctions(t, edir2, want, avoid); msg != "" {
|
||||
t.Logf("%s", output)
|
||||
t.Errorf("coverage data from %q output match failed: %s", tp, msg)
|
||||
}
|
||||
|
||||
if testing.CoverMode() == "atomic" {
|
||||
upmergeCoverData(t, edir2)
|
||||
upmergeCoverData(t, rdir2)
|
||||
} else {
|
||||
upmergeCoverData(t, edir1)
|
||||
upmergeCoverData(t, rdir1)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestApisOnNocoverBinary(t *testing.T) {
|
||||
testenv.MustHaveGoBuild(t)
|
||||
dir := t.TempDir()
|
||||
|
||||
// Build harness with no -cover.
|
||||
bdir := mkdir(t, filepath.Join(dir, "nocover"))
|
||||
edir := mkdir(t, filepath.Join(dir, "emitDirNo"))
|
||||
harnessPath := buildHarness(t, bdir, nil)
|
||||
output, err := runHarness(t, harnessPath, "emitToDir", false, edir, edir)
|
||||
if err == nil {
|
||||
t.Fatalf("expected error on TestApisOnNocoverBinary harness run")
|
||||
}
|
||||
const want = "not built with -cover"
|
||||
if !strings.Contains(output, want) {
|
||||
t.Errorf("error output does not contain %q: %s", want, output)
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue