From d61cf894c4bcfa5e70def688dc3215741f508e26 Mon Sep 17 00:00:00 2001 From: fabstu Date: Fri, 5 Aug 2016 03:06:31 +0200 Subject: [PATCH 1/4] Add WithStack and WithMessage tests Adds testFormatCompleteCompare as additional testing func. The new function takes a string slice as "want", wherein stacktraces and non-stacktrace messages are discerned by strings.ContainsAny(want[i], "\n"). For example usage, see TestFormatWithStack & TestFormatWithMessage. --- errors_test.go | 91 +++++++++++++--- example_test.go | 53 +++++++++ format_test.go | 277 ++++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 398 insertions(+), 23 deletions(-) diff --git a/errors_test.go b/errors_test.go index 11d45554..c4ca6179 100644 --- a/errors_test.go +++ b/errors_test.go @@ -84,6 +84,18 @@ func TestCause(t *testing.T) { }, { err: x, // return from errors.New want: x, + }, { + WithMessage(nil, "whoops"), + nil, + }, { + WithMessage(io.EOF, "whoops"), + io.EOF, + }, { + WithStack(nil), + nil, + }, { + WithStack(io.EOF), + io.EOF, }} for i, tt := range tests { @@ -137,23 +149,78 @@ func TestErrorf(t *testing.T) { } } +func TestWithStackNil(t *testing.T) { + got := WithStack(nil) + if got != nil { + t.Errorf("WithStack(nil): got %#v, expected nil", got) + } +} + +func TestWithStack(t *testing.T) { + tests := []struct { + err error + want string + }{ + {io.EOF, "EOF"}, + {WithStack(io.EOF), "EOF"}, + } + + for _, tt := range tests { + got := WithStack(tt.err).Error() + if got != tt.want { + t.Errorf("WithStack(%v): got: %v, want %v", tt.err, got, tt.want) + } + } +} + +func TestWithMessageNil(t *testing.T) { + got := WithMessage(nil, "no error") + if got != nil { + t.Errorf("WithMessage(nil, \"no error\"): got %#v, expected nil", got) + } +} + +func TestWithMessage(t *testing.T) { + tests := []struct { + err error + message string + want string + }{ + {io.EOF, "read error", "read error: EOF"}, + {WithMessage(io.EOF, "read error"), "client error", "client error: read error: EOF"}, + } + + for _, tt := range tests { + got := WithMessage(tt.err, tt.message).Error() + if got != tt.want { + t.Errorf("WithMessage(%v, %q): got: %q, want %q", tt.err, tt.message, got, tt.want) + } + } + +} + // errors.New, etc values are not expected to be compared by value // but the change in errors#27 made them incomparable. Assert that // various kinds of errors have a functional equality operator, even // if the result of that equality is always false. func TestErrorEquality(t *testing.T) { - tests := []struct { - err1, err2 error - }{ - {io.EOF, io.EOF}, - {io.EOF, nil}, - {io.EOF, errors.New("EOF")}, - {io.EOF, New("EOF")}, - {New("EOF"), New("EOF")}, - {New("EOF"), Errorf("EOF")}, - {New("EOF"), Wrap(io.EOF, "EOF")}, + vals := []error{ + nil, + io.EOF, + errors.New("EOF"), + New("EOF"), + Errorf("EOF"), + Wrap(io.EOF, "EOF"), + Wrapf(io.EOF, "EOF%d", 2), + WithMessage(nil, "whoops"), + WithMessage(io.EOF, "whoops"), + WithStack(io.EOF), + WithStack(nil), } - for _, tt := range tests { - _ = tt.err1 == tt.err2 // mustn't panic + + for i := 0; i < len(vals); i++ { + for j := 0; j < len(vals); j++ { + _ = vals[i] == vals[j] // mustn't panic + } } } diff --git a/example_test.go b/example_test.go index 5bec3ad4..c1fc13e3 100644 --- a/example_test.go +++ b/example_test.go @@ -35,6 +35,59 @@ func ExampleNew_printf() { // /home/dfc/go/src/runtime/asm_amd64.s:2059 } +func ExampleWithMessage() { + cause := errors.New("whoops") + err := errors.WithMessage(cause, "oh noes") + fmt.Println(err) + + // Output: oh noes: whoops +} + +func ExampleWithStack() { + cause := errors.New("whoops") + err := errors.WithStack(cause) + fmt.Println(err) + + // Output: whoops +} + +func ExampleWithStack_printf() { + cause := errors.New("whoops") + err := errors.WithStack(cause) + fmt.Printf("%+v", err) + + // Example Output: + // whoops + // github.com/pkg/errors_test.ExampleWithStack_printf + // /home/fabstu/go/src/github.com/pkg/errors/example_test.go:55 + // testing.runExample + // /usr/lib/go/src/testing/example.go:114 + // testing.RunExamples + // /usr/lib/go/src/testing/example.go:38 + // testing.(*M).Run + // /usr/lib/go/src/testing/testing.go:744 + // main.main + // github.com/pkg/errors/_test/_testmain.go:106 + // runtime.main + // /usr/lib/go/src/runtime/proc.go:183 + // runtime.goexit + // /usr/lib/go/src/runtime/asm_amd64.s:2086 + // github.com/pkg/errors_test.ExampleWithStack_printf + // /home/fabstu/go/src/github.com/pkg/errors/example_test.go:56 + // testing.runExample + // /usr/lib/go/src/testing/example.go:114 + // testing.RunExamples + // /usr/lib/go/src/testing/example.go:38 + // testing.(*M).Run + // /usr/lib/go/src/testing/testing.go:744 + // main.main + // github.com/pkg/errors/_test/_testmain.go:106 + // runtime.main + // /usr/lib/go/src/runtime/proc.go:183 + // runtime.goexit + // /usr/lib/go/src/runtime/asm_amd64.s:2086 +} + func ExampleWrap() { cause := errors.New("whoops") err := errors.Wrap(cause, "oh noes") diff --git a/format_test.go b/format_test.go index 3b1746c0..dbef5848 100644 --- a/format_test.go +++ b/format_test.go @@ -1,6 +1,7 @@ package errors import ( + "errors" "fmt" "io" "regexp" @@ -26,7 +27,7 @@ func TestFormatNew(t *testing.T) { "%+v", "error\n" + "github.com/pkg/errors.TestFormatNew\n" + - "\t.+/github.com/pkg/errors/format_test.go:25", + "\t.+/github.com/pkg/errors/format_test.go:26", }} for i, tt := range tests { @@ -52,7 +53,7 @@ func TestFormatErrorf(t *testing.T) { "%+v", "error\n" + "github.com/pkg/errors.TestFormatErrorf\n" + - "\t.+/github.com/pkg/errors/format_test.go:51", + "\t.+/github.com/pkg/errors/format_test.go:52", }} for i, tt := range tests { @@ -78,7 +79,7 @@ func TestFormatWrap(t *testing.T) { "%+v", "error\n" + "github.com/pkg/errors.TestFormatWrap\n" + - "\t.+/github.com/pkg/errors/format_test.go:77", + "\t.+/github.com/pkg/errors/format_test.go:78", }, { Wrap(io.EOF, "error"), "%s", @@ -93,14 +94,14 @@ func TestFormatWrap(t *testing.T) { "EOF\n" + "error\n" + "github.com/pkg/errors.TestFormatWrap\n" + - "\t.+/github.com/pkg/errors/format_test.go:91", + "\t.+/github.com/pkg/errors/format_test.go:92", }, { Wrap(Wrap(io.EOF, "error1"), "error2"), "%+v", "EOF\n" + "error1\n" + "github.com/pkg/errors.TestFormatWrap\n" + - "\t.+/github.com/pkg/errors/format_test.go:98\n", + "\t.+/github.com/pkg/errors/format_test.go:99\n", }, { Wrap(New("error with space"), "context"), "%q", @@ -131,7 +132,7 @@ func TestFormatWrapf(t *testing.T) { "EOF\n" + "error2\n" + "github.com/pkg/errors.TestFormatWrapf\n" + - "\t.+/github.com/pkg/errors/format_test.go:129", + "\t.+/github.com/pkg/errors/format_test.go:130", }, { Wrapf(New("error"), "error%d", 2), "%s", @@ -145,7 +146,7 @@ func TestFormatWrapf(t *testing.T) { "%+v", "error\n" + "github.com/pkg/errors.TestFormatWrapf\n" + - "\t.+/github.com/pkg/errors/format_test.go:144", + "\t.+/github.com/pkg/errors/format_test.go:145", }} for i, tt := range tests { @@ -153,16 +154,270 @@ func TestFormatWrapf(t *testing.T) { } } +func TestFormatWithStack(t *testing.T) { + tests := []struct { + error + format string + want []string + }{{ + WithStack(io.EOF), + "%s", + []string{"EOF"}, + }, { + WithStack(io.EOF), + "%v", + []string{"EOF"}, + }, { + WithStack(io.EOF), + "%+v", + []string{"EOF", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:171"}, + }, { + WithStack(New("error")), + "%s", + []string{"error"}, + }, { + WithStack(New("error")), + "%v", + []string{"error"}, + }, { + WithStack(New("error")), + "%+v", + []string{"error", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:185", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:185"}, + }, { + WithStack(WithStack(io.EOF)), + "%+v", + []string{"EOF", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:193", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:193"}, + }, { + WithStack(WithStack(Wrapf(io.EOF, "message"))), + "%+v", + []string{"EOF", + "message", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:201", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:201", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:201"}, + }, { + WithStack(Errorf("error%d", 1)), + "%+v", + []string{"error1", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:212", + "github.com/pkg/errors.TestFormatWithStack\n" + + "\t.+/github.com/pkg/errors/format_test.go:212"}, + }} + + for i, tt := range tests { + testFormatCompleteCompare(t, i, tt.error, tt.format, tt.want) + } +} + +func TestFormatWithMessage(t *testing.T) { + tests := []struct { + error + format string + want []string + }{{ + WithMessage(New("error"), "error2"), + "%s", + []string{"error2: error"}, + }, { + WithMessage(New("error"), "error2"), + "%v", + []string{"error2: error"}, + }, { + WithMessage(New("error"), "error2"), + "%+v", + []string{ + "error", + "github.com/pkg/errors.TestFormatWithMessage\n" + + "\t.+/github.com/pkg/errors/format_test.go:240", + "error2"}, + }, { + WithMessage(io.EOF, "addition1"), + "%s", + []string{"addition1: EOF"}, + }, { + WithMessage(io.EOF, "addition1"), + "%v", + []string{"addition1: EOF"}, + }, { + WithMessage(io.EOF, "addition1"), + "%+v", + []string{"EOF", "addition1"}, + }, { + WithMessage(WithMessage(io.EOF, "addition1"), "addition2"), + "%v", + []string{"addition2: addition1: EOF"}, + }, { + WithMessage(WithMessage(io.EOF, "addition1"), "addition2"), + "%+v", + []string{"EOF", "addition1", "addition2"}, + }, { + Wrap(WithMessage(io.EOF, "error1"), "error2"), + "%+v", + []string{"EOF", "error1", "error2", + "github.com/pkg/errors.TestFormatWithMessage\n" + + "\t.+/github.com/pkg/errors/format_test.go:268"}, + }, { + WithMessage(Errorf("error%d", 1), "error2"), + "%+v", + []string{"error1", + "github.com/pkg/errors.TestFormatWithMessage\n" + + "\t.+/github.com/pkg/errors/format_test.go:274", + "error2"}, + }, { + WithMessage(WithStack(io.EOF), "error"), + "%+v", + []string{ + "EOF", + "github.com/pkg/errors.TestFormatWithMessage\n" + + "\t.+/github.com/pkg/errors/format_test.go:281", + "error"}, + }, { + WithMessage(Wrap(WithStack(io.EOF), "inside-error"), "outside-error"), + "%+v", + []string{ + "EOF", + "github.com/pkg/errors.TestFormatWithMessage\n" + + "\t.+/github.com/pkg/errors/format_test.go:289", + "inside-error", + "github.com/pkg/errors.TestFormatWithMessage\n" + + "\t.+/github.com/pkg/errors/format_test.go:289", + "outside-error"}, + }} + + for i, tt := range tests { + testFormatCompleteCompare(t, i, tt.error, tt.format, tt.want) + } +} + func testFormatRegexp(t *testing.T, n int, arg interface{}, format, want string) { got := fmt.Sprintf(format, arg) - lines := strings.SplitN(got, "\n", -1) - for i, w := range strings.SplitN(want, "\n", -1) { - match, err := regexp.MatchString(w, lines[i]) + gotLines := strings.SplitN(got, "\n", -1) + wantLines := strings.SplitN(want, "\n", -1) + + if len(wantLines) > len(gotLines) { + t.Errorf("test %d: wantLines(%d) > gotLines(%d):\n got: %q\nwant: %q", n+1, len(wantLines), len(gotLines), got, want) + return + } + + for i, w := range wantLines { + match, err := regexp.MatchString(w, gotLines[i]) if err != nil { t.Fatal(err) } if !match { - t.Errorf("test %d: line %d: fmt.Sprintf(%q, err): got: %q, want: %q", n+1, i+1, format, got, want) + t.Errorf("test %d: line %d: fmt.Sprintf(%q, err):\n got: %q\nwant: %q", n+1, i+1, format, got, want) + } + } +} + +var stackLineR = regexp.MustCompile(`\.`) + +// parseBlocks parses input into a slice, where: +// - incase entry contains a newline, its a stacktrace +// - incase entry contains no newline, its a solo line. +// +// Example use: +// +// for _, e := range blocks { +// if strings.ContainsAny(e, "\n") { +// // Match as stack +// } else { +// // Match as line +// } +// } +func parseBlocks(input string) ([]string, error) { + var blocks []string + + stack := "" + wasStack := false + lines := map[string]bool{} // already found lines + + for _, l := range strings.Split(input, "\n") { + isStackLine := stackLineR.MatchString(l) + + switch { + case !isStackLine && wasStack: + blocks = append(blocks, stack, l) + stack = "" + lines = map[string]bool{} + case isStackLine: + if wasStack { + // Detecting two stacks after another, possible cause lines match in + // our tests due to WithStack(WithStack(io.EOF)) on same line. + if lines[l] { + if len(stack) == 0 { + return nil, errors.New("len of block must not be zero here") + } + + blocks = append(blocks, stack) + stack = l + lines = map[string]bool{l: true} + continue + } + + stack = stack + "\n" + l + } else { + stack = l + } + lines[l] = true + case !isStackLine && !wasStack: + blocks = append(blocks, l) + default: + return nil, errors.New("must not happen") + } + + wasStack = isStackLine + } + + // Use up stack + if stack != "" { + blocks = append(blocks, stack) + } + return blocks, nil +} + +func testFormatCompleteCompare(t *testing.T, n int, arg interface{}, format string, want []string) { + gotStr := fmt.Sprintf(format, arg) + + got, err := parseBlocks(gotStr) + if err != nil { + t.Fatal(err) + } + + if len(got) != len(want) { + t.Fatalf("test %d: fmt.Sprintf(%s, err) -> wrong number of blocks: got(%d) want(%d)\n got: %q\nwant: %q\ngotStr: %q", + n+1, format, len(got), len(want), got, want, gotStr) + } + + for i := range got { + if strings.ContainsAny(want[i], "\n") { + // Match as stack + match, err := regexp.MatchString(want[i], got[i]) + if err != nil { + t.Fatal(err) + } + if !match { + t.Errorf("test %d: block %d: fmt.Sprintf(%q, err):\n got: %q\nwant: %q", n+1, i+1, format, got[i], want[i]) + } + } else { + // Match as message + if got[i] != want[i] { + t.Errorf("test %d: fmt.Sprintf(%s, err) at block %d got != want:\n got: %q\nwant: %q", n+1, format, i+1, got[i], want[i]) + } } } } From 601da7f5be7039a8298645c9fb4e9438a67cce61 Mon Sep 17 00:00:00 2001 From: fabstu Date: Fri, 5 Aug 2016 13:01:57 +0200 Subject: [PATCH 2/4] minor: refactored small loop --- errors_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/errors_test.go b/errors_test.go index c4ca6179..1d8c6355 100644 --- a/errors_test.go +++ b/errors_test.go @@ -218,8 +218,8 @@ func TestErrorEquality(t *testing.T) { WithStack(nil), } - for i := 0; i < len(vals); i++ { - for j := 0; j < len(vals); j++ { + for i := range vals { + for j := range vals { _ = vals[i] == vals[j] // mustn't panic } } From 8e45a9999ecf17ffd77ca9e52541434de05f30af Mon Sep 17 00:00:00 2001 From: fabstu Date: Sat, 6 Aug 2016 18:37:29 +0200 Subject: [PATCH 3/4] tests: added recursively trying out combinations of calls for %+v. --- format_test.go | 142 +++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 125 insertions(+), 17 deletions(-) diff --git a/format_test.go b/format_test.go index dbef5848..cc645c7a 100644 --- a/format_test.go +++ b/format_test.go @@ -219,7 +219,7 @@ func TestFormatWithStack(t *testing.T) { }} for i, tt := range tests { - testFormatCompleteCompare(t, i, tt.error, tt.format, tt.want) + testFormatCompleteCompare(t, i, tt.error, tt.format, tt.want, true) } } @@ -299,7 +299,60 @@ func TestFormatWithMessage(t *testing.T) { }} for i, tt := range tests { - testFormatCompleteCompare(t, i, tt.error, tt.format, tt.want) + testFormatCompleteCompare(t, i, tt.error, tt.format, tt.want, true) + } +} + +func TestFormatGeneric(t *testing.T) { + starts := []struct { + err error + want []string + }{ + {New("new-error"), []string{ + "new-error", + "github.com/pkg/errors.TestFormatGeneric\n" + + "\t.+/github.com/pkg/errors/format_test.go:311"}, + }, {Errorf("errorf-error"), []string{ + "errorf-error", + "github.com/pkg/errors.TestFormatGeneric\n" + + "\t.+/github.com/pkg/errors/format_test.go:315"}, + }, {errors.New("errors-new-error"), []string{ + "errors-new-error"}, + }, + } + + wrappers := []wrapper{ + { + func(err error) error { return WithMessage(err, "with-message") }, + []string{"with-message"}, + }, { + func(err error) error { return WithStack(err) }, + []string{ + "github.com/pkg/errors.TestFormatGeneric.func2\n\t" + + ".+/github.com/pkg/errors/format_test.go:329", + }, + }, { + func(err error) error { return Wrap(err, "wrap-error") }, + []string{ + "wrap-error", + "github.com/pkg/errors.TestFormatGeneric.func3\n\t" + + ".+/github.com/pkg/errors/format_test.go:335", + }, + }, { + func(err error) error { return Wrapf(err, "wrapf-error%d", 1) }, + []string{ + "wrapf-error1", + "github.com/pkg/errors.TestFormatGeneric.func4\n\t" + + ".+/github.com/pkg/errors/format_test.go:342", + }, + }, + } + + for s := range starts { + err := starts[s].err + want := starts[s].want + testFormatCompleteCompare(t, s, err, "%+v", want, false) + testGenericRecursive(t, err, want, wrappers, 3) } } @@ -330,6 +383,9 @@ var stackLineR = regexp.MustCompile(`\.`) // - incase entry contains a newline, its a stacktrace // - incase entry contains no newline, its a solo line. // +// Detecting stack boundaries only works incase the WithStack-calls are +// to be found on the same line, thats why it is optionally here. +// // Example use: // // for _, e := range blocks { @@ -339,7 +395,8 @@ var stackLineR = regexp.MustCompile(`\.`) // // Match as line // } // } -func parseBlocks(input string) ([]string, error) { +// +func parseBlocks(input string, detectStackboundaries bool) ([]string, error) { var blocks []string stack := "" @@ -358,15 +415,17 @@ func parseBlocks(input string) ([]string, error) { if wasStack { // Detecting two stacks after another, possible cause lines match in // our tests due to WithStack(WithStack(io.EOF)) on same line. - if lines[l] { - if len(stack) == 0 { - return nil, errors.New("len of block must not be zero here") - } + if detectStackboundaries { + if lines[l] { + if len(stack) == 0 { + return nil, errors.New("len of block must not be zero here") + } - blocks = append(blocks, stack) - stack = l - lines = map[string]bool{l: true} - continue + blocks = append(blocks, stack) + stack = l + lines = map[string]bool{l: true} + continue + } } stack = stack + "\n" + l @@ -390,17 +449,17 @@ func parseBlocks(input string) ([]string, error) { return blocks, nil } -func testFormatCompleteCompare(t *testing.T, n int, arg interface{}, format string, want []string) { +func testFormatCompleteCompare(t *testing.T, n int, arg interface{}, format string, want []string, detectStackBoundaries bool) { gotStr := fmt.Sprintf(format, arg) - got, err := parseBlocks(gotStr) + got, err := parseBlocks(gotStr, detectStackBoundaries) if err != nil { t.Fatal(err) } if len(got) != len(want) { - t.Fatalf("test %d: fmt.Sprintf(%s, err) -> wrong number of blocks: got(%d) want(%d)\n got: %q\nwant: %q\ngotStr: %q", - n+1, format, len(got), len(want), got, want, gotStr) + t.Fatalf("test %d: fmt.Sprintf(%s, err) -> wrong number of blocks: got(%d) want(%d)\n got: %s\nwant: %s\ngotStr: %q", + n+1, format, len(got), len(want), prettyBlocks(got), prettyBlocks(want), gotStr) } for i := range got { @@ -411,13 +470,62 @@ func testFormatCompleteCompare(t *testing.T, n int, arg interface{}, format stri t.Fatal(err) } if !match { - t.Errorf("test %d: block %d: fmt.Sprintf(%q, err):\n got: %q\nwant: %q", n+1, i+1, format, got[i], want[i]) + t.Fatalf("test %d: block %d: fmt.Sprintf(%q, err):\ngot:\n%q\nwant:\n%q\nall-got:\n%s\nall-want:\n%s\n", + n+1, i+1, format, got[i], want[i], prettyBlocks(got), prettyBlocks(want)) } } else { // Match as message if got[i] != want[i] { - t.Errorf("test %d: fmt.Sprintf(%s, err) at block %d got != want:\n got: %q\nwant: %q", n+1, format, i+1, got[i], want[i]) + t.Fatalf("test %d: fmt.Sprintf(%s, err) at block %d got != want:\n got: %q\nwant: %q", n+1, format, i+1, got[i], want[i]) } } } } + +type wrapper struct { + wrap func(err error) error + want []string +} + +func prettyBlocks(blocks []string, prefix ...string) string { + var out []string + + for _, b := range blocks { + out = append(out, fmt.Sprintf("%v", b)) + } + + return " " + strings.Join(out, "\n ") +} + +func testGenericRecursive(t *testing.T, beforeErr error, beforeWant []string, list []wrapper, maxDepth int) { + if len(beforeWant) == 0 { + panic("beforeWant must not be empty") + } + for _, w := range list { + if len(w.want) == 0 { + panic("want must not be empty") + } + + err := w.wrap(beforeErr) + + // Copy required cause append(beforeWant, ..) modified beforeWant subtly. + beforeCopy := make([]string, len(beforeWant)) + copy(beforeCopy, beforeWant) + + beforeWant := beforeCopy + last := len(beforeWant) - 1 + var want []string + + // Merge two stacks behind each other. + if strings.ContainsAny(beforeWant[last], "\n") && strings.ContainsAny(w.want[0], "\n") { + want = append(beforeWant[:last], append([]string{beforeWant[last] + "((?s).*)" + w.want[0]}, w.want[1:]...)...) + } else { + want = append(beforeWant, w.want...) + } + + testFormatCompleteCompare(t, maxDepth, err, "%+v", want, false) + if maxDepth > 0 { + testGenericRecursive(t, err, want, list, maxDepth-1) + } + } +} From 04b553a77a7e7f8b2b90f4e777f6b51208d08f9a Mon Sep 17 00:00:00 2001 From: fabstu Date: Sat, 6 Aug 2016 19:11:28 +0200 Subject: [PATCH 4/4] tests: fixed tests on 1.4. --- format_test.go | 6 +++--- stack_test.go | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/format_test.go b/format_test.go index cc645c7a..50e7fb60 100644 --- a/format_test.go +++ b/format_test.go @@ -328,21 +328,21 @@ func TestFormatGeneric(t *testing.T) { }, { func(err error) error { return WithStack(err) }, []string{ - "github.com/pkg/errors.TestFormatGeneric.func2\n\t" + + "github.com/pkg/errors.(func·002|TestFormatGeneric.func2)\n\t" + ".+/github.com/pkg/errors/format_test.go:329", }, }, { func(err error) error { return Wrap(err, "wrap-error") }, []string{ "wrap-error", - "github.com/pkg/errors.TestFormatGeneric.func3\n\t" + + "github.com/pkg/errors.(func·003|TestFormatGeneric.func3)\n\t" + ".+/github.com/pkg/errors/format_test.go:335", }, }, { func(err error) error { return Wrapf(err, "wrapf-error%d", 1) }, []string{ "wrapf-error1", - "github.com/pkg/errors.TestFormatGeneric.func4\n\t" + + "github.com/pkg/errors.(func·004|TestFormatGeneric.func4)\n\t" + ".+/github.com/pkg/errors/format_test.go:342", }, }, diff --git a/stack_test.go b/stack_test.go index ca46e866..5c775d66 100644 --- a/stack_test.go +++ b/stack_test.go @@ -188,7 +188,7 @@ func TestStackTrace(t *testing.T) { }, }, { func() error { return New("ooh") }(), []string{ - `github.com/pkg/errors.(func·005|TestStackTrace.func1)` + + `github.com/pkg/errors.(func·009|TestStackTrace.func1)` + "\n\t.+/github.com/pkg/errors/stack_test.go:190", // this is the stack of New "github.com/pkg/errors.TestStackTrace\n" + "\t.+/github.com/pkg/errors/stack_test.go:190", // this is the stack of New's caller @@ -199,9 +199,9 @@ func TestStackTrace(t *testing.T) { return Errorf("hello %s", fmt.Sprintf("world")) }() }()), []string{ - `github.com/pkg/errors.(func·006|TestStackTrace.func2.1)` + + `github.com/pkg/errors.(func·010|TestStackTrace.func2.1)` + "\n\t.+/github.com/pkg/errors/stack_test.go:199", // this is the stack of Errorf - `github.com/pkg/errors.(func·007|TestStackTrace.func2)` + + `github.com/pkg/errors.(func·011|TestStackTrace.func2)` + "\n\t.+/github.com/pkg/errors/stack_test.go:200", // this is the stack of Errorf's caller "github.com/pkg/errors.TestStackTrace\n" + "\t.+/github.com/pkg/errors/stack_test.go:201", // this is the stack of Errorf's caller's caller