deps.go

     1  // Copyright 2016 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  // Package testdeps provides access to dependencies needed by test execution.
     6  //
     7  // This package is imported by the generated main package, which passes
     8  // TestDeps into testing.Main. This allows tests to use packages at run time
     9  // without making those packages direct dependencies of package testing.
    10  // Direct dependencies of package testing are harder to write tests for.
    11  package testdeps
    12  
    13  import (
    14  	"bufio"
    15  	"context"
    16  	"internal/fuzz"
    17  	"internal/testlog"
    18  	"io"
    19  	"os"
    20  	"os/signal"
    21  	"reflect"
    22  	"regexp"
    23  	"runtime/pprof"
    24  	"strings"
    25  	"sync"
    26  	"time"
    27  )
    28  
    29  // TestDeps is an implementation of the testing.testDeps interface,
    30  // suitable for passing to testing.MainStart.
    31  type TestDeps struct{}
    32  
    33  var matchPat string
    34  var matchRe *regexp.Regexp
    35  
    36  func (TestDeps) MatchString(pat, str string) (result bool, err error) {
    37  	if matchRe == nil || matchPat != pat {
    38  		matchPat = pat
    39  		matchRe, err = regexp.Compile(matchPat)
    40  		if err != nil {
    41  			return
    42  		}
    43  	}
    44  	return matchRe.MatchString(str), nil
    45  }
    46  
    47  func (TestDeps) StartCPUProfile(w io.Writer) error {
    48  	return pprof.StartCPUProfile(w)
    49  }
    50  
    51  func (TestDeps) StopCPUProfile() {
    52  	pprof.StopCPUProfile()
    53  }
    54  
    55  func (TestDeps) WriteProfileTo(name string, w io.Writer, debug int) error {
    56  	return pprof.Lookup(name).WriteTo(w, debug)
    57  }
    58  
    59  // ImportPath is the import path of the testing binary, set by the generated main function.
    60  var ImportPath string
    61  
    62  func (TestDeps) ImportPath() string {
    63  	return ImportPath
    64  }
    65  
    66  // testLog implements testlog.Interface, logging actions by package os.
    67  type testLog struct {
    68  	mu  sync.Mutex
    69  	w   *bufio.Writer
    70  	set bool
    71  }
    72  
    73  func (l *testLog) Getenv(key string) {
    74  	l.add("getenv", key)
    75  }
    76  
    77  func (l *testLog) Open(name string) {
    78  	l.add("open", name)
    79  }
    80  
    81  func (l *testLog) Stat(name string) {
    82  	l.add("stat", name)
    83  }
    84  
    85  func (l *testLog) Chdir(name string) {
    86  	l.add("chdir", name)
    87  }
    88  
    89  // add adds the (op, name) pair to the test log.
    90  func (l *testLog) add(op, name string) {
    91  	if strings.Contains(name, "\n") || name == "" {
    92  		return
    93  	}
    94  
    95  	l.mu.Lock()
    96  	defer l.mu.Unlock()
    97  	if l.w == nil {
    98  		return
    99  	}
   100  	l.w.WriteString(op)
   101  	l.w.WriteByte(' ')
   102  	l.w.WriteString(name)
   103  	l.w.WriteByte('\n')
   104  }
   105  
   106  var log testLog
   107  
   108  func (TestDeps) StartTestLog(w io.Writer) {
   109  	log.mu.Lock()
   110  	log.w = bufio.NewWriter(w)
   111  	if !log.set {
   112  		// Tests that define TestMain and then run m.Run multiple times
   113  		// will call StartTestLog/StopTestLog multiple times.
   114  		// Checking log.set avoids calling testlog.SetLogger multiple times
   115  		// (which will panic) and also avoids writing the header multiple times.
   116  		log.set = true
   117  		testlog.SetLogger(&log)
   118  		log.w.WriteString("# test log\n") // known to cmd/go/internal/test/test.go
   119  	}
   120  	log.mu.Unlock()
   121  }
   122  
   123  func (TestDeps) StopTestLog() error {
   124  	log.mu.Lock()
   125  	defer log.mu.Unlock()
   126  	err := log.w.Flush()
   127  	log.w = nil
   128  	return err
   129  }
   130  
   131  // SetPanicOnExit0 tells the os package whether to panic on os.Exit(0).
   132  func (TestDeps) SetPanicOnExit0(v bool) {
   133  	testlog.SetPanicOnExit0(v)
   134  }
   135  
   136  func (TestDeps) CoordinateFuzzing(
   137  	timeout time.Duration,
   138  	limit int64,
   139  	minimizeTimeout time.Duration,
   140  	minimizeLimit int64,
   141  	parallel int,
   142  	seed []fuzz.CorpusEntry,
   143  	types []reflect.Type,
   144  	corpusDir,
   145  	cacheDir string) (err error) {
   146  	// Fuzzing may be interrupted with a timeout or if the user presses ^C.
   147  	// In either case, we'll stop worker processes gracefully and save
   148  	// crashers and interesting values.
   149  	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
   150  	defer cancel()
   151  	err = fuzz.CoordinateFuzzing(ctx, fuzz.CoordinateFuzzingOpts{
   152  		Log:             os.Stderr,
   153  		Timeout:         timeout,
   154  		Limit:           limit,
   155  		MinimizeTimeout: minimizeTimeout,
   156  		MinimizeLimit:   minimizeLimit,
   157  		Parallel:        parallel,
   158  		Seed:            seed,
   159  		Types:           types,
   160  		CorpusDir:       corpusDir,
   161  		CacheDir:        cacheDir,
   162  	})
   163  	if err == ctx.Err() {
   164  		return nil
   165  	}
   166  	return err
   167  }
   168  
   169  func (TestDeps) RunFuzzWorker(fn func(fuzz.CorpusEntry) error) error {
   170  	// Worker processes may or may not receive a signal when the user presses ^C
   171  	// On POSIX operating systems, a signal sent to a process group is delivered
   172  	// to all processes in that group. This is not the case on Windows.
   173  	// If the worker is interrupted, return quickly and without error.
   174  	// If only the coordinator process is interrupted, it tells each worker
   175  	// process to stop by closing its "fuzz_in" pipe.
   176  	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
   177  	defer cancel()
   178  	err := fuzz.RunFuzzWorker(ctx, fn)
   179  	if err == ctx.Err() {
   180  		return nil
   181  	}
   182  	return err
   183  }
   184  
   185  func (TestDeps) ReadCorpus(dir string, types []reflect.Type) ([]fuzz.CorpusEntry, error) {
   186  	return fuzz.ReadCorpus(dir, types)
   187  }
   188  
   189  func (TestDeps) CheckCorpus(vals []any, types []reflect.Type) error {
   190  	return fuzz.CheckCorpus(vals, types)
   191  }
   192  
   193  func (TestDeps) ResetCoverage() {
   194  	fuzz.ResetCoverage()
   195  }
   196  
   197  func (TestDeps) SnapshotCoverage() {
   198  	fuzz.SnapshotCoverage()
   199  }
   200
View as plain text