+++ /dev/null
-// 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 xerrors_test
-
-import (
- "fmt"
- "os"
- "testing"
-
- "golang.org/x/xerrors"
-)
-
-func TestIs(t *testing.T) {
- err1 := xerrors.New("1")
- erra := xerrors.Errorf("wrap 2: %w", err1)
- errb := xerrors.Errorf("wrap 3: %w", erra)
- erro := xerrors.Opaque(err1)
- errco := xerrors.Errorf("opaque: %w", erro)
- err3 := xerrors.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},
- {nil, err1, false},
- {err1, nil, false},
- {err1, err1, true},
- {erra, err1, true},
- {errb, err1, true},
- {errco, erro, true},
- {errco, err1, false},
- {erro, erro, true},
- {err1, err3, false},
- {erra, err3, false},
- {errb, err3, false},
- {poser, err1, true},
- {poser, err3, true},
- {poser, erra, false},
- {poser, errb, false},
- {poser, erro, false},
- {poser, errco, false},
- {errorUncomparable{}, errorUncomparable{}, true},
- {errorUncomparable{}, &errorUncomparable{}, false},
- {&errorUncomparable{}, errorUncomparable{}, true},
- {&errorUncomparable{}, &errorUncomparable{}, false},
- {errorUncomparable{}, err1, false},
- {&errorUncomparable{}, err1, false},
- }
- for _, tc := range testCases {
- t.Run("", func(t *testing.T) {
- if got := xerrors.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
-}
-
-func (p *poser) Error() string { return p.msg }
-func (p *poser) Is(err error) bool { return p.f(err) }
-func (p *poser) As(err interface{}) bool {
- switch x := err.(type) {
- case **poser:
- *x = p
- case *errorT:
- *x = errorT{}
- case **os.PathError:
- *x = &os.PathError{}
- default:
- return false
- }
- return true
-}
-
-func TestAs(t *testing.T) {
- var errT errorT
- var errP *os.PathError
- var timeout interface{ Timeout() bool }
- var p *poser
- _, errF := os.Open("non-existing")
-
- testCases := []struct {
- err error
- target interface{}
- match bool
- }{{
- nil,
- &errP,
- false,
- }, {
- xerrors.Errorf("pittied the fool: %w", errorT{}),
- &errT,
- true,
- }, {
- errF,
- &errP,
- true,
- }, {
- xerrors.Opaque(errT),
- &errT,
- false,
- }, {
- errorT{},
- &errP,
- false,
- }, {
- errWrap{nil},
- &errT,
- false,
- }, {
- &poser{"error", nil},
- &errT,
- true,
- }, {
- &poser{"path", nil},
- &errP,
- true,
- }, {
- &poser{"oh no", nil},
- &p,
- true,
- }, {
- xerrors.New("err"),
- &timeout,
- false,
- }, {
- errF,
- &timeout,
- true,
- }, {
- xerrors.Errorf("path error: %w", errF),
- &timeout,
- true,
- }}
- for i, tc := range testCases {
- name := fmt.Sprintf("%d:As(Errorf(..., %v), %v)", i, tc.err, tc.target)
- t.Run(name, func(t *testing.T) {
- match := xerrors.As(tc.err, tc.target)
- if match != tc.match {
- t.Fatalf("xerrors.As(%T, %T): got %v; want %v", tc.err, tc.target, match, tc.match)
- }
- if !match {
- return
- }
- if tc.target == nil {
- t.Fatalf("non-nil result after match")
- }
- })
- }
-}
-
-func TestAsValidation(t *testing.T) {
- var s string
- testCases := []interface{}{
- nil,
- (*int)(nil),
- "error",
- &s,
- }
- err := xerrors.New("error")
- for _, tc := range testCases {
- t.Run(fmt.Sprintf("%T(%v)", tc, tc), func(t *testing.T) {
- defer func() {
- recover()
- }()
- if xerrors.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 := xerrors.New("1")
- erra := xerrors.Errorf("wrap 2: %w", err1)
- erro := xerrors.Opaque(err1)
-
- testCases := []struct {
- err error
- want error
- }{
- {nil, nil},
- {errWrap{nil}, nil},
- {err1, nil},
- {erra, err1},
- {xerrors.Errorf("wrap 3: %w", erra), erra},
-
- {erro, nil},
- {xerrors.Errorf("opaque: %w", erro), erro},
- }
- for _, tc := range testCases {
- if got := xerrors.Unwrap(tc.err); got != tc.want {
- t.Errorf("Unwrap(%v) = %v, want %v", tc.err, got, tc.want)
- }
- }
-}
-
-func TestOpaque(t *testing.T) {
- got := fmt.Sprintf("%v", xerrors.Errorf("foo: %v", xerrors.Opaque(errorT{})))
- want := "foo: errorT"
- if got != want {
- t.Errorf("error without Format: got %v; want %v", got, want)
- }
-
- got = fmt.Sprintf("%v", xerrors.Errorf("foo: %v", xerrors.Opaque(errorD{})))
- want = "foo: errorD"
- if got != want {
- t.Errorf("error with Format: got %v; want %v", got, want)
- }
-}
-
-type errorT struct{}
-
-func (errorT) Error() string { return "errorT" }
-
-type errorD struct{}
-
-func (errorD) Error() string { return "errorD" }
-
-func (errorD) FormatError(p xerrors.Printer) error {
- p.Print("errorD")
- p.Detail()
- p.Print("detail")
- return nil
-}
-
-type errWrap struct{ error }
-
-func (errWrap) Error() string { return "wrapped" }
-
-func (errWrap) Unwrap() error { return nil }
-
-type errorUncomparable struct {
- f []string
-}
-
-func (errorUncomparable) Error() string {
- return "uncomparable error"
-}
-
-func (errorUncomparable) Is(target error) bool {
- _, ok := target.(errorUncomparable)
- return ok
-}
projects / dotfiles / .git / blobdiff