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