cover.go

     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  
     7  package work
     8  
     9  import (
    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'.
    25  func (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.
    38  func 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.
    74  func 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.
    89  func 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.
   111  func 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
View as plain text