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 40b77c133136b46a85101cd5dc89f3791390910a..0429f8243d2ff72d8495b8cddb2a88dcafb49f03 100644 (file)
--- a/src/testing/fuzz.go
+++ b/src/testing/fuzz.go
@@ -380,6 +380,13 @@ func (f *F) Fuzz(ff interface{}) {
                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 @@ func (f *F) Fuzz(ff interface{}) {
                                level:   f.level + 1,
                                creator: pc[:n],
                                chatty:  f.chatty,
-                               fuzzing: true,
                        },
                        context: f.testContext,
                }
@@ -615,6 +621,7 @@ func runFuzzing(deps testDeps, fuzzTargets []InternalFuzzTarget) (ok bool) {
        }
        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 d97e415765682e1a4b6114e7cf7fd447d875b1e4..c6ff429fe42b301ef99a42db59c4a6852bb7850b 100644 (file)
--- a/src/testing/match.go
+++ b/src/testing/match.go
@@ -82,6 +82,17 @@ func (m *matcher) fullName(c *common, subname string) (name string, ok, partial
        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 b3f4b4da585b039f637aefdcca8fd0f6687cd8c8..57ac5800514dcedd3d148658461be06c72f3c210 100644 (file)
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -495,7 +495,6 @@ type common struct {
 
        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 @@ func (c *common) flushToParent(testName, format string, args ...interface{}) {
        }
 }
 
-// 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 @@ func tRunner(t *T, fn func(t *T)) {
                        }
                }
 
-               if err != nil && t.isFuzzing() {
+               if err != nil && t.context.isFuzzing {
                        prefix := "panic: "
                        if err == errNilPanicOrGoexit {
                                prefix = ""
@@ -1457,6 +1445,12 @@ type testContext struct {
        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.