errors: Import changes and refactorings from pkg/errors

Benchmark ran with Go 1.9

name                          old time/op    new time/op    delta
AssertBehaviourEmptyStruct-4    23.6ns ± 1%    23.1ns ± 1%   -2.21%        (p=0.000 n=10+10)
AssertBehaviourConstant-4       23.3ns ± 2%    23.2ns ± 1%     ~            (p=0.719 n=10+8)
AssertBehaviourPointer-4        9.23ns ± 1%    8.42ns ± 1%   -8.80%         (p=0.000 n=9+10)
AssertBehaviourNoMatch-4        62.6ns ± 1%    92.6ns ± 1%  +48.00%        (p=0.000 n=10+10)
MultiErr-4                       936ns ± 2%     942ns ± 2%     ~           (p=0.305 n=10+10)
MultiErrPointer-4                724ns ± 1%     728ns ± 2%     ~            (p=0.267 n=9+10)
MultiErrConstant-4               758ns ± 3%     749ns ± 2%     ~             (p=0.108 n=9+9)

name                          old alloc/op   new alloc/op   delta
AssertBehaviourEmptyStruct-4    0.00B ±NaN%    0.00B ±NaN%     ~     (all samples are equal)
AssertBehaviourConstant-4       0.00B ±NaN%    0.00B ±NaN%     ~     (all samples are equal)
AssertBehaviourPointer-4        0.00B ±NaN%    0.00B ±NaN%     ~     (all samples are equal)
AssertBehaviourNoMatch-4        0.00B ±NaN%    0.00B ±NaN%     ~     (all samples are equal)
MultiErr-4                        140B ± 0%      140B ± 0%     ~     (all samples are equal)
MultiErrPointer-4                 224B ± 0%      224B ± 0%     ~     (all samples are equal)
MultiErrConstant-4                224B ± 0%      224B ± 0%     ~     (all samples are equal)

name                          old allocs/op  new allocs/op  delta
AssertBehaviourEmptyStruct-4     0.00 ±NaN%     0.00 ±NaN%     ~     (all samples are equal)
AssertBehaviourConstant-4        0.00 ±NaN%     0.00 ±NaN%     ~     (all samples are equal)
AssertBehaviourPointer-4         0.00 ±NaN%     0.00 ±NaN%     ~     (all samples are equal)
AssertBehaviourNoMatch-4         0.00 ±NaN%     0.00 ±NaN%     ~     (all samples are equal)
MultiErr-4                        5.00 ± 0%      5.00 ± 0%     ~     (all samples are equal)
MultiErrPointer-4                 4.00 ± 0%      4.00 ± 0%     ~     (all samples are equal)
MultiErrConstant-4                4.00 ± 0%      4.00 ± 0%     ~     (all samples are equal)

Author: SchumacherFM

behaviour.go

@@ -20,27 +20,33 @@ import "fmt"
 // if an error has a specific behaviour attached.
 type BehaviourFunc func(error) bool
 
-func errWrapf(err error, format string, args ...interface{}) wrapper {
-	ret := wrapper{
-		cause: cause{
+func fmtNoSprintf(format string, _ ...interface{}) string {
+	return format
+}
+
+func errWrapf(err error, format string, args ...interface{}) *withStack {
+	sprintf := fmtNoSprintf
+	if len(args) > 0 {
+		sprintf = fmt.Sprintf
+	}
+	return &withStack{
+		error: &withMessage{
 			cause: err,
-			msg:   format,
+			msg:   sprintf(format, args...),
 		},
 		stack: callers(),
 	}
-	if len(args) > 0 {
-		ret.cause.msg = fmt.Sprintf(format, args...)
-	}
-	return ret
 }
 
-func errNewf(format string, args ...interface{}) (ret _error) {
-	ret.msg = format
-	ret.stack = callers()
+func errNewf(format string, args ...interface{}) *fundamental {
+	sprintf := fmtNoSprintf
 	if len(args) > 0 {
-		ret.msg = fmt.Sprintf(format, args...)
+		sprintf = fmt.Sprintf
+	}
+	return &fundamental{
+		msg:   sprintf(format, args...),
+		stack: callers(),
 	}
-	return
 }
 
 // HasBehaviour checks if err contains at least one of the provided behaviour

behaviour_error.go

@@ -46,19 +46,19 @@ func TestCausedBehaviour(t *testing.T) {
 }
 
 func TestError_Error(t *testing.T) {
-	t.Parallel()
+
 	const e1 Error = "e1"
 	assert.EqualError(t, e1, "e1")
 }
 
 func TestWrapf2(t *testing.T) {
-	t.Parallel()
+
 	var e = Wrapf(nil, "Error %d")
 	assert.Nil(t, e)
 }
 
 func TestErrorContainsAny(t *testing.T) {
-	t.Parallel()
+
 	tests := []struct {
 		me   error
 		vf   []BehaviourFunc
@@ -84,18 +84,18 @@ func TestErrorContainsAny(t *testing.T) {
 }
 
 func TestErrWrapf(t *testing.T) {
-	t.Parallel()
+
 	const e Error = "Error1"
-	if haveEB, want := errWrapf(e, "Hello World %#v"), "Hello World %#v"; haveEB.msg != want {
-		t.Errorf("have %q want %q", haveEB.msg, want)
+	if haveEB, want := errWrapf(e, "Hello World %#v"), "Hello World %#v"; haveEB.error.(*withMessage).msg != want {
+		t.Errorf("have %q want %q", haveEB.error.(*withMessage).msg, want)
 	}
-	if haveEB, want := errWrapf(e, "Hello World %d", 123), "Hello World 123"; haveEB.msg != want {
-		t.Errorf("have %q want %q", haveEB.msg, want)
+	if haveEB, want := errWrapf(e, "Hello World %d", 123), "Hello World 123"; haveEB.error.(*withMessage).msg != want {
+		t.Errorf("have %q want %q", haveEB.error.(*withMessage).msg, want)
 	}
 }
 
 func TestErrNewf(t *testing.T) {
-	t.Parallel()
+
 	if have, want := errNewf("Hello World %d", 633), "Hello World 633"; have.msg != want {
 		t.Errorf("have %q want %q", have.msg, want)
 	}

behaviour_error_test.go

@@ -174,8 +174,8 @@ func isSeparator(r rune) bool {
 
 const behaviourTemplate = `
 type (
-	{{.LcName}}  struct{ wrapper }
-	{{.LcName}}f struct{ _error }
+	{{.LcName}}  struct{ *withStack }
+	{{.LcName}}f struct{ *fundamental }
 )
 
 // New{{.TcName}} returns an error which wraps err that satisfies
@@ -184,22 +184,22 @@ func New{{.TcName}}(err error, msg string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
-	return &{{.LcName}}{errWrapf(err, msg, args...)}
+	return {{.LcName}}{errWrapf(err, msg, args...)}
 }
 
 // New{{.TcName}}f returns a formatted error that satisfies Is{{.TcName}}().
 func New{{.TcName}}f(format string, args ...interface{}) error {
-	return &{{.LcName}}f{errNewf(format, args...)}
+	return {{.LcName}}f{errNewf(format, args...)}
 }
 
 func is{{.TcName}}(err error) (ok bool) {
 	type iFace interface {
 		{{.TcName}}() bool
 	}
 	switch et := err.(type) {
-	case *{{.LcName}}:
+	case {{.LcName}}:
 		ok = true
-	case *{{.LcName}}f:
+	case {{.LcName}}f:
 		ok = true
 	case iFace:
 		ok = et.{{.TcName}}()
@@ -222,9 +222,7 @@ func (nf testBehave) {{.TcName}}() bool {
 	return nf.ret
 }
 
-func Test{{.TcName}}(t *testing.T) {
-	t.Parallel()
-
+func TestBehaviour{{.TcName}}(t *testing.T) {
 	tests := []struct {
 		err  error
 		is   BehaviourFunc