Function TestFormat

assert/assert_test.go:61–124

(t *testing.T)

}

func TestFormat(t *testing.T) {
	tt := testutils.T{t}

	baseErr := goErr.New("woo")
	const woo = `woo`
	const waawoo = `waa: woo`
	testCases := []struct {
		name          string
		err           error
		expFmtSimple  string
		expFmtVerbose string
	}{
		{"assert",
			assert.WithAssertionFailure(baseErr),
			woo, `
woo
(1) assertion failure
Wraps: (2) woo
Error types: (1) *assert.withAssertionFailure (2) *errors.errorString`},

		{"assert + wrapper",
			assert.WithAssertionFailure(&werrFmt{baseErr, "waa"}),
			waawoo, `
waa: woo
(1) assertion failure
Wraps: (2) waa
  | -- this is waa's
  | multi-line payload
Wraps: (3) woo
Error types: (1) *assert.withAssertionFailure (2) *assert_test.werrFmt (3) *errors.errorString`},

		{"wrapper + assert",
			&werrFmt{assert.WithAssertionFailure(baseErr), "waa"},
			waawoo, `
waa: woo
(1) waa
  | -- this is waa's
  | multi-line payload
Wraps: (2) assertion failure
Wraps: (3) woo
Error types: (1) *assert_test.werrFmt (2) *assert.withAssertionFailure (3) *errors.errorString`},
	}

	for _, test := range testCases {
		tt.Run(test.name, func(tt testutils.T) {
			err := test.err

			// %s is simple formatting
			tt.CheckStringEqual(fmt.Sprintf("%s", err), test.expFmtSimple)

			// %v is simple formatting too, for compatibility with the past.
			tt.CheckStringEqual(fmt.Sprintf("%v", err), test.expFmtSimple)

			// %q is always like %s but quotes the result.
			ref := fmt.Sprintf("%q", test.expFmtSimple)
			tt.CheckStringEqual(fmt.Sprintf("%q", err), ref)

			// %+v is the verbose mode.