diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-16 19:23:18 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-16 19:23:18 +0000 |
commit | 43a123c1ae6613b3efeed291fa552ecd909d3acf (patch) | |
tree | fd92518b7024bc74031f78a1cf9e454b65e73665 /src/errors/wrap_test.go | |
parent | Initial commit. (diff) | |
download | golang-1.20-upstream.tar.xz golang-1.20-upstream.zip |
Adding upstream version 1.20.14.upstream/1.20.14upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/errors/wrap_test.go')
-rw-r--r-- | src/errors/wrap_test.go | 327 |
1 files changed, 327 insertions, 0 deletions
diff --git a/src/errors/wrap_test.go b/src/errors/wrap_test.go new file mode 100644 index 0000000..9efbe45 --- /dev/null +++ b/src/errors/wrap_test.go @@ -0,0 +1,327 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package errors_test + +import ( + "errors" + "fmt" + "io/fs" + "os" + "reflect" + "testing" +) + +func TestIs(t *testing.T) { + err1 := errors.New("1") + erra := wrapped{"wrap 2", err1} + errb := wrapped{"wrap 3", erra} + + err3 := errors.New("3") + + poser := &poser{"either 1 or 3", func(err error) bool { + return err == err1 || err == err3 + }} + + testCases := []struct { + err error + target error + match bool + }{ + {nil, nil, true}, + {err1, nil, false}, + {err1, err1, true}, + {erra, err1, true}, + {errb, err1, true}, + {err1, err3, false}, + {erra, err3, false}, + {errb, err3, false}, + {poser, err1, true}, + {poser, err3, true}, + {poser, erra, false}, + {poser, errb, false}, + {errorUncomparable{}, errorUncomparable{}, true}, + {errorUncomparable{}, &errorUncomparable{}, false}, + {&errorUncomparable{}, errorUncomparable{}, true}, + {&errorUncomparable{}, &errorUncomparable{}, false}, + {errorUncomparable{}, err1, false}, + {&errorUncomparable{}, err1, false}, + {multiErr{}, err1, false}, + {multiErr{err1, err3}, err1, true}, + {multiErr{err3, err1}, err1, true}, + {multiErr{err1, err3}, errors.New("x"), false}, + {multiErr{err3, errb}, errb, true}, + {multiErr{err3, errb}, erra, true}, + {multiErr{err3, errb}, err1, true}, + {multiErr{errb, err3}, err1, true}, + {multiErr{poser}, err1, true}, + {multiErr{poser}, err3, true}, + {multiErr{nil}, nil, false}, + } + for _, tc := range testCases { + t.Run("", func(t *testing.T) { + if got := errors.Is(tc.err, tc.target); got != tc.match { + t.Errorf("Is(%v, %v) = %v, want %v", tc.err, tc.target, got, tc.match) + } + }) + } +} + +type poser struct { + msg string + f func(error) bool +} + +var poserPathErr = &fs.PathError{Op: "poser"} + +func (p *poser) Error() string { return p.msg } +func (p *poser) Is(err error) bool { return p.f(err) } +func (p *poser) As(err any) bool { + switch x := err.(type) { + case **poser: + *x = p + case *errorT: + *x = errorT{"poser"} + case **fs.PathError: + *x = poserPathErr + default: + return false + } + return true +} + +func TestAs(t *testing.T) { + var errT errorT + var errP *fs.PathError + var timeout interface{ Timeout() bool } + var p *poser + _, errF := os.Open("non-existing") + poserErr := &poser{"oh no", nil} + + testCases := []struct { + err error + target any + match bool + want any // value of target on match + }{{ + nil, + &errP, + false, + nil, + }, { + wrapped{"pitied the fool", errorT{"T"}}, + &errT, + true, + errorT{"T"}, + }, { + errF, + &errP, + true, + errF, + }, { + errorT{}, + &errP, + false, + nil, + }, { + wrapped{"wrapped", nil}, + &errT, + false, + nil, + }, { + &poser{"error", nil}, + &errT, + true, + errorT{"poser"}, + }, { + &poser{"path", nil}, + &errP, + true, + poserPathErr, + }, { + poserErr, + &p, + true, + poserErr, + }, { + errors.New("err"), + &timeout, + false, + nil, + }, { + errF, + &timeout, + true, + errF, + }, { + wrapped{"path error", errF}, + &timeout, + true, + errF, + }, { + multiErr{}, + &errT, + false, + nil, + }, { + multiErr{errors.New("a"), errorT{"T"}}, + &errT, + true, + errorT{"T"}, + }, { + multiErr{errorT{"T"}, errors.New("a")}, + &errT, + true, + errorT{"T"}, + }, { + multiErr{errorT{"a"}, errorT{"b"}}, + &errT, + true, + errorT{"a"}, + }, { + multiErr{multiErr{errors.New("a"), errorT{"a"}}, errorT{"b"}}, + &errT, + true, + errorT{"a"}, + }, { + multiErr{wrapped{"path error", errF}}, + &timeout, + true, + errF, + }, { + multiErr{nil}, + &errT, + false, + nil, + }} + for i, tc := range testCases { + name := fmt.Sprintf("%d:As(Errorf(..., %v), %v)", i, tc.err, tc.target) + // Clear the target pointer, in case it was set in a previous test. + rtarget := reflect.ValueOf(tc.target) + rtarget.Elem().Set(reflect.Zero(reflect.TypeOf(tc.target).Elem())) + t.Run(name, func(t *testing.T) { + match := errors.As(tc.err, tc.target) + if match != tc.match { + t.Fatalf("match: got %v; want %v", match, tc.match) + } + if !match { + return + } + if got := rtarget.Elem().Interface(); got != tc.want { + t.Fatalf("got %#v, want %#v", got, tc.want) + } + }) + } +} + +func TestAsValidation(t *testing.T) { + var s string + testCases := []any{ + nil, + (*int)(nil), + "error", + &s, + } + err := errors.New("error") + for _, tc := range testCases { + t.Run(fmt.Sprintf("%T(%v)", tc, tc), func(t *testing.T) { + defer func() { + recover() + }() + if errors.As(err, tc) { + t.Errorf("As(err, %T(%v)) = true, want false", tc, tc) + return + } + t.Errorf("As(err, %T(%v)) did not panic", tc, tc) + }) + } +} + +func TestUnwrap(t *testing.T) { + err1 := errors.New("1") + erra := wrapped{"wrap 2", err1} + + testCases := []struct { + err error + want error + }{ + {nil, nil}, + {wrapped{"wrapped", nil}, nil}, + {err1, nil}, + {erra, err1}, + {wrapped{"wrap 3", erra}, erra}, + } + for _, tc := range testCases { + if got := errors.Unwrap(tc.err); got != tc.want { + t.Errorf("Unwrap(%v) = %v, want %v", tc.err, got, tc.want) + } + } +} + +type errorT struct{ s string } + +func (e errorT) Error() string { return fmt.Sprintf("errorT(%s)", e.s) } + +type wrapped struct { + msg string + err error +} + +func (e wrapped) Error() string { return e.msg } +func (e wrapped) Unwrap() error { return e.err } + +type multiErr []error + +func (m multiErr) Error() string { return "multiError" } +func (m multiErr) Unwrap() []error { return []error(m) } + +type errorUncomparable struct { + f []string +} + +func (errorUncomparable) Error() string { + return "uncomparable error" +} + +func (errorUncomparable) Is(target error) bool { + _, ok := target.(errorUncomparable) + return ok +} + +func ExampleIs() { + if _, err := os.Open("non-existing"); err != nil { + if errors.Is(err, fs.ErrNotExist) { + fmt.Println("file does not exist") + } else { + fmt.Println(err) + } + } + + // Output: + // file does not exist +} + +func ExampleAs() { + if _, err := os.Open("non-existing"); err != nil { + var pathError *fs.PathError + if errors.As(err, &pathError) { + fmt.Println("Failed at path:", pathError.Path) + } else { + fmt.Println(err) + } + } + + // Output: + // Failed at path: non-existing +} + +func ExampleUnwrap() { + err1 := errors.New("error1") + err2 := fmt.Errorf("error2: [%w]", err1) + fmt.Println(err2) + fmt.Println(errors.Unwrap(err2)) + // Output + // error2: [error1] + // error1 +} |