rename

Author: bbasata

internal/testing/hack/t.go

@@ -11,13 +11,16 @@ import (
 	"time"
 )
 
-// T is a replacement for github.com/mitchellh/go-testing-interface.T.
+// BaseT is a replacement for github.com/mitchellh/go-testing-interface.T.
 //
-// RuntimeT and tshim are two implementations of T. RuntimeT can be used to
-// test a test framework without the testing.T side effects of stopping
-// goroutine execution. tshim can be used as an adapter around a standard
-// testing.T.
-type T interface {
+// RuntimeT and StandardT are two implementations of BaseT. MetaT can be used
+// to test a testing.T-based test framework without the side effects of
+// stopping goroutine execution. StandardT can be used as an adapter around a
+// standard testing.T.
+//
+// Precedent for StandardT: the unexported tshim type in
+// github.com/rogpeppe/go-internal/testscript.
+type BaseT interface {
 	Cleanup(func())
 	Error(args ...interface{})
 	Errorf(format string, args ...interface{})
@@ -46,54 +49,54 @@ type T interface {
 	TempDir() string
 }
 
-var _ T = RuntimeT{}
+var _ BaseT = MetaT{}
 
-type RuntimeT struct {
+type MetaT struct {
 	fail bool
 	skip bool
 }
 
-// Attr satisfies [T] and does nothing.
-func (t RuntimeT) Attr(key string, value string) {
+// Attr satisfies [BaseT] and does nothing.
+func (t MetaT) Attr(key string, value string) {
 }
 
-// Chdir satisfies [T] and does nothing.
-func (r RuntimeT) Chdir(dir string) {
+// Chdir satisfies [BaseT] and does nothing.
+func (r MetaT) Chdir(dir string) {
 }
 
-// Cleanup satisfies [T] and does nothing.
-func (r RuntimeT) Cleanup(_ func()) {
+// Cleanup satisfies [BaseT] and does nothing.
+func (r MetaT) Cleanup(_ func()) {
 }
 
-// Context satisfies [T] and returns context.TODO()
-func (r RuntimeT) Context() context.Context {
+// Context satisfies [BaseT] and returns context.TODO()
+func (r MetaT) Context() context.Context {
 	return context.TODO()
 }
 
-// Deadline satisfies [T] and returns zero-values.
-func (r RuntimeT) Deadline() (deadline time.Time, ok bool) {
+// Deadline satisfies [BaseT] and returns zero-values.
+func (r MetaT) Deadline() (deadline time.Time, ok bool) {
 	return time.Time{}, false
 }
 
 // Error is equivalent to Log followed by Fail.
-func (t RuntimeT) Error(args ...interface{}) {
+func (t MetaT) Error(args ...interface{}) {
 	t.Log(args)
 	t.Fail()
 }
 
 // Errorf is equivalent to Logf followed by Fail.
-func (t RuntimeT) Errorf(format string, args ...interface{}) {
+func (t MetaT) Errorf(format string, args ...interface{}) {
 	t.Logf(format, args...)
 	t.Fail()
 }
 
 // Fail marks the function as having failed but continues execution.
-func (t RuntimeT) Fail() {
+func (t MetaT) Fail() {
 	t.fail = true
 }
 
 // Failed reports whether the function has failed.
-func (t RuntimeT) Failed() bool {
+func (t MetaT) Failed() bool {
 	return t.fail
 }
 
@@ -102,99 +105,101 @@ func (t RuntimeT) Failed() bool {
 //
 // For compatibility, it mimics the string argument from
 // mitchellg/go-testing-interface.
-func (t RuntimeT) FailNow() {
+func (t MetaT) FailNow() {
 	panic("testing.T failed, see logs for output")
 }
 
 // Fatal is equivalent to Log followed by FailNow.
-func (t RuntimeT) Fatal(args ...interface{}) {
+func (t MetaT) Fatal(args ...interface{}) {
 	t.Log(args)
 	t.FailNow()
 }
 
 // Fatalf is equivalent to Logf followed by FailNow.
-func (t RuntimeT) Fatalf(format string, args ...interface{}) {
+func (t MetaT) Fatalf(format string, args ...interface{}) {
 	t.Logf(format, args...)
 	t.FailNow()
 }
 
 // Log formats its arguments using default formatting, analogous to
 // fmt.Println,, and records the text to standard output.
-func (t RuntimeT) Log(args ...interface{}) {
+func (t MetaT) Log(args ...interface{}) {
 	fmt.Println(fmt.Sprintf("%v", args))
 }
 
 // Logf formats its arguments according to the format, analogous to fmt.Printf,
 // and records the text to standard output.
-func (t RuntimeT) Logf(format string, args ...interface{}) {
+func (t MetaT) Logf(format string, args ...interface{}) {
 	fmt.Println(fmt.Sprintf(format, args...))
 }
 
-// Helper satisfies [T] and does nothing.
-func (r RuntimeT) Helper() {
+// Helper satisfies [BaseT] and does nothing.
+func (r MetaT) Helper() {
 }
 
-// Name satisfies [T] and returns an empty string.
-func (r RuntimeT) Name() string {
+// Name satisfies [BaseT] and returns an empty string.
+func (r MetaT) Name() string {
 	return ""
 }
 
-// Output satisfied [T] and returns io.Discard.
-func (r RuntimeT) Output() io.Writer {
+// Output satisfied [BaseT] and returns io.Discard.
+func (r MetaT) Output() io.Writer {
 	return io.Discard
 }
 
-// Parallel satisfies [T] and does nothing.
-func (r RuntimeT) Parallel() {
+// Parallel satisfies [BaseT] and does nothing.
+func (r MetaT) Parallel() {
 	panic("parallel not implemented") // TODO: Implement
 }
 
-// Setenv satisfies [T] and does nothing.
-func (r RuntimeT) Setenv(key string, value string) {
+// Setenv satisfies [BaseT] and does nothing.
+func (r MetaT) Setenv(key string, value string) {
 }
 
 // SkipNow marks the test as having been skipped.
 //
 // As a practical consideration, this does not stop execution in the way that
 // [testing.T.SkipNow] does -- RuntimeT.Run does not run its function in a
 // separate goroutine.
-func (t RuntimeT) SkipNow() {
+func (t MetaT) SkipNow() {
 	t.Skip()
 }
 
 // Skipf is equivalent to Logf followed by SkipNow.
-func (t RuntimeT) Skipf(format string, args ...interface{}) {
+func (t MetaT) Skipf(format string, args ...interface{}) {
 	t.Logf(format, args...)
 	t.Skip()
 }
 
-// TempDir satisfies [T] and returns "/dev/null".
-func (r RuntimeT) TempDir() string {
+// TempDir satisfies [BaseT] and returns "/dev/null".
+func (r MetaT) TempDir() string {
 	return "/dev/null"
 }
 
 // Skip is equivalent to Log followed by SkipNow.
-func (t RuntimeT) Skip(args ...interface{}) {
+func (t MetaT) Skip(args ...interface{}) {
 	t.Log(args)
 	t.skip = true
 }
 
 // Skipped reports whether the test was skipped.
-func (t RuntimeT) Skipped() bool {
+func (t MetaT) Skipped() bool {
 	return t.skip
 }
 
-// tshim embeds a [testing.T] and satisfies [T].
-type tshim struct {
+var _ BaseT = StandardT{}
+
+// StandardT embeds a [testing.T] and satisfies [BaseT].
+type StandardT struct {
 	*testing.T
 }
 
 // Run runs f as a subtest of t.
 //
 // As practical consideration, this does nsot run its function in a separate
 // goroutine and the name is not used.
-func (t tshim) Run(name string, f func(T)) bool {
+func (t StandardT) Run(name string, f func(BaseT)) bool {
 	return t.T.Run(name, func(t *testing.T) {
-		f(tshim{t})
+		f(StandardT{t})
 	})
 }