General improvements.

Removed NilError.
Renamed ErrorsNotFatal to just NotFatal.
Comment changes.
Test case changes.

Author: pat42smith

cmd.go

@@ -92,6 +92,8 @@ func (c *Cmd) WantCode(expected int) {
 }
 
 // Chdir sets the working directory where the command will be run.
+// Chdir(""), the default, is equivalent to Chdir("."); it uses
+// the current directory.
 func (c *Cmd) Chdir(path string) {
 	c.dir = path
 }
@@ -197,7 +199,7 @@ func (c *Cmd) Run(t Reporter, input string) {
 		if out.Len() == 0 {
 			t.Error("no output")
 		} else {
-			// Don't use t.Error("output\n" + out.String()); the output usually ends with a newline,
+			// Don't use t.Error("output:\n" + out.String()); the output usually ends with a newline,
 			// and t.Error always adds another newline.
 			t.Errorf("output:\n%s", out.String())
 		}

cmd_test.go

@@ -127,13 +127,13 @@ exit code: 0
 
 	st.Reset()
 	c.CheckStdout(nil)
-	c.Run(&st, "whatever")
+	c.Run(&st, "greenery")
 	st.Expect(t, true, true, `unexpected output
 command: /bin/sh -c read x; echo a $x b
 input:
-whatever
+greenery
 output:
-a whatever b
+a greenery b
 no error output
 exit code: 0
 `)
@@ -180,14 +180,14 @@ exit code: 99
 
 	st.Reset()
 	c.CheckStderr(nil)
-	c.Run(&st, "something")
+	c.Run(&st, "tropical")
 	st.Expect(t, true, true, `unexpected error output
 command: /bin/sh -c read x; if [ "$x" != nothing ]; then echo $x >&2; exit 99; fi
 input:
-something
+tropical
 no output
 error output:
-something
+tropical
 exit code: 99
 `)
 
@@ -349,8 +349,12 @@ func TestCmdChdir(t *testing.T) {
 
 	path := filepath.Join(tmp, "somefile")
 	f, e := os.Create(path)
-	NilError(t, e)
-	NilError(t, f.Close())
+	if e == nil {
+		e = f.Close()
+	}
+	if e != nil {
+		t.Fatal(e)
+	}
 
 	c := Command("/bin/ls")
 	c.Chdir(tmp)

go.mod

@@ -1,3 +1,3 @@
 module github.com/pat42smith/gotest
 
-go 1.18
+go 1.21

gotest.go

@@ -1,4 +1,4 @@
-// Copyright 2022 Patrick Smith
+// Copyright 2022-2023 Patrick Smith
 // Use of this source code is subject to the MIT-style license in the LICENSE file.
 
 // Package gotest provides support for writing test cases in Go.
@@ -10,7 +10,7 @@
 //
 // By default, these functions use FailNow, Fatal, or Fatalf to report errors,
 // so they terminate the running test on the first error. This behavior may
-// be changed with the ErrorsNotFatal wrapper.
+// be changed with the NotFatal wrapper.
 package gotest
 
 // Type Reporter is an interface satisfied by the testing.T, .B, and .F types.
@@ -20,7 +20,8 @@ package gotest
 // can properly mark themselves as helper functions.
 //
 // In future, more methods from the intersection of T, B, and F may be added.
-// Be warned that code using Reporter in unusual ways may break if this happens.
+// Be warned that this may break code containing types designed to implement Reporter;
+// you create such types at your own risk.
 type Reporter interface {
 	Error(args ...any)
 	Errorf(format string, args ...any)
@@ -38,7 +39,7 @@ type Reporter interface {
 func Require(t Reporter, condition bool) {
 	t.Helper()
 	if !condition {
-		t.Fatal("Test requirement failed")
+		t.Fatal("Required condition failed")
 	}
 }
 
@@ -50,19 +51,12 @@ func Expect[T comparable](t Reporter, expected, actual T) {
 	}
 }
 
-// NilError fails and terminates the test if passed a non-nil error.
-func NilError(t Reporter, e error) {
-	t.Helper()
-	if e != nil {
-		t.Fatal(e)
-	}
-}
-
 // Function panics runs f and reports whether it panics.
 //
 // If f panics, panics returns true and the value passed to panic.
 // Otherwise, panics returns (false, nil).
-// If f calls panic(nil), panics will correctly return (true, nil).
+// If f calls panic(nil), panics will return (true, nil) in Go 1.20 and
+// earlier. It will return true and a non-nil value in 1.21 and later.
 func panics(f func()) (panicked bool, with any) {
 	defer func() {
 		if panicked {
@@ -78,6 +72,8 @@ func panics(f func()) (panicked bool, with any) {
 //
 // If f does not panic, MustPanic terminates the running test with an error.
 // If f does panic, MustPanic returns the value that was passed to panic.
+// However, if f calls panic(nil), MustPanic will return a non-nil value
+// in Go 1.21 and later versions.
 func MustPanic(t Reporter, f func()) any {
 	t.Helper()
 	panicked, with := panics(f)
@@ -87,22 +83,25 @@ func MustPanic(t Reporter, f func()) any {
 	return with
 }
 
-// ErrorsNotFatal wraps a Reporter, and redirects fatal errors to non-terminating errors.
-type ErrorsNotFatal struct {
+// NotFatal wraps a Reporter, and redirects fatal errors to non-terminating errors.
+type NotFatal struct {
 	Reporter
 }
 
-// ErrorsNotFatal.FailNow marks a test failed, but does not not terminate it.
-func (enf ErrorsNotFatal) FailNow() {
-	enf.Fail()
+// NotFatal.FailNow marks a test failed, but does not not terminate the test;
+// it is equivalent to nf.Fail().
+func (nf NotFatal) FailNow() {
+	nf.Fail()
 }
 
-// ErrorsNotFatal.Fatal reports an error without terminating the test.
-func (enf ErrorsNotFatal) Fatal(args ...any) {
-	enf.Error(args...)
+// NotFatal.Fatal reports an error without terminating the test;
+// it is equivalent to nf.Error(args...).
+func (nf NotFatal) Fatal(args ...any) {
+	nf.Error(args...)
 }
 
-// ErrorsNotFatal.Fatal reports an error without terminating the test.
-func (enf ErrorsNotFatal) Fatalf(format string, args ...any) {
-	enf.Errorf(format, args...)
+// NotFatal.Fatal reports an error without terminating the test;
+// it is equivalent to nf.Errorf(format, args...).
+func (nf NotFatal) Fatalf(format string, args ...any) {
+	nf.Errorf(format, args...)
 }

gotest_test.go

@@ -4,10 +4,9 @@
 package gotest
 
 import (
-	"fmt"
 	"os"
 	"path/filepath"
-	"strconv"
+	"runtime"
 	"strings"
 	"testing"
 )
@@ -18,16 +17,7 @@ func TestRequire(t *testing.T) {
 	st.Expect(t, false, false, "")
 
 	Require(&st, false)
-	st.Expect(t, true, true, "Test requirement failed\n")
-}
-
-func TestNilError(t *testing.T) {
-	var st StubReporter
-	NilError(&st, nil)
-	st.Expect(t, false, false, "")
-
-	NilError(&st, fmt.Errorf("oops"))
-	st.Expect(t, true, true, "oops\n")
+	st.Expect(t, true, true, "Required condition failed\n")
 }
 
 func TestExpect(t *testing.T) {
@@ -39,36 +29,28 @@ func TestExpect(t *testing.T) {
 	st.Expect(t, true, true, "Expected a but actual value was b\n")
 
 	// This should not compile, as the arguments have different types: Expect(&st, 7, "7")
-	testprogram := `package main_test
+	testprogram := `package foo
 import "github.com/pat42smith/gotest"
 import "testing"
 
-func TestExpect(t *testing.T) {
+func Try(t *testing.T) {
 	gotest.Expect(t, 7, "7")
 }`
 
-	here, e := os.Getwd()
-	NilError(t, e)
-	here = strconv.Quote(here)
-	gomod := `module main
-go 1.18
-require github.com/pat42smith/gotest v0.0.0
-replace github.com/pat42smith/gotest => ` + here + "\n"
-
 	tmp := t.TempDir()
-	testfile := filepath.Join(tmp, "main_test.go")
-	NilError(t, os.WriteFile(testfile, []byte(testprogram), 0444))
-	modfile := filepath.Join(tmp, "go.mod")
-	NilError(t, os.WriteFile(modfile, []byte(gomod), 0444))
+	testfile := filepath.Join(tmp, "foo.go")
+	if e := os.WriteFile(testfile, []byte(testprogram), 0444); e != nil {
+		t.Fatal(e)
+	}
 
-	cmd := Command("go", "test")
-	cmd.Chdir(tmp)
+	cmd := Command("go", "build", testfile)
 	cmd.CheckStderr(func(actual string) bool {
-		return strings.Contains(actual, `default type string of "7" does not match inferred type int for T`)
+		return strings.Contains(actual, `mismatched types untyped int and untyped string (cannot infer T)`)
 	})
+	cmd.Run(t, "")
 }
 
-func Testpanics(t *testing.T) {
+func TestPanics(t *testing.T) {
 	p, w := panics(func() {})
 	Expect(t, false, p)
 	Require(t, w == nil) // Can't use Expect(t, nil, w) because w (type any) does not implement comparable.
@@ -79,13 +61,15 @@ func Testpanics(t *testing.T) {
 	Expect(t, true, p)
 	Require(t, w == 97)
 
-	// panic(nil) is a special case that appears to the recover function as if no panic happened.
-	// So be sure to check this case.
+	// panic(nil) is a special case that, in older versions of Go, appeared to the recover
+	// function as if no panic happened.  Since Go 1.21, it causes a runtime panic.
 	p, w = panics(func() {
 		panic(nil)
 	})
 	Expect(t, true, p)
-	Require(t, w == nil)
+	if _, ok := w.(*runtime.PanicNilError); !ok {
+		t.Fatalf("result of panics after panic(nil) is a %T; expected *runtime.PanicNilError", w)
+	}
 }
 
 func TestMustPanic(t *testing.T) {
@@ -101,14 +85,14 @@ func TestMustPanic(t *testing.T) {
 	Require(t, x == nil)
 }
 
-func TestErrorsNotFatal(t *testing.T) {
+func TestNotFatal(t *testing.T) {
 	var st1, st2, st3 StubReporter
-	ErrorsNotFatal{&st1}.FailNow()
+	NotFatal{&st1}.FailNow()
 	st1.Expect(t, true, false, "")
 
-	ErrorsNotFatal{&st2}.Fatal("problem")
+	NotFatal{&st2}.Fatal("problem")
 	st2.Expect(t, true, false, "problem\n")
 
-	ErrorsNotFatal{&st3}.Fatalf("<%s>", "uh oh")
+	NotFatal{&st3}.Fatalf("<%s>", "uh oh")
 	st3.Expect(t, true, false, "<uh oh>\n")
 }

stubreporter.go

@@ -107,22 +107,21 @@ func (sr *StubReporter) Fatalf(format string, args ...any) {
 // Expect verifies the status of the StubReporter.
 //
 // The failed, killed, and log parameters are compared to the StubReporter status.
-// If they do not match, an error is reported to t; the message will include
-// the when parameter.
+// If they do not match, an error is reported to t.
 func (sr *StubReporter) Expect(t Reporter, failed, killed bool, log string) {
 	t.Helper()
 	ok := true
 	if sr.Failed() != failed {
 		ok = false
-		if !failed {
+		if sr.Failed() {
 			t.Error("StubReporter marked failed")
 		} else {
 			t.Error("StubReporter marked not failed")
 		}
 	}
 	if sr.Killed() != killed {
 		ok = false
-		if !killed {
+		if sr.Killed() {
 			t.Error("StubReporter marked killed")
 		} else {
 			t.Error("StubReporter marked not killed")

stubreporter_test.go

@@ -11,10 +11,16 @@ import (
 func TestStubHelper(t *testing.T) {
 	var sr StubReporter
 	sr.Helper()
-	// If it returned, we're fine.
+	sr.Expect(t, false, false, "")
+
+	sr.failed = true
+	sr.killed = true
+	fmt.Fprintln(&sr.log, "boo")
+	sr.Helper()
+	sr.Expect(t, true, true, "boo\n")
 }
 
-func TestStubSRExpect(t *testing.T) {
+func TestStubExpect(t *testing.T) {
 	for bits := 0; bits < 0100; bits++ {
 		var sr StubReporter
 		if bits&1 != 0 {
@@ -115,6 +121,8 @@ func TestStubReset(t *testing.T) {
 	sr.Expect(t, true, true, "boo\n")
 	sr.Reset()
 	sr.Expect(t, false, false, "")
+	sr.Reset()
+	sr.Expect(t, false, false, "")
 }
 
 func TestStubMessages(t *testing.T) {