Remove all go 1.20 features from test usage

This commit removes all test code that references:
- go 1.20 `errors.Join` function.
- go 1.20 multi-cause `fmt.Errorf` that contain multiple `%w`
formatting directives.

This commit also reverts go.mod to use 1.17 to match the state of the
codebase from before the go 1.20 upgrade.

This allows older codebases to upgrade to a version of this library
that can encode/decode multi-cause errors from newer versions without
completely discarding the child cause error info.

.github/workflows/ci.yaml

@@ -2,9 +2,9 @@ name: Go
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, go-1.17-compat ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, go-1.17-compat ]
 
 jobs:
 
@@ -13,8 +13,10 @@ jobs:
     strategy:
       matrix:
         go:
+          - "1.17"
+          - "1.18"
+          - "1.19"
           - "1.20"
-          - "1.21"
     steps:
     - uses: actions/checkout@v2
 

errbase/adapters_test.go

@@ -68,31 +68,6 @@ func TestAdaptGoSingleWrapErr(t *testing.T) {
 	tt.CheckContains(newErr.Error(), "hello")
 }
 
-func TestAdaptBaseGoJoinErr(t *testing.T) {
-	origErr := goErr.Join(goErr.New("hello"), goErr.New("world"))
-	t.Logf("start err: %# v", pretty.Formatter(origErr))
-
-	newErr := network(t, origErr)
-
-	tt := testutils.T{T: t}
-	// The library preserves the error message.
-	tt.CheckEqual(newErr.Error(), origErr.Error())
-
-}
-
-func TestAdaptGoMultiWrapErr(t *testing.T) {
-	origErr := fmt.Errorf("an error %w and also %w", goErr.New("hello"), goErr.New("world"))
-	t.Logf("start err: %# v", pretty.Formatter(origErr))
-
-	newErr := network(t, origErr)
-
-	tt := testutils.T{T: t}
-	// The library preserves the causes. It's not possible to preserve the fmt string.
-	tt.CheckEqual(newErr.Error(), origErr.Error())
-	tt.CheckContains(newErr.Error(), "hello")
-	tt.CheckContains(newErr.Error(), "world")
-}
-
 func TestAdaptPkgWithMessage(t *testing.T) {
 	// Simple message wrappers from github.com/pkg/errors are preserved
 	// completely.

errbase/format_error_internal_test.go

@@ -130,18 +130,6 @@ func TestFormatErrorInternal(t *testing.T) {
 Wraps: (2) ab
 Wraps: (3) b
 Error types: (1) *fmt.wrapError (2) *fmt.wrapError (3) *errors.errorString`,
-		},
-		{
-			name:           "simple multi-wrapper",
-			err:            goErr.Join(goErr.New("a"), goErr.New("b")),
-			expectedSimple: "a\nb",
-			// TODO(davidh): verbose test case should have line break
-			// between `a` and `b` on second line.
-			expectedVerbose: `a
-(1) ab
-Wraps: (2) b
-Wraps: (3) a
-Error types: (1) *errors.joinError (2) *errors.errorString (3) *errors.errorString`,
 		},
 		{
 			name: "multi-wrapper with custom formatter and partial elide",
@@ -190,91 +178,6 @@ Error types: (1) *errbase.wrapNoElideCauses (2) *errbase.wrapNoElideCauses (3) *
   | c
   | d
 Error types: (1) *errors.errorString`,
-		},
-		{
-			name: "two-level multi-wrapper",
-			err: goErr.Join(
-				goErr.Join(goErr.New("a"), goErr.New("b")),
-				goErr.Join(goErr.New("c"), goErr.New("d")),
-			),
-			expectedSimple: "a\nb\nc\nd",
-			// TODO(davidh): verbose output should preserve line breaks after (1)
-			// and also after (2) and (5) in `c\nd` and `a\nb`.
-			expectedVerbose: `a
-(1) ab
-  |
-  | c
-  | d
-Wraps: (2) cd
-└─ Wraps: (3) d
-└─ Wraps: (4) c
-Wraps: (5) ab
-└─ Wraps: (6) b
-└─ Wraps: (7) a
-Error types: (1) *errors.joinError (2) *errors.joinError (3) *errors.errorString (4) *errors.errorString (5) *errors.joinError (6) *errors.errorString (7) *errors.errorString`,
-		},
-		{
-			name: "simple multi-wrapper with single-cause chains inside",
-			err: goErr.Join(
-				fmt.Errorf("a%w", goErr.New("b")),
-				fmt.Errorf("c%w", goErr.New("d")),
-			),
-			expectedSimple: "ab\ncd",
-			expectedVerbose: `ab
-(1) ab
-  | cd
-Wraps: (2) cd
-└─ Wraps: (3) d
-Wraps: (4) ab
-└─ Wraps: (5) b
-Error types: (1) *errors.joinError (2) *fmt.wrapError (3) *errors.errorString (4) *fmt.wrapError (5) *errors.errorString`,
-		},
-		{
-			name: "multi-cause wrapper with single-cause chains inside",
-			err: goErr.Join(
-				fmt.Errorf("a%w", fmt.Errorf("b%w", fmt.Errorf("c%w", goErr.New("d")))),
-				fmt.Errorf("e%w", fmt.Errorf("f%w", fmt.Errorf("g%w", goErr.New("h")))),
-			),
-			expectedSimple: `abcd
-efgh`,
-			expectedVerbose: `abcd
-(1) abcd
-  | efgh
-Wraps: (2) efgh
-└─ Wraps: (3) fgh
-  └─ Wraps: (4) gh
-    └─ Wraps: (5) h
-Wraps: (6) abcd
-└─ Wraps: (7) bcd
-  └─ Wraps: (8) cd
-    └─ Wraps: (9) d
-Error types: (1) *errors.joinError (2) *fmt.wrapError (3) *fmt.wrapError (4) *fmt.wrapError (5) *errors.errorString (6) *fmt.wrapError (7) *fmt.wrapError (8) *fmt.wrapError (9) *errors.errorString`},
-		{
-			name: "single cause chain with multi-cause wrapper inside with single-cause chains inside",
-			err: fmt.Errorf(
-				"prefix1: %w",
-				fmt.Errorf(
-					"prefix2: %w",
-					goErr.Join(
-						fmt.Errorf("a%w", fmt.Errorf("b%w", fmt.Errorf("c%w", goErr.New("d")))),
-						fmt.Errorf("e%w", fmt.Errorf("f%w", fmt.Errorf("g%w", goErr.New("h")))),
-					))),
-			expectedSimple: `prefix1: prefix2: abcd
-efgh`,
-			expectedVerbose: `prefix1: prefix2: abcd
-(1) prefix1
-Wraps: (2) prefix2
-Wraps: (3) abcd
-  | efgh
-  └─ Wraps: (4) efgh
-    └─ Wraps: (5) fgh
-      └─ Wraps: (6) gh
-        └─ Wraps: (7) h
-  └─ Wraps: (8) abcd
-    └─ Wraps: (9) bcd
-      └─ Wraps: (10) cd
-        └─ Wraps: (11) d
-Error types: (1) *fmt.wrapError (2) *fmt.wrapError (3) *errors.joinError (4) *fmt.wrapError (5) *fmt.wrapError (6) *fmt.wrapError (7) *errors.errorString (8) *fmt.wrapError (9) *fmt.wrapError (10) *fmt.wrapError (11) *errors.errorString`,
 		},
 		{
 			name:           "test wrapMini elides cause error string",

errbase/unwrap_test.go

@@ -16,7 +16,6 @@ package errbase_test
 
 import (
 	"errors"
-	"fmt"
 	"testing"
 
 	"github.com/cockroachdb/errors/errbase"
@@ -59,18 +58,6 @@ func TestMixedErrorWrapping(t *testing.T) {
 	tt.CheckEqual(errbase.UnwrapAll(err3), err)
 }
 
-func TestMultiErrorUnwrap(t *testing.T) {
-	tt := testutils.T{T: t}
-
-	err := errors.New("hello")
-	err2 := pkgErr.WithMessage(err, "woo")
-	err3 := fmt.Errorf("%w %w", err, err2)
-
-	tt.CheckEqual(errbase.UnwrapOnce(err3), nil)
-	tt.CheckEqual(errbase.UnwrapAll(err3), err3)
-	tt.CheckDeepEqual(errbase.UnwrapMulti(err3), []error{err, err2})
-}
-
 type myWrapper struct{ cause error }
 
 func (w *myWrapper) Error() string { return w.cause.Error() }

errutil/as_test.go

@@ -15,7 +15,6 @@
 package errutil_test
 
 import (
-	goErr "errors"
 	"fmt"
 	"testing"
 
@@ -61,12 +60,6 @@ func TestAs(t *testing.T) {
 	tt.Check(errors.As(multiWrapErr, &mywSlot))
 	tt.Check(errors.Is(mywSlot, refwErr))
 
-	// Check that it works even if hidden in multi-cause wrapErrors
-	multiWrapErr = fmt.Errorf("error: %w and %w", errors.Wrap(refwErr, "hidden"), errors.New("world"))
-	mywSlot = nil
-	tt.Check(errors.As(multiWrapErr, &mywSlot))
-	tt.Check(errors.Is(mywSlot, refwErr))
-
 	// Check that it works even if hidden in custom multi-error
 	multiWrapErr = &myMultiWrapper{
 		causes: []error{errors.Wrap(refwErr, "hidden"), errors.New("world")},
@@ -75,19 +68,6 @@ func TestAs(t *testing.T) {
 	mywSlot = nil
 	tt.Check(errors.As(multiWrapErr, &mywSlot))
 	tt.Check(errors.Is(mywSlot, refwErr))
-
-	// Check that it works even if hidden in a multi-level multi-cause chain
-	multiWrapErr = fmt.Errorf("error: %w and %w",
-		&myMultiWrapper{
-			causes: []error{errors.New("ignoreme"), errors.New("also ignore")},
-			msg:    "red herring",
-		}, &myMultiWrapper{
-			causes: []error{errors.Wrap(refwErr, "hidden"), errors.New("world")},
-			msg:    "errors",
-		})
-	mywSlot = nil
-	tt.Check(errors.As(multiWrapErr, &mywSlot))
-	tt.Check(errors.Is(mywSlot, refwErr))
 }
 
 type myType struct{ msg string }
@@ -106,7 +86,9 @@ type myMultiWrapper struct {
 	msg    string
 }
 
-func (m *myMultiWrapper) Error() string { return fmt.Sprintf("%s: %v", m.msg, goErr.Join(m.causes...)) }
+func (m *myMultiWrapper) Error() string {
+	return fmt.Sprintf("%s: %v", m.msg, errors.Join(m.causes...))
+}
 
 func (m *myMultiWrapper) Unwrap() []error {
 	return m.causes

errutil_api_test.go

@@ -6,19 +6,8 @@ import (
 	"testing"
 
 	"github.com/cockroachdb/errors"
-	"github.com/cockroachdb/errors/testutils"
 )
 
-func TestUnwrap(t *testing.T) {
-	tt := testutils.T{t}
-
-	e := fmt.Errorf("foo %w %w", fmt.Errorf("bar"), fmt.Errorf("baz"))
-
-	// Compatibility with go 1.20: Unwrap() on a multierror returns nil
-	// (per API documentation)
-	tt.Check(errors.Unwrap(e) == nil)
-}
-
 // More detailed testing of Join is in datadriven_test.go. Here we make
 // sure that the public API includes the stacktrace wrapper.
 func TestJoin(t *testing.T) {

fmttests/datadriven_test.go

@@ -158,9 +158,6 @@ var wrapCommands = map[string]commandFn{
 	"go-errorf-suffix": func(e error, args []arg) error {
 		return fmt.Errorf("%w - %s", e, strfy(args))
 	},
-	"go-errorf-multi": func(err error, args []arg) error {
-		return fmt.Errorf("%s - %w %w", strfy(args), err, pkgErr.New("sibling error in wrapper"))
-	},
 	"opaque": func(err error, _ []arg) error {
 		return errbase.DecodeError(context.Background(),
 			errbase.EncodeError(context.Background(), err))