testing: don't create unique subtest names while fuzzing
T.Run uses a map[string]int64 to keep track of subtest names that may
be returned through T.Name. T.Name can't return duplicate names for
subtests started with T.Run.
If a fuzz target calls T.Run, this map takes a large amount of memory,
since there are a very large number of subtests that would
otherwise have duplicate names, and the map stores one entry per subtest.
The unique suffixes are not useful (and may be confusing) since the
full sequence of tests cannot be re-run deterministically.
This change deletes all entries in the map before each call to the
function being fuzzed. There is a slight change in the contract of
T.Name while fuzzing.
This change was discussed in CL 351452.
Fixes #44517
Change-Id: I3093a2e5568099ce54aca1006fac84a6fd2c3ddf
Reviewed-on: https://go-review.googlesource.com/c/go/+/354430
Trust: Jay Conrod <jayconrod@google.com>
Trust: Katie Hockman <katie@golang.org>
Trust: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Jay Conrod <jayconrod@google.com>
Run-TryBot: Katie Hockman <katie@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go
index 40b77c1..0429f82 100644
--- a/src/testing/fuzz.go
+++ b/src/testing/fuzz.go
@@ -380,6 +380,13 @@
if e.Path != "" {
testName = fmt.Sprintf("%s/%s", testName, filepath.Base(e.Path))
}
+ if f.testContext.isFuzzing {
+ // Don't preserve subtest names while fuzzing. If fn calls T.Run,
+ // there will be a very large number of subtests with duplicate names,
+ // which will use a large amount of memory. The subtest names aren't
+ // useful since there's no way to re-run them deterministically.
+ f.testContext.match.clearSubNames()
+ }
// Record the stack trace at the point of this call so that if the subtest
// function - which runs in a separate stack - is marked as a helper, we can
@@ -395,7 +402,6 @@
level: f.level + 1,
creator: pc[:n],
chatty: f.chatty,
- fuzzing: true,
},
context: f.testContext,
}
@@ -615,6 +621,7 @@
}
m := newMatcher(deps.MatchString, *matchFuzz, "-test.fuzz")
tctx := newTestContext(1, m)
+ tctx.isFuzzing = true
fctx := &fuzzContext{
deps: deps,
}
diff --git a/src/testing/match.go b/src/testing/match.go
index d97e415..c6ff429 100644
--- a/src/testing/match.go
+++ b/src/testing/match.go
@@ -82,6 +82,17 @@
return name, ok, partial
}
+// clearSubNames clears the matcher's internal state, potentially freeing
+// memory. After this is called, T.Name may return the same strings as it did
+// for earlier subtests.
+func (m *matcher) clearSubNames() {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ for key := range m.subNames {
+ delete(m.subNames, key)
+ }
+}
+
func (m simpleMatch) matches(name []string, matchString func(pat, str string) (bool, error)) (ok, partial bool) {
for i, s := range name {
if i >= len(m) {
diff --git a/src/testing/testing.go b/src/testing/testing.go
index b3f4b4d..57ac580 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -495,7 +495,6 @@
chatty *chattyPrinter // A copy of chattyPrinter, if the chatty flag is set.
bench bool // Whether the current test is a benchmark.
- fuzzing bool // Whether the current test is a fuzzing target.
hasSub int32 // Written atomically.
raceErrors int // Number of races detected during test.
runner string // Function name of tRunner running the test.
@@ -697,17 +696,6 @@
}
}
-// isFuzzing returns whether the current context, or any of the parent contexts,
-// are a fuzzing target
-func (c *common) isFuzzing() bool {
- for com := c; com != nil; com = com.parent {
- if com.fuzzing {
- return true
- }
- }
- return false
-}
-
type indenter struct {
c *common
}
@@ -1291,7 +1279,7 @@
}
}
- if err != nil && t.isFuzzing() {
+ if err != nil && t.context.isFuzzing {
prefix := "panic: "
if err == errNilPanicOrGoexit {
prefix = ""
@@ -1457,6 +1445,12 @@
match *matcher
deadline time.Time
+ // isFuzzing is true in the context used when generating random inputs
+ // for fuzz targets. isFuzzing is false when running normal tests and
+ // when running fuzz tests as unit tests (without -fuzz or when -fuzz
+ // does not match).
+ isFuzzing bool
+
mu sync.Mutex
// Channel used to signal tests that are ready to be run in parallel.
