.travis.yml

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

README.md

@@ -9,10 +9,10 @@ The retries exponentially increase and stop increasing when a certain threshold
 
 ## Usage
 
-Import path is `github.com/cenkalti/backoff/v3`. Please note the version part at the end.
+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.v3 to view the documentation.
+so you can use https://godoc.org/gopkg.in/cenkalti/backoff.v4 to view the documentation.
 
 ## Contributing
 

exponential.go

@@ -56,9 +56,10 @@ type ExponentialBackOff struct {
 	RandomizationFactor float64
 	Multiplier          float64
 	MaxInterval         time.Duration
-	// After MaxElapsedTime the ExponentialBackOff stops.
+	// After MaxElapsedTime the ExponentialBackOff returns Stop.
 	// It never stops if MaxElapsedTime == 0.
 	MaxElapsedTime time.Duration
+	Stop           time.Duration
 	Clock          Clock
 
 	currentInterval time.Duration
@@ -87,6 +88,7 @@ func NewExponentialBackOff() *ExponentialBackOff {
 		Multiplier:          DefaultMultiplier,
 		MaxInterval:         DefaultMaxInterval,
 		MaxElapsedTime:      DefaultMaxElapsedTime,
+		Stop:                Stop,
 		Clock:               SystemClock,
 	}
 	b.Reset()
@@ -114,7 +116,7 @@ func (b *ExponentialBackOff) Reset() {
 func (b *ExponentialBackOff) NextBackOff() time.Duration {
 	// Make sure we have not gone over the maximum elapsed time.
 	if b.MaxElapsedTime != 0 && b.GetElapsedTime() > b.MaxElapsedTime {
-		return Stop
+		return b.Stop
 	}
 	defer b.incrementCurrentInterval()
 	return getRandomValueFromInterval(b.RandomizationFactor, rand.Float64(), b.currentInterval)

exponential_test.go

@@ -83,6 +83,17 @@ func TestMaxElapsedTime(t *testing.T) {
 	assertEquals(t, Stop, exp.NextBackOff())
 }
 
+func TestCustomStop(t *testing.T) {
+	var exp = NewExponentialBackOff()
+	customStop := time.Minute
+	exp.Stop = customStop
+	exp.Clock = &TestClock{start: time.Time{}.Add(10000 * time.Second)}
+	// Change the currentElapsedTime to be 0 ensuring that the elapsed time will be greater
+	// than the max elapsed time.
+	exp.startTime = time.Time{}
+	assertEquals(t, customStop, exp.NextBackOff())
+}
+
 func TestBackOffOverflow(t *testing.T) {
 	var (
 		testInitialInterval time.Duration = math.MaxInt64 / 2

go.mod

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

retry_test.go

@@ -18,7 +18,9 @@ func (t *testTimer) Start(duration time.Duration) {
 }
 
 func (t *testTimer) Stop() {
-	t.timer.Stop()
+	if t.timer != nil {
+		t.timer.Stop()
+	}
 }
 
 func (t *testTimer) C() <-chan time.Time {

timer.go

@@ -29,5 +29,7 @@ func (t *defaultTimer) Start(duration time.Duration) {
 
 // Stop is called when the timer is not used anymore and resources may be freed.
 func (t *defaultTimer) Stop() {
-	t.timer.Stop()
+	if t.timer != nil {
+		t.timer.Stop()
+	}
 }

tries.go

@@ -20,6 +20,9 @@ type backOffTries struct {
 }
 
 func (b *backOffTries) NextBackOff() time.Duration {
+	if b.maxTries == 0 {
+		return Stop
+	}
 	if b.maxTries > 0 {
 		if b.maxTries <= b.numTries {
 			return Stop

tries_test.go

@@ -1,6 +1,7 @@
 package backoff
 
 import (
+	"errors"
 	"math/rand"
 	"testing"
 	"time"
@@ -42,13 +43,21 @@ func TestMaxTriesHappy(t *testing.T) {
 	}
 }
 
+// https://github.com/cenkalti/backoff/issues/80
 func TestMaxTriesZero(t *testing.T) {
-	// It might not make sense, but its okay to send a zero
-	bo := WithMaxRetries(&ZeroBackOff{}, uint64(0))
-	for ix := 0; ix < 11; ix++ {
-		d := bo.NextBackOff()
-		if d == Stop {
-			t.Errorf("returned Stop on try %d", ix)
-		}
+	var called int
+
+	b := WithMaxRetries(&ZeroBackOff{}, 0)
+
+	err := Retry(func() error {
+		called++
+		return errors.New("err")
+	}, b)
+
+	if err == nil {
+		t.Errorf("error expected, nil founc")
+	}
+	if called != 1 {
+		t.Errorf("operation is called %d times", called)
 	}
 }