testing: rename testContext to testState

Following up to CL 603959, update internals of testing package to
reduce the confusion around "context". The changes rename
testContext/benchContext/fuzzContext to testState/benchState/fuzzState.

Change-Id: Ib8855dab456d41ab343488fcf5fefff2431f7b72
Reviewed-on: https://go-review.googlesource.com/c/go/+/607555
Auto-Submit: Ian Lance Taylor <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>
Reviewed-by: Damien Neil <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: narqo

src/testing/benchmark.go

@@ -93,7 +93,7 @@ type InternalBenchmark struct {
 type B struct {
 	common
 	importPath       string // import path of the package containing the benchmark
-	context          *benchContext
+	bstate           *benchState
 	N                int
 	previousN        int           // number of iterations in the previous run
 	previousDuration time.Duration // total duration of the previous run
@@ -199,10 +199,10 @@ func (b *B) runN(n int) {
 // run1 runs the first iteration of benchFunc. It reports whether more
 // iterations of this benchmarks should be run.
 func (b *B) run1() bool {
-	if ctx := b.context; ctx != nil {
+	if bstate := b.bstate; bstate != nil {
 		// Extend maxLen, if needed.
-		if n := len(b.name) + ctx.extLen + 1; n > ctx.maxLen {
-			ctx.maxLen = n + 8 // Add additional slack to avoid too many jumps in size.
+		if n := len(b.name) + bstate.extLen + 1; n > bstate.maxLen {
+			bstate.maxLen = n + 8 // Add additional slack to avoid too many jumps in size.
 		}
 	}
 	go func() {
@@ -253,9 +253,9 @@ func (b *B) run() {
 			fmt.Fprintf(b.w, "cpu: %s\n", cpu)
 		}
 	})
-	if b.context != nil {
+	if b.bstate != nil {
 		// Running go test --test.bench
-		b.context.processBench(b) // Must call doBench.
+		b.bstate.processBench(b) // Must call doBench.
 	} else {
 		// Running func Benchmark.
 		b.doBench()
@@ -492,7 +492,7 @@ func benchmarkName(name string, n int) string {
 	return name
 }
 
-type benchContext struct {
+type benchState struct {
 	match *matcher
 
 	maxLen int // The largest recorded benchmark name.
@@ -517,17 +517,17 @@ func runBenchmarks(importPath string, matchString func(pat, str string) (bool, e
 			maxprocs = procs
 		}
 	}
-	ctx := &benchContext{
+	bstate := &benchState{
 		match:  newMatcher(matchString, *matchBenchmarks, "-test.bench", *skip),
 		extLen: len(benchmarkName("", maxprocs)),
 	}
 	var bs []InternalBenchmark
 	for _, Benchmark := range benchmarks {
-		if _, matched, _ := ctx.match.fullName(nil, Benchmark.Name); matched {
+		if _, matched, _ := bstate.match.fullName(nil, Benchmark.Name); matched {
 			bs = append(bs, Benchmark)
 			benchName := benchmarkName(Benchmark.Name, maxprocs)
-			if l := len(benchName) + ctx.extLen + 1; l > ctx.maxLen {
-				ctx.maxLen = l
+			if l := len(benchName) + bstate.extLen + 1; l > bstate.maxLen {
+				bstate.maxLen = l
 			}
 		}
 	}
@@ -544,7 +544,7 @@ func runBenchmarks(importPath string, matchString func(pat, str string) (bool, e
 			}
 		},
 		benchTime: benchTime,
-		context:   ctx,
+		bstate:    bstate,
 	}
 	if Verbose() {
 		main.chatty = newChattyPrinter(main.w)
@@ -554,15 +554,15 @@ func runBenchmarks(importPath string, matchString func(pat, str string) (bool, e
 }
 
 // processBench runs bench b for the configured CPU counts and prints the results.
-func (ctx *benchContext) processBench(b *B) {
+func (s *benchState) processBench(b *B) {
 	for i, procs := range cpuList {
 		for j := uint(0); j < *count; j++ {
 			runtime.GOMAXPROCS(procs)
 			benchName := benchmarkName(b.name, procs)
 
 			// If it's chatty, we've already printed this information.
 			if b.chatty == nil {
-				fmt.Fprintf(b.w, "%-*s\t", ctx.maxLen, benchName)
+				fmt.Fprintf(b.w, "%-*s\t", s.maxLen, benchName)
 			}
 			// Recompute the running time for all but the first iteration.
 			if i > 0 || j > 0 {
@@ -589,7 +589,7 @@ func (ctx *benchContext) processBench(b *B) {
 			}
 			results := r.String()
 			if b.chatty != nil {
-				fmt.Fprintf(b.w, "%-*s\t", ctx.maxLen, benchName)
+				fmt.Fprintf(b.w, "%-*s\t", s.maxLen, benchName)
 			}
 			if *benchmarkMemory || b.showAllocResult {
 				results += "\t" + r.MemString()
@@ -629,8 +629,8 @@ func (b *B) Run(name string, f func(b *B)) bool {
 	defer benchmarkLock.Lock()
 
 	benchName, ok, partial := b.name, true, false
-	if b.context != nil {
-		benchName, ok, partial = b.context.match.fullName(&b.common, name)
+	if b.bstate != nil {
+		benchName, ok, partial = b.bstate.match.fullName(&b.common, name)
 	}
 	if !ok {
 		return true
@@ -651,7 +651,7 @@ func (b *B) Run(name string, f func(b *B)) bool {
 		importPath: b.importPath,
 		benchFunc:  f,
 		benchTime:  b.benchTime,
-		context:    b.context,
+		bstate:     b.bstate,
 	}
 	if partial {
 		// Partial name match, like -bench=X/Y matching BenchmarkX.

src/testing/fuzz.go

@@ -67,8 +67,8 @@ type InternalFuzzTarget struct {
 // that are allowed in the (*F).Fuzz function are (*F).Failed and (*F).Name.
 type F struct {
 	common
-	fuzzContext *fuzzContext
-	testContext *testContext
+	fstate *fuzzState
+	tstate *testState
 
 	// inFuzzFn is true when the fuzz function is running. Most F methods cannot
 	// be called when inFuzzFn is true.
@@ -244,22 +244,22 @@ func (f *F) Fuzz(ff any) {
 	// corpus and entries declared with F.Add.
 	//
 	// Don't load the seed corpus if this is a worker process; we won't use it.
-	if f.fuzzContext.mode != fuzzWorker {
+	if f.fstate.mode != fuzzWorker {
 		for _, c := range f.corpus {
-			if err := f.fuzzContext.deps.CheckCorpus(c.Values, types); err != nil {
+			if err := f.fstate.deps.CheckCorpus(c.Values, types); err != nil {
 				// TODO(#48302): Report the source location of the F.Add call.
 				f.Fatal(err)
 			}
 		}
 
 		// Load seed corpus
-		c, err := f.fuzzContext.deps.ReadCorpus(filepath.Join(corpusDir, f.name), types)
+		c, err := f.fstate.deps.ReadCorpus(filepath.Join(corpusDir, f.name), types)
 		if err != nil {
 			f.Fatal(err)
 		}
 		for i := range c {
 			c[i].IsSeed = true // these are all seed corpus values
-			if f.fuzzContext.mode == fuzzCoordinator {
+			if f.fstate.mode == fuzzCoordinator {
 				// If this is the coordinator process, zero the values, since we don't need
 				// to hold onto them.
 				c[i].Values = nil
@@ -285,12 +285,12 @@ func (f *F) Fuzz(ff any) {
 		if e.Path != "" {
 			testName = fmt.Sprintf("%s/%s", testName, filepath.Base(e.Path))
 		}
-		if f.testContext.isFuzzing {
+		if f.tstate.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()
+			f.tstate.match.clearSubNames()
 		}
 
 		// Record the stack trace at the point of this call so that if the subtest
@@ -308,7 +308,7 @@ func (f *F) Fuzz(ff any) {
 				creator: pc[:n],
 				chatty:  f.chatty,
 			},
-			context: f.testContext,
+			tstate: f.tstate,
 		}
 		if captureOut != nil {
 			// t.parent aliases f.common.
@@ -328,9 +328,9 @@ func (f *F) Fuzz(ff any) {
 			// we make sure it is called right before the tRunner function
 			// exits, regardless of whether it was executed cleanly, panicked,
 			// or if the fuzzFn called t.Fatal.
-			if f.testContext.isFuzzing {
-				defer f.fuzzContext.deps.SnapshotCoverage()
-				f.fuzzContext.deps.ResetCoverage()
+			if f.tstate.isFuzzing {
+				defer f.fstate.deps.SnapshotCoverage()
+				f.fstate.deps.ResetCoverage()
 			}
 			fn.Call(args)
 		})
@@ -342,14 +342,14 @@ func (f *F) Fuzz(ff any) {
 		return !t.Failed()
 	}
 
-	switch f.fuzzContext.mode {
+	switch f.fstate.mode {
 	case fuzzCoordinator:
 		// Fuzzing is enabled, and this is the test process started by 'go test'.
 		// Act as the coordinator process, and coordinate workers to perform the
 		// actual fuzzing.
 		corpusTargetDir := filepath.Join(corpusDir, f.name)
 		cacheTargetDir := filepath.Join(*fuzzCacheDir, f.name)
-		err := f.fuzzContext.deps.CoordinateFuzzing(
+		err := f.fstate.deps.CoordinateFuzzing(
 			fuzzDuration.d,
 			int64(fuzzDuration.n),
 			minimizeDuration.d,
@@ -376,7 +376,7 @@ func (f *F) Fuzz(ff any) {
 	case fuzzWorker:
 		// Fuzzing is enabled, and this is a worker process. Follow instructions
 		// from the coordinator.
-		if err := f.fuzzContext.deps.RunFuzzWorker(func(e corpusEntry) error {
+		if err := f.fstate.deps.RunFuzzWorker(func(e corpusEntry) error {
 			// Don't write to f.w (which points to Stdout) if running from a
 			// fuzz worker. This would become very verbose, particularly during
 			// minimization. Return the error instead, and let the caller deal
@@ -398,7 +398,7 @@ func (f *F) Fuzz(ff any) {
 		// corpus now.
 		for _, e := range f.corpus {
 			name := fmt.Sprintf("%s/%s", f.name, filepath.Base(e.Path))
-			if _, ok, _ := f.testContext.match.fullName(nil, name); ok {
+			if _, ok, _ := f.tstate.match.fullName(nil, name); ok {
 				run(f.w, e)
 			}
 		}
@@ -451,8 +451,8 @@ type fuzzCrashError interface {
 	CrashPath() string
 }
 
-// fuzzContext holds fields common to all fuzz tests.
-type fuzzContext struct {
+// fuzzState holds fields common to all fuzz tests.
+type fuzzState struct {
 	deps testDeps
 	mode fuzzMode
 }
@@ -486,9 +486,9 @@ func runFuzzTests(deps testDeps, fuzzTests []InternalFuzzTarget, deadline time.T
 				break
 			}
 
-			tctx := newTestContext(*parallel, m)
-			tctx.deadline = deadline
-			fctx := &fuzzContext{deps: deps, mode: seedCorpusOnly}
+			tstate := newTestState(*parallel, m)
+			tstate.deadline = deadline
+			fstate := &fuzzState{deps: deps, mode: seedCorpusOnly}
 			root := common{w: os.Stdout} // gather output in one place
 			if Verbose() {
 				root.chatty = newChattyPrinter(root.w)
@@ -497,7 +497,7 @@ func runFuzzTests(deps testDeps, fuzzTests []InternalFuzzTarget, deadline time.T
 				if shouldFailFast() {
 					break
 				}
-				testName, matched, _ := tctx.match.fullName(nil, ft.Name)
+				testName, matched, _ := tstate.match.fullName(nil, ft.Name)
 				if !matched {
 					continue
 				}
@@ -517,8 +517,8 @@ func runFuzzTests(deps testDeps, fuzzTests []InternalFuzzTarget, deadline time.T
 						level:   root.level + 1,
 						chatty:  root.chatty,
 					},
-					testContext: tctx,
-					fuzzContext: fctx,
+					tstate: tstate,
+					fstate: fstate,
 				}
 				f.w = indenter{&f.common}
 				if f.chatty != nil {
@@ -554,17 +554,17 @@ func runFuzzing(deps testDeps, fuzzTests []InternalFuzzTarget) (ok bool) {
 		return true
 	}
 	m := newMatcher(deps.MatchString, *matchFuzz, "-test.fuzz", *skip)
-	tctx := newTestContext(1, m)
-	tctx.isFuzzing = true
-	fctx := &fuzzContext{
+	tstate := newTestState(1, m)
+	tstate.isFuzzing = true
+	fstate := &fuzzState{
 		deps: deps,
 	}
 	root := common{w: os.Stdout}
 	if *isFuzzWorker {
 		root.w = io.Discard
-		fctx.mode = fuzzWorker
+		fstate.mode = fuzzWorker
 	} else {
-		fctx.mode = fuzzCoordinator
+		fstate.mode = fuzzCoordinator
 	}
 	if Verbose() && !*isFuzzWorker {
 		root.chatty = newChattyPrinter(root.w)
@@ -573,7 +573,7 @@ func runFuzzing(deps testDeps, fuzzTests []InternalFuzzTarget) (ok bool) {
 	var testName string
 	var matched []string
 	for i := range fuzzTests {
-		name, ok, _ := tctx.match.fullName(nil, fuzzTests[i].Name)
+		name, ok, _ := tstate.match.fullName(nil, fuzzTests[i].Name)
 		if !ok {
 			continue
 		}
@@ -599,8 +599,8 @@ func runFuzzing(deps testDeps, fuzzTests []InternalFuzzTarget) (ok bool) {
 			level:   root.level + 1,
 			chatty:  root.chatty,
 		},
-		fuzzContext: fctx,
-		testContext: tctx,
+		fstate: fstate,
+		tstate: tstate,
 	}
 	f.w = indenter{&f.common}
 	if f.chatty != nil {
@@ -694,7 +694,7 @@ func fRunner(f *F, fn func(*F)) {
 			// This only affects fuzz tests run as normal tests.
 			// While fuzzing, T.Parallel has no effect, so f.sub is empty, and this
 			// branch is not taken. f.barrier is nil in that case.
-			f.testContext.release()
+			f.tstate.release()
 			close(f.barrier)
 			// Wait for the subtests to complete.
 			for _, sub := range f.sub {