Function TestFormat

domains/domains_test.go:179–242

(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
	}{
		{"keys",
			domains.WithDomain(baseErr, domains.NoDomain),
			woo, `
woo
(1) error domain: <none>
Wraps: (2) woo
Error types: (1) *domains.withDomain (2) *errors.errorString`},

		{"keys + wrapper",
			domains.WithDomain(&werrFmt{baseErr, "waa"}, domains.NoDomain),
			waawoo, `
waa: woo
(1) error domain: <none>
Wraps: (2) waa
  | -- this is waa's
  | multi-line payload
Wraps: (3) woo
Error types: (1) *domains.withDomain (2) *domains_test.werrFmt (3) *errors.errorString`},

		{"wrapper + keys",
			&werrFmt{domains.WithDomain(baseErr, domains.NoDomain), "waa"},
			waawoo, `
waa: woo
(1) waa
  | -- this is waa's
  | multi-line payload
Wraps: (2) error domain: <none>
Wraps: (3) woo
Error types: (1) *domains_test.werrFmt (2) *domains.withDomain (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.