golang · suntala · Feb 5, 2025 · Feb 12, 2025 · Feb 18, 2025 · Feb 19, 2025
diff --git a/api/next/59928.txt b/api/next/59928.txt
@@ -0,0 +1,3 @@
+pkg testing, method (*B) Output() io.Writer #59928
+pkg testing, method (*F) Output() io.Writer #59928
+pkg testing, method (*T) Output() io.Writer #59928
diff --git a/doc/next/6-stdlib/99-minor/testing/59928.md b/doc/next/6-stdlib/99-minor/testing/59928.md
@@ -0,0 +1,3 @@
+<!-- go.dev/issue/59928 -->
+
+The new [Output] method of [testing.T], [testing.B] and [testing.F] provides a Writer that writes to the same test output stream as [TB.Log].
diff --git a/src/testing/benchmark.go b/src/testing/benchmark.go
@@ -755,6 +755,7 @@ func (s *benchState) processBench(b *B) {
 					benchFunc: b.benchFunc,
 					benchTime: b.benchTime,
 				}
+				b.setOutputWriter()
 				b.run1()
 			}
 			r := b.doBench()
@@ -831,6 +832,7 @@ func (b *B) Run(name string, f func(b *B)) bool {
 		benchTime:  b.benchTime,
 		bstate:     b.bstate,
 	}
+	sub.setOutputWriter()
 	if partial {
 		// Partial name match, like -bench=X/Y matching BenchmarkX.
 		// Only process sub-benchmarks, if any.
@@ -1007,6 +1009,7 @@ func Benchmark(f func(b *B)) BenchmarkResult {
 		benchFunc: f,
 		benchTime: benchTime,
 	}
+	b.setOutputWriter()
 	if b.run1() {
 		b.run()
 	}

diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go
@@ -320,6 +320,7 @@ func (f *F) Fuzz(ff any) {
 			t.parent.w = captureOut
 		}
 		t.w = indenter{&t.common}
+		t.setOutputWriter()
 		if t.chatty != nil {
 			t.chatty.Updatef(t.name, "=== RUN   %s\n", t.name)
 		}
@@ -529,6 +530,7 @@ func runFuzzTests(deps testDeps, fuzzTests []InternalFuzzTarget, deadline time.T
 					fstate: fstate,
 				}
 				f.w = indenter{&f.common}
+				f.setOutputWriter()
 				if f.chatty != nil {
 					f.chatty.Updatef(f.name, "=== RUN   %s\n", f.name)
 				}

diff --git a/src/testing/sub_test.go b/src/testing/sub_test.go
@@ -989,3 +989,232 @@ func TestNestedCleanup(t *T) {
 		t.Errorf("unexpected cleanup count: got %d want 3", ranCleanup)
 	}
 }
+
+func TestOutput(t *T) {
+	o := t.Output()
+	if o != t.o {
+		t.Errorf("outputWriter:\ngot:\n%+v\nwant:\n%+v", o, t.o)
+	}
+
+	testCases := []struct {
+		in  string
+		out string
+		buf string
+	}{{
+		in:  "a",
+		out: "",
+		buf: "a",
+	}, {
+		in:  "b",
+		out: "",
+		buf: "ab",
+	}, {
+		in:  "\n",
+		out: "    ab\n",
+		buf: "",
+	}, {
+		in:  "\nc",
+		out: "    ab\n    \n",
+		buf: "c",
+	}, {
+		in:  "d",
+		out: "    ab\n    \n",
+		buf: "cd",
+	}}
+	for _, tc := range testCases {
+		o.Write([]byte(tc.in))
+		if string(t.output) != tc.out {
+			t.Errorf("output:\ngot:\n%s\nwant:\n%s", t.output, tc.out)
+		}
+		if string(t.o.partial) != tc.buf {
+			t.Errorf("buffer:\ngot:\n%s\nwant:\n%s", t.o.partial, tc.buf)
+		}
+	}
+}
+
+func TestOutputFlushing(t *T) {
+	testCases := []struct {
+		desc   string
+		chatty bool
+		json   bool
+		output string
+		f      func(*T)
+	}{{
+		desc: "buffered output gets flushed at test end",
+		output: `
+--- FAIL: buffered output gets flushed at test end (0.00s)
+    --- FAIL: buffered output gets flushed at test end/#00 (0.00s)
+        a
+        b`,
+		f: func(t *T) {
+			t.Run("", func(t *T) {
+				o := t.Output()
+				o.Write([]byte("a\n"))
+				o.Write([]byte("b"))
+				t.Fail()
+			})
+		},
+	}, {
+		desc:   "with chatty",
+		chatty: true,
+		output: `
+=== RUN   with chatty
+=== RUN   with chatty/#00
+    a
+    b
+--- PASS: with chatty (0.00s)
+    --- PASS: with chatty/#00 (0.00s)`,
+		f: func(t *T) {
+			t.Run("", func(t *T) {
+				o := t.Output()
+				o.Write([]byte("a\n"))
+				o.Write([]byte("b"))
+			})
+		},
+	}, {
+		desc:   "with chatty and json",
+		chatty: true,
+		json:   true,
+		output: `
+^V=== RUN   with chatty and json
+^V=== RUN   with chatty and json/#00
+    a
+    b
+^V--- PASS: with chatty and json/#00 (0.00s)
+^V=== NAME  with chatty and json
+^V--- PASS: with chatty and json (0.00s)
+^V=== NAME
+`,
+		f: func(t *T) {
+			t.Run("", func(t *T) {
+				o := t.Output()
+				o.Write([]byte("a\n"))
+				o.Write([]byte("b"))
+			})
+		},
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *T) {
+			tstate := newTestState(1, allMatcher())
+			buf := &strings.Builder{}
+			root := &T{
+				common: common{
+					w: buf,
+				},
+				tstate: tstate,
+			}
+
+			if tc.chatty {
+				root.chatty = newChattyPrinter(root.w)
+				root.chatty.json = tc.json
+			}
+
+			root.Run(tc.desc, tc.f)
+
+			got := strings.TrimSpace(buf.String())
+
+			want := strings.TrimSpace(tc.output)
+			re := makeRegexp(want)
+			if ok, err := regexp.MatchString(re, got); !ok || err != nil {
+				t.Errorf("output:\ngot:\n%s\nwant:\n%s", got, want)
+			}
+		})
+	}
+}
+
+func TestOutputAfterComplete(t *T) {
+	tstate := newTestState(1, allMatcher())
+	var buf bytes.Buffer
+	t1 := &T{
+		common: common{
+			// Use a buffered channel so that tRunner can write
+			// to it although nothing is reading from it.
+			signal: make(chan bool, 1),
+			w:      &buf,
+		},
+		tstate: tstate,
+	}
+
+	c1 := make(chan bool)
+	c2 := make(chan string)
+	tRunner(t1, func(t *T) {
+		t.Run("TestLateOutput", func(t *T) {
+			go func() {
+				defer close(c2)
+				defer func() {
+					p := recover()
+					if p == nil {
+						c2 <- "subtest did not panic"
+						return
+					}
+					s, ok := p.(string)
+					if !ok {
+						c2 <- fmt.Sprintf("subtest panic with unexpected value %v", p)
+						return
+					}
+					const want = "Output called after TestLateOutput has completed"
+					if !strings.Contains(s, want) {
+						c2 <- fmt.Sprintf("subtest panic %q does not contain %q", s, want)
+					}
+				}()
+
+				<-c1
+				t.Output()
+			}()
+		})
+	})
+	close(c1)
+
+	if s := <-c2; s != "" {
+		t.Error(s)
+	}
+}
+
+func TestWriteAfterComplete(t *T) {
+	tstate := newTestState(1, allMatcher())
+	var buf bytes.Buffer
+	t1 := &T{
+		common: common{
+			// Use a buffered channel so that tRunner can write
+			// to it although nothing is reading from it.
+			signal: make(chan bool, 1),
+			w:      &buf,
+		},
+		tstate: tstate,
+	}
+
+	c1 := make(chan bool)
+	c2 := make(chan string)
+	tRunner(t1, func(t *T) {
+		t.Run("TestLateWrite", func(t *T) {
+			o := t.Output()
+			go func() {
+				defer close(c2)
+				defer func() {
+					p := recover()
+					if p == nil {
+						c2 <- "subtest did not panic"
+						return
+					}
+					s, ok := p.(string)
+					if !ok {
+						c2 <- fmt.Sprintf("subtest panic with unexpected value %v", p)
+						return
+					}
+					const want = "Write called after TestLateWrite has completed"
+					if !strings.Contains(s, want) {
+						c2 <- fmt.Sprintf("subtest panic %q does not contain %q", s, want)
+					}
+				}()
+
+				<-c1
+				o.Write([]byte("write after test"))
+			}()
+		})
+	})
+	close(c1)
+
+	if s := <-c2; s != "" {
+		t.Error(s)
+	}
+}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,3 @@
		<!-- go.dev/issue/59928 -->

		The new [Output] method of [testing.T], [testing.B] and [testing.F] provides a Writer that writes to the same test output stream as [TB.Log].