.gitignore

@@ -20,3 +20,6 @@ _cgo_export.*
 _testmain.go
 
 *.exe
+
+# IDEs
+.idea/

.travis.yml

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

README.md

@@ -11,16 +11,15 @@ The retries exponentially increase and stop increasing when a certain threshold
 
 Import path is `github.com/cenkalti/backoff/v4`. Please note the version part at the end.
 
-godoc.org does not support modules yet,
-so you can use https://godoc.org/gopkg.in/cenkalti/backoff.v4 to view the documentation.
+Use https://pkg.go.dev/github.com/cenkalti/backoff/v4 to view the documentation.
 
 ## Contributing
 
 * I would like to keep this library as small as possible.
 * Please don't send a PR without opening an issue and discussing it first.
 * If proposed change is not a common use case, I will probably not accept it.
 
-[godoc]: https://godoc.org/github.com/cenkalti/backoff
+[godoc]: https://pkg.go.dev/github.com/cenkalti/backoff/v4
 [godoc image]: https://godoc.org/github.com/cenkalti/backoff?status.png
 [travis]: https://travis-ci.org/cenkalti/backoff
 [travis image]: https://travis-ci.org/cenkalti/backoff.png?branch=master
@@ -30,4 +29,4 @@ so you can use https://godoc.org/gopkg.in/cenkalti/backoff.v4 to view the docume
 [google-http-java-client]: https://github.com/google/google-http-java-client/blob/da1aa993e90285ec18579f1553339b00e19b3ab5/google-http-client/src/main/java/com/google/api/client/util/ExponentialBackOff.java
 [exponential backoff wiki]: http://en.wikipedia.org/wiki/Exponential_backoff
 
-[advanced example]: https://godoc.org/github.com/cenkalti/backoff#example_
+[advanced example]: https://pkg.go.dev/github.com/cenkalti/backoff/v4?tab=doc#pkg-examples

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,8 +92,16 @@ 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) *PermanentError {
+func Permanent(err error) error {
+	if err == nil {
+		return nil
+	}
 	return &PermanentError{
 		Err: err,
 	}

retry_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"log"
 	"testing"
 	"time"
@@ -88,29 +89,97 @@ func TestRetryContext(t *testing.T) {
 	}
 }
 
-func TestRetryPermenent(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)
+func TestRetryPermanent(t *testing.T) {
+	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)
+		}
 
-		if i == permanentOn {
-			log.Println("permanent error")
-			return Permanent(errors.New("permanent error"))
+		if !shouldRetry && numRetries > 0 {
+			t.Errorf("Test: '%s', backoff should not have retried", test)
 		}
+	}
 
-		log.Println("error")
-		return errors.New("error")
+	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)
 	}
+}
 
-	err := RetryNotifyWithTimer(f, NewExponentialBackOff(), nil, &testTimer{})
-	if err == nil || err.Error() != "permanent error" {
-		t.Errorf("unexpected error: %s", err)
+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 i != permanentOn {
-		t.Errorf("invalid number of retries: %d", i)
+
+	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)
 	}
 }