1// Copyright 2023 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// Action graph execution methods related to coverage.
6
7package work
8
9import (
10	"cmd/go/internal/base"
11	"cmd/go/internal/cfg"
12	"cmd/go/internal/str"
13	"cmd/internal/cov/covcmd"
14	"context"
15	"encoding/json"
16	"fmt"
17	"internal/coverage"
18	"io"
19	"os"
20	"path/filepath"
21)
22
23// CovData invokes "go tool covdata" with the specified arguments
24// as part of the execution of action 'a'.
25func (b *Builder) CovData(a *Action, cmdargs ...any) ([]byte, error) {
26	cmdline := str.StringList(cmdargs...)
27	args := append([]string{}, cfg.BuildToolexec...)
28	args = append(args, base.Tool("covdata"))
29	args = append(args, cmdline...)
30	return b.Shell(a).runOut(a.Objdir, nil, args)
31}
32
33// BuildActionCoverMetaFile locates and returns the path of the
34// meta-data file written by the "go tool cover" step as part of the
35// build action for the "go test -cover" run action 'runAct'. Note
36// that if the package has no functions the meta-data file will exist
37// but will be empty; in this case the return is an empty string.
38func BuildActionCoverMetaFile(runAct *Action) (string, error) {
39	p := runAct.Package
40	for i := range runAct.Deps {
41		pred := runAct.Deps[i]
42		if pred.Mode != "build" || pred.Package == nil {
43			continue
44		}
45		if pred.Package.ImportPath == p.ImportPath {
46			metaFile := pred.Objdir + covcmd.MetaFileForPackage(p.ImportPath)
47			if cfg.BuildN {
48				return metaFile, nil
49			}
50			f, err := os.Open(metaFile)
51			if err != nil {
52				return "", err
53			}
54			defer f.Close()
55			fi, err2 := f.Stat()
56			if err2 != nil {
57				return "", err2
58			}
59			if fi.Size() == 0 {
60				return "", nil
61			}
62			return metaFile, nil
63		}
64	}
65	return "", fmt.Errorf("internal error: unable to locate build action for package %q run action", p.ImportPath)
66}
67
68// WriteCoveragePercent writes out to the writer 'w' a "percent
69// statements covered" for the package whose test-run action is
70// 'runAct', based on the meta-data file 'mf'. This helper is used in
71// cases where a user runs "go test -cover" on a package that has
72// functions but no tests; in the normal case (package has tests)
73// the percentage is written by the test binary when it runs.
74func WriteCoveragePercent(b *Builder, runAct *Action, mf string, w io.Writer) error {
75	dir := filepath.Dir(mf)
76	output, cerr := b.CovData(runAct, "percent", "-i", dir)
77	if cerr != nil {
78		return b.Shell(runAct).reportCmd("", "", output, cerr)
79	}
80	_, werr := w.Write(output)
81	return werr
82}
83
84// WriteCoverageProfile writes out a coverage profile fragment for the
85// package whose test-run action is 'runAct'; content is written to
86// the file 'outf' based on the coverage meta-data info found in
87// 'mf'. This helper is used in cases where a user runs "go test
88// -cover" on a package that has functions but no tests.
89func WriteCoverageProfile(b *Builder, runAct *Action, mf, outf string, w io.Writer) error {
90	dir := filepath.Dir(mf)
91	output, err := b.CovData(runAct, "textfmt", "-i", dir, "-o", outf)
92	if err != nil {
93		return b.Shell(runAct).reportCmd("", "", output, err)
94	}
95	_, werr := w.Write(output)
96	return werr
97}
98
99// WriteCoverMetaFilesFile writes out a summary file ("meta-files
100// file") as part of the action function for the "writeCoverMeta"
101// pseudo action employed during "go test -coverpkg" runs where there
102// are multiple tests and multiple packages covered. It builds up a
103// table mapping package import path to meta-data file fragment and
104// writes it out to a file where it can be read by the various test
105// run actions. Note that this function has to be called A) after the
106// build actions are complete for all packages being tested, and B)
107// before any of the "run test" actions for those packages happen.
108// This requirement is enforced by adding making this action ("a")
109// dependent on all test package build actions, and making all test
110// run actions dependent on this action.
111func WriteCoverMetaFilesFile(b *Builder, ctx context.Context, a *Action) error {
112	sh := b.Shell(a)
113
114	// Build the metafilecollection object.
115	var collection coverage.MetaFileCollection
116	for i := range a.Deps {
117		dep := a.Deps[i]
118		if dep.Mode != "build" {
119			panic("unexpected mode " + dep.Mode)
120		}
121		metaFilesFile := dep.Objdir + covcmd.MetaFileForPackage(dep.Package.ImportPath)
122		// Check to make sure the meta-data file fragment exists
123		//  and has content (may be empty if package has no functions).
124		if fi, err := os.Stat(metaFilesFile); err != nil {
125			continue
126		} else if fi.Size() == 0 {
127			continue
128		}
129		collection.ImportPaths = append(collection.ImportPaths, dep.Package.ImportPath)
130		collection.MetaFileFragments = append(collection.MetaFileFragments, metaFilesFile)
131	}
132
133	// Serialize it.
134	data, err := json.Marshal(collection)
135	if err != nil {
136		return fmt.Errorf("marshal MetaFileCollection: %v", err)
137	}
138	data = append(data, '\n') // makes -x output more readable
139
140	// Create the directory for this action's objdir and
141	// then write out the serialized collection
142	// to a file in the directory.
143	if err := sh.Mkdir(a.Objdir); err != nil {
144		return err
145	}
146	mfpath := a.Objdir + coverage.MetaFilesFileName
147	if err := sh.writeFile(mfpath, data); err != nil {
148		return fmt.Errorf("writing metafiles file: %v", err)
149	}
150
151	// We're done.
152	return nil
153}
154