Merge ad75acf into 382faa4

.travis.yml

@@ -1,6 +1,6 @@
 language: go
 go:
-  - 1.12
+  - 1.13
   - 1.x
   - tip
 before_install:

go.mod

@@ -1,3 +1,3 @@
 module github.com/cenkalti/backoff/v4
 
-go 1.12
+go 1.13

retry.go

@@ -1,6 +1,9 @@
 package backoff
 
-import "time"
+import (
+	"errors"
+	"time"
+)
 
 // An Operation is executing by Retry() or RetryNotify().
 // The operation will be retried using a backoff policy if it returns an error.
@@ -53,7 +56,8 @@ func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer
 			return nil
 		}
 
-		if permanent, ok := err.(*PermanentError); ok {
+		var permanent *PermanentError
+		if errors.As(err, &permanent) {
 			return permanent.Err
 		}
 
@@ -88,6 +92,11 @@ func (e *PermanentError) Unwrap() error {
 	return e.Err
 }
 
+func (e *PermanentError) Is(target error) bool {
+	_, ok := target.(*PermanentError)
+	return ok
+}
+
 // Permanent wraps the given err in a *PermanentError.
 func Permanent(err error) error {
 	if err == nil {

retry_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"log"
 	"testing"
 	"time"
@@ -89,41 +90,94 @@ func TestRetryContext(t *testing.T) {
 }
 
 func TestRetryPermanent(t *testing.T) {
-	const permanentOn = 3
-	var i = 0
-
-	// This function fails permanently after permanentOn tries
-	f := func() error {
-		i++
-		log.Printf("function is called %d. time\n", i)
-
-		if i == permanentOn {
-			log.Println("permanent error")
-			return Permanent(errors.New("permanent error"))
+	ensureRetries := func(test string, shouldRetry bool, f func() error) {
+		numRetries := -1
+		maxRetries := 1
+
+		_ = RetryNotifyWithTimer(
+			func() error {
+				numRetries++
+				if numRetries >= maxRetries {
+					return Permanent(errors.New("forced"))
+				}
+				return f()
+			},
+			NewExponentialBackOff(),
+			nil,
+			&testTimer{},
+		)
+
+		if shouldRetry && numRetries == 0 {
+			t.Errorf("Test: '%s', backoff should have retried", test)
 		}
 
-		log.Println("error")
-		return errors.New("error")
+		if !shouldRetry && numRetries > 0 {
+			t.Errorf("Test: '%s', backoff should not have retried", test)
+		}
 	}
 
-	err := RetryNotifyWithTimer(f, NewExponentialBackOff(), nil, &testTimer{})
-	if err == nil || err.Error() != "permanent error" {
-		t.Errorf("unexpected error: %s", err)
-	}
-	if i != permanentOn {
-		t.Errorf("invalid number of retries: %d", i)
+	for _, testCase := range []struct {
+		name        string
+		f           func() error
+		shouldRetry bool
+	}{
+		{
+			"nil test",
+			func() error {
+				return nil
+			},
+			false,
+		},
+		{
+			"io.EOF",
+			func() error {
+				return io.EOF
+			},
+			true,
+		},
+		{
+			"Permanent(io.EOF)",
+			func() error {
+				return Permanent(io.EOF)
+			},
+			false,
+		},
+		{
+			"Wrapped: Permanent(io.EOF)",
+			func() error {
+				return fmt.Errorf("Wrapped error: %w", Permanent(io.EOF))
+			},
+			false,
+		},
+	} {
+		ensureRetries(testCase.name, testCase.shouldRetry, testCase.f)
 	}
 }
 
 func TestPermanent(t *testing.T) {
 	want := errors.New("foo")
+	other := errors.New("bar")
 	var err error = Permanent(want)
 
 	got := errors.Unwrap(err)
 	if got != want {
 		t.Errorf("got %v, want %v", got, want)
 	}
 
+	if is := errors.Is(err, want); !is {
+		t.Errorf("err: %v is not %v", err, want)
+	}
+
+	if is := errors.Is(err, other); is {
+		t.Errorf("err: %v is %v", err, other)
+	}
+
+	wrapped := fmt.Errorf("wrapped: %w", err)
+	var permanent *PermanentError
+	if !errors.As(wrapped, &permanent) {
+		t.Errorf("errors.As(%v, %v)", wrapped, permanent)
+	}
+
 	err = Permanent(nil)
 	if err != nil {
 		t.Errorf("got %v, want nil", err)