dependencies: update to gomega v1.23.0 and ginkgo v2.4.0 and dependencies

Gomega adds support for formatting extensions and StopTrying in matchers.
Ginkgo enhances DeferCleanup.

This also triggered an update of other dependencies.

vendor/github.com/onsi/gomega/internal/assertion.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/onsi/gomega/format"
 	"github.com/onsi/gomega/types"
 )
 
@@ -146,7 +147,12 @@ func vetActuals(actuals []interface{}, skipIndex int) (bool, string) {
 		if actual != nil {
 			zeroValue := reflect.Zero(reflect.TypeOf(actual)).Interface()
 			if !reflect.DeepEqual(zeroValue, actual) {
-				message := fmt.Sprintf("Unexpected non-nil/non-zero argument at index %d:\n\t<%T>: %#v", i, actual, actual)
+				var message string
+				if err, ok := actual.(error); ok {
+					message = fmt.Sprintf("Unexpected error: %s\n%s", err, format.Object(err, 1))
+				} else {
+					message = fmt.Sprintf("Unexpected non-nil/non-zero argument at index %d:\n\t<%T>: %#v", i, actual, actual)
+				}
 				return false, message
 			}
 		}

vendor/github.com/onsi/gomega/internal/async_assertion.go

@@ -2,58 +2,22 @@ package internal
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"reflect"
 	"runtime"
 	"sync"
 	"time"
 
+	"github.com/onsi/gomega/format"
 	"github.com/onsi/gomega/types"
 )
 
-type StopTryingError interface {
-	error
-	Now()
-	wasViaPanic() bool
-}
+var errInterface = reflect.TypeOf((*error)(nil)).Elem()
+var gomegaType = reflect.TypeOf((*types.Gomega)(nil)).Elem()
+var contextType = reflect.TypeOf(new(context.Context)).Elem()
 
-func asStopTryingError(actual interface{}) (StopTryingError, bool) {
-	if actual == nil {
-		return nil, false
-	}
-	if actualErr, ok := actual.(error); ok {
-		var target *stopTryingError
-		if errors.As(actualErr, &target) {
-			return target, true
-		} else {
-			return nil, false
-		}
-	}
-
-	return nil, false
-}
-
-type stopTryingError struct {
-	message  string
-	viaPanic bool
-}
-
-func (s *stopTryingError) Error() string {
-	return s.message
-}
-
-func (s *stopTryingError) Now() {
-	s.viaPanic = true
-	panic(s)
-}
-
-func (s *stopTryingError) wasViaPanic() bool {
-	return s.viaPanic
-}
-
-var StopTrying = func(message string) StopTryingError {
-	return &stopTryingError{message: message}
+type contextWithAttachProgressReporter interface {
+	AttachProgressReporter(func() string) func()
 }
 
 type AsyncAssertionType uint
@@ -164,39 +128,40 @@ func (assertion *AsyncAssertion) buildDescription(optionalDescription ...interfa
 	return fmt.Sprintf(optionalDescription[0].(string), optionalDescription[1:]...) + "\n"
 }
 
-func (assertion *AsyncAssertion) processReturnValues(values []reflect.Value) (interface{}, error, StopTryingError) {
-	var err error
-	var stopTrying StopTryingError
-
+func (assertion *AsyncAssertion) processReturnValues(values []reflect.Value) (interface{}, error) {
 	if len(values) == 0 {
-		return nil, fmt.Errorf("No values were returned by the function passed to Gomega"), stopTrying
+		return nil, fmt.Errorf("No values were returned by the function passed to Gomega")
 	}
+
 	actual := values[0].Interface()
-	if stopTryingErr, ok := asStopTryingError(actual); ok {
-		stopTrying = stopTryingErr
+	if _, ok := AsPollingSignalError(actual); ok {
+		return actual, actual.(error)
 	}
+
+	var err error
 	for i, extraValue := range values[1:] {
 		extra := extraValue.Interface()
 		if extra == nil {
 			continue
 		}
-		if stopTryingErr, ok := asStopTryingError(extra); ok {
-			stopTrying = stopTryingErr
-			continue
+		if _, ok := AsPollingSignalError(extra); ok {
+			return actual, extra.(error)
 		}
-		zero := reflect.Zero(reflect.TypeOf(extra)).Interface()
+		extraType := reflect.TypeOf(extra)
+		zero := reflect.Zero(extraType).Interface()
 		if reflect.DeepEqual(extra, zero) {
 			continue
 		}
+		if i == len(values)-2 && extraType.Implements(errInterface) {
+			err = fmt.Errorf("function returned error: %w", extra.(error))
+		}
 		if err == nil {
-			err = fmt.Errorf("Unexpected non-nil/non-zero argument at index %d:\n\t<%T>: %#v", i+1, extra, extra)
+			err = fmt.Errorf("Unexpected non-nil/non-zero return value at index %d:\n\t<%T>: %#v", i+1, extra, extra)
 		}
 	}
-	return actual, err, stopTrying
-}
 
-var gomegaType = reflect.TypeOf((*types.Gomega)(nil)).Elem()
-var contextType = reflect.TypeOf(new(context.Context)).Elem()
+	return actual, err
+}
 
 func (assertion *AsyncAssertion) invalidFunctionError(t reflect.Type) error {
 	return fmt.Errorf(`The function passed to %s had an invalid signature of %s.  Functions passed to %s must either:
@@ -226,9 +191,9 @@ You can learn more at https://onsi.github.io/gomega/#eventually
 `, assertion.asyncType, t, t.NumIn(), numProvided, have, assertion.asyncType)
 }
 
-func (assertion *AsyncAssertion) buildActualPoller() (func() (interface{}, error, StopTryingError), error) {
+func (assertion *AsyncAssertion) buildActualPoller() (func() (interface{}, error), error) {
 	if !assertion.actualIsFunc {
-		return func() (interface{}, error, StopTryingError) { return assertion.actual, nil, nil }, nil
+		return func() (interface{}, error) { return assertion.actual, nil }, nil
 	}
 	actualValue := reflect.ValueOf(assertion.actual)
 	actualType := reflect.TypeOf(assertion.actual)
@@ -236,23 +201,11 @@ func (assertion *AsyncAssertion) buildActualPoller() (func() (interface{}, error
 
 	if numIn == 0 && numOut == 0 {
 		return nil, assertion.invalidFunctionError(actualType)
-	} else if numIn == 0 {
-		return func() (actual interface{}, err error, stopTrying StopTryingError) {
-			defer func() {
-				if e := recover(); e != nil {
-					if stopTryingErr, ok := asStopTryingError(e); ok {
-						stopTrying = stopTryingErr
-					} else {
-						panic(e)
-					}
-				}
-			}()
-
-			actual, err, stopTrying = assertion.processReturnValues(actualValue.Call([]reflect.Value{}))
-			return
-		}, nil
 	}
-	takesGomega, takesContext := actualType.In(0).Implements(gomegaType), actualType.In(0).Implements(contextType)
+	takesGomega, takesContext := false, false
+	if numIn > 0 {
+		takesGomega, takesContext = actualType.In(0).Implements(gomegaType), actualType.In(0).Implements(contextType)
+	}
 	if takesGomega && numIn > 1 && actualType.In(1).Implements(contextType) {
 		takesContext = true
 	}
@@ -292,21 +245,22 @@ func (assertion *AsyncAssertion) buildActualPoller() (func() (interface{}, error
 		return nil, assertion.argumentMismatchError(actualType, len(inValues))
 	}
 
-	return func() (actual interface{}, err error, stopTrying StopTryingError) {
+	return func() (actual interface{}, err error) {
 		var values []reflect.Value
 		assertionFailure = nil
 		defer func() {
-			if numOut == 0 {
+			if numOut == 0 && takesGomega {
 				actual = assertionFailure
 			} else {
-				actual, err, stopTrying = assertion.processReturnValues(values)
-				if assertionFailure != nil {
+				actual, err = assertion.processReturnValues(values)
+				_, isAsyncError := AsPollingSignalError(err)
+				if assertionFailure != nil && !isAsyncError {
 					err = assertionFailure
 				}
 			}
 			if e := recover(); e != nil {
-				if stopTryingErr, ok := asStopTryingError(e); ok {
-					stopTrying = stopTryingErr
+				if _, isAsyncError := AsPollingSignalError(e); isAsyncError {
+					err = e.(error)
 				} else if assertionFailure == nil {
 					panic(e)
 				}
@@ -317,13 +271,6 @@ func (assertion *AsyncAssertion) buildActualPoller() (func() (interface{}, error
 	}, nil
 }
 
-func (assertion *AsyncAssertion) matcherSaysStopTrying(matcher types.GomegaMatcher, value interface{}) StopTryingError {
-	if assertion.actualIsFunc || types.MatchMayChangeInTheFuture(matcher, value) {
-		return nil
-	}
-	return StopTrying("No future change is possible.  Bailing out early")
-}
-
 func (assertion *AsyncAssertion) afterTimeout() <-chan time.Time {
 	if assertion.timeoutInterval >= 0 {
 		return time.After(assertion.timeoutInterval)
@@ -351,8 +298,27 @@ func (assertion *AsyncAssertion) afterPolling() <-chan time.Time {
 	}
 }
 
-type contextWithAttachProgressReporter interface {
-	AttachProgressReporter(func() string) func()
+func (assertion *AsyncAssertion) matcherSaysStopTrying(matcher types.GomegaMatcher, value interface{}) bool {
+	if assertion.actualIsFunc || types.MatchMayChangeInTheFuture(matcher, value) {
+		return false
+	}
+	return true
+}
+
+func (assertion *AsyncAssertion) pollMatcher(matcher types.GomegaMatcher, value interface{}) (matches bool, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			if _, isAsyncError := AsPollingSignalError(e); isAsyncError {
+				err = e.(error)
+			} else {
+				panic(e)
+			}
+		}
+	}()
+
+	matches, err = matcher.Match(value)
+
+	return
 }
 
 func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch bool, optionalDescription ...interface{}) bool {
@@ -362,6 +328,7 @@ func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch
 
 	var matches bool
 	var err error
+	var oracleMatcherSaysStop bool
 
 	assertion.g.THelper()
 
@@ -371,22 +338,27 @@ func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch
 		return false
 	}
 
-	value, err, stopTrying := pollActual()
+	value, err := pollActual()
 	if err == nil {
-		if stopTrying == nil {
-			stopTrying = assertion.matcherSaysStopTrying(matcher, value)
-		}
-		matches, err = matcher.Match(value)
+		oracleMatcherSaysStop = assertion.matcherSaysStopTrying(matcher, value)
+		matches, err = assertion.pollMatcher(matcher, value)
 	}
 
 	messageGenerator := func() string {
 		// can be called out of band by Ginkgo if the user requests a progress report
 		lock.Lock()
 		defer lock.Unlock()
-		errMsg := ""
 		message := ""
 		if err != nil {
-			errMsg = "Error: " + err.Error()
+			if pollingSignalErr, ok := AsPollingSignalError(err); ok && pollingSignalErr.IsStopTrying() {
+				message = err.Error()
+				for _, attachment := range pollingSignalErr.Attachments {
+					message += fmt.Sprintf("\n%s:\n", attachment.Description)
+					message += format.Object(attachment.Object, 1)
+				}
+			} else {
+				message = "Error: " + err.Error() + "\n" + format.Object(err, 1)
+			}
 		} else {
 			if desiredMatch {
 				message = matcher.FailureMessage(value)
@@ -395,7 +367,7 @@ func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch
 			}
 		}
 		description := assertion.buildDescription(optionalDescription...)
-		return fmt.Sprintf("%s%s%s", description, message, errMsg)
+		return fmt.Sprintf("%s%s", description, message)
 	}
 
 	fail := func(preamble string) {
@@ -412,84 +384,72 @@ func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch
 		}
 	}
 
-	if assertion.asyncType == AsyncAssertionTypeEventually {
-		for {
-			if err == nil && matches == desiredMatch {
-				return true
-			}
+	for {
+		var nextPoll <-chan time.Time = nil
+		var isTryAgainAfterError = false
 
-			if stopTrying != nil {
-				fail(stopTrying.Error() + " -")
+		if pollingSignalErr, ok := AsPollingSignalError(err); ok {
+			if pollingSignalErr.IsStopTrying() {
+				fail("Told to stop trying")
 				return false
 			}
-
-			select {
-			case <-assertion.afterPolling():
-				v, e, st := pollActual()
-				if st != nil && st.wasViaPanic() {
-					// we were told to stop trying via panic - which means we dont' have reasonable new values
-					// we should simply use the old values and exit now
-					fail(st.Error() + " -")
-					return false
-				}
-				lock.Lock()
-				value, err, stopTrying = v, e, st
-				lock.Unlock()
-				if err == nil {
-					if stopTrying == nil {
-						stopTrying = assertion.matcherSaysStopTrying(matcher, value)
-					}
-					matches, e = matcher.Match(value)
-					lock.Lock()
-					err = e
-					lock.Unlock()
-				}
-			case <-contextDone:
-				fail("Context was cancelled")
-				return false
-			case <-timeout:
-				fail("Timed out")
-				return false
+			if pollingSignalErr.IsTryAgainAfter() {
+				nextPoll = time.After(pollingSignalErr.TryAgainDuration())
+				isTryAgainAfterError = true
 			}
 		}
-	} else if assertion.asyncType == AsyncAssertionTypeConsistently {
-		for {
-			if !(err == nil && matches == desiredMatch) {
+
+		if err == nil && matches == desiredMatch {
+			if assertion.asyncType == AsyncAssertionTypeEventually {
+				return true
+			}
+		} else if !isTryAgainAfterError {
+			if assertion.asyncType == AsyncAssertionTypeConsistently {
 				fail("Failed")
 				return false
 			}
+		}
 
-			if stopTrying != nil {
+		if oracleMatcherSaysStop {
+			if assertion.asyncType == AsyncAssertionTypeEventually {
+				fail("No future change is possible.  Bailing out early")
+				return false
+			} else {
 				return true
 			}
+		}
 
-			select {
-			case <-assertion.afterPolling():
-				v, e, st := pollActual()
-				if st != nil && st.wasViaPanic() {
-					// we were told to stop trying via panic - which means we made it this far and should return successfully
-					return true
-				}
+		if nextPoll == nil {
+			nextPoll = assertion.afterPolling()
+		}
+
+		select {
+		case <-nextPoll:
+			v, e := pollActual()
+			lock.Lock()
+			value, err = v, e
+			lock.Unlock()
+			if err == nil {
+				oracleMatcherSaysStop = assertion.matcherSaysStopTrying(matcher, value)
+				m, e := assertion.pollMatcher(matcher, value)
 				lock.Lock()
-				value, err, stopTrying = v, e, st
+				matches, err = m, e
 				lock.Unlock()
-				if err == nil {
-					if stopTrying == nil {
-						stopTrying = assertion.matcherSaysStopTrying(matcher, value)
-					}
-					matches, e = matcher.Match(value)
-					lock.Lock()
-					err = e
-					lock.Unlock()
-				}
-			case <-contextDone:
-				fail("Context was cancelled")
+			}
+		case <-contextDone:
+			fail("Context was cancelled")
+			return false
+		case <-timeout:
+			if assertion.asyncType == AsyncAssertionTypeEventually {
+				fail("Timed out")
 				return false
-			case <-timeout:
+			} else {
+				if isTryAgainAfterError {
+					fail("Timed out while waiting on TryAgainAfter")
+					return false
+				}
 				return true
 			}
 		}
 	}
-
-	return false
 }

vendor/github.com/onsi/gomega/internal/duration_bundle.go

@@ -44,28 +44,28 @@ func durationFromEnv(key string, defaultDuration time.Duration) time.Duration {
 	return duration
 }
 
-func toDuration(input interface{}) time.Duration {
+func toDuration(input interface{}) (time.Duration, error) {
 	duration, ok := input.(time.Duration)
 	if ok {
-		return duration
+		return duration, nil
 	}
 
 	value := reflect.ValueOf(input)
 	kind := reflect.TypeOf(input).Kind()
 
 	if reflect.Int <= kind && kind <= reflect.Int64 {
-		return time.Duration(value.Int()) * time.Second
+		return time.Duration(value.Int()) * time.Second, nil
 	} else if reflect.Uint <= kind && kind <= reflect.Uint64 {
-		return time.Duration(value.Uint()) * time.Second
+		return time.Duration(value.Uint()) * time.Second, nil
 	} else if reflect.Float32 <= kind && kind <= reflect.Float64 {
-		return time.Duration(value.Float() * float64(time.Second))
+		return time.Duration(value.Float() * float64(time.Second)), nil
 	} else if reflect.String == kind {
 		duration, err := time.ParseDuration(value.String())
 		if err != nil {
-			panic(fmt.Sprintf("%#v is not a valid parsable duration string.", input))
+			return 0, fmt.Errorf("%#v is not a valid parsable duration string: %w", input, err)
 		}
-		return duration
+		return duration, nil
 	}
 
-	panic(fmt.Sprintf("%v is not a valid interval.  Must be time.Duration, parsable duration string or a number.", input))
+	return 0, fmt.Errorf("%#v is not a valid interval. Must be a time.Duration, a parsable duration string, or a number.", input)
 }

vendor/github.com/onsi/gomega/internal/gomega.go

@@ -2,6 +2,7 @@ package internal
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"github.com/onsi/gomega/types"
@@ -52,16 +53,46 @@ func (g *Gomega) ExpectWithOffset(offset int, actual interface{}, extra ...inter
 	return NewAssertion(actual, g, offset, extra...)
 }
 
-func (g *Gomega) Eventually(actual interface{}, intervals ...interface{}) types.AsyncAssertion {
-	return g.EventuallyWithOffset(0, actual, intervals...)
+func (g *Gomega) Eventually(args ...interface{}) types.AsyncAssertion {
+	return g.makeAsyncAssertion(AsyncAssertionTypeEventually, 0, args...)
 }
 
-func (g *Gomega) EventuallyWithOffset(offset int, actual interface{}, args ...interface{}) types.AsyncAssertion {
+func (g *Gomega) EventuallyWithOffset(offset int, args ...interface{}) types.AsyncAssertion {
+	return g.makeAsyncAssertion(AsyncAssertionTypeEventually, offset, args...)
+}
+
+func (g *Gomega) Consistently(args ...interface{}) types.AsyncAssertion {
+	return g.makeAsyncAssertion(AsyncAssertionTypeConsistently, 0, args...)
+}
+
+func (g *Gomega) ConsistentlyWithOffset(offset int, args ...interface{}) types.AsyncAssertion {
+	return g.makeAsyncAssertion(AsyncAssertionTypeConsistently, offset, args...)
+}
+
+func (g *Gomega) makeAsyncAssertion(asyncAssertionType AsyncAssertionType, offset int, args ...interface{}) types.AsyncAssertion {
+	baseOffset := 3
 	timeoutInterval := -time.Duration(1)
 	pollingInterval := -time.Duration(1)
 	intervals := []interface{}{}
 	var ctx context.Context
-	for _, arg := range args {
+	if len(args) == 0 {
+		g.Fail(fmt.Sprintf("Call to %s is missing a value or function to poll", asyncAssertionType), offset+baseOffset)
+		return nil
+	}
+
+	actual := args[0]
+	startingIndex := 1
+	if _, isCtx := args[0].(context.Context); isCtx && len(args) > 1 {
+		// the first argument is a context, we should accept it as the context _only if_ it is **not** the only argumnent **and** the second argument is not a parseable duration
+		// this is due to an unfortunate ambiguity in early version of Gomega in which multi-type durations are allowed after the actual
+		if _, err := toDuration(args[1]); err != nil {
+			ctx = args[0].(context.Context)
+			actual = args[1]
+			startingIndex = 2
+		}
+	}
+
+	for _, arg := range args[startingIndex:] {
 		switch v := arg.(type) {
 		case context.Context:
 			ctx = v
@@ -69,41 +100,21 @@ func (g *Gomega) EventuallyWithOffset(offset int, actual interface{}, args ...in
 			intervals = append(intervals, arg)
 		}
 	}
+	var err error
 	if len(intervals) > 0 {
-		timeoutInterval = toDuration(intervals[0])
-	}
-	if len(intervals) > 1 {
-		pollingInterval = toDuration(intervals[1])
-	}
-
-	return NewAsyncAssertion(AsyncAssertionTypeEventually, actual, g, timeoutInterval, pollingInterval, ctx, offset)
-}
-
-func (g *Gomega) Consistently(actual interface{}, intervals ...interface{}) types.AsyncAssertion {
-	return g.ConsistentlyWithOffset(0, actual, intervals...)
-}
-
-func (g *Gomega) ConsistentlyWithOffset(offset int, actual interface{}, args ...interface{}) types.AsyncAssertion {
-	timeoutInterval := -time.Duration(1)
-	pollingInterval := -time.Duration(1)
-	intervals := []interface{}{}
-	var ctx context.Context
-	for _, arg := range args {
-		switch v := arg.(type) {
-		case context.Context:
-			ctx = v
-		default:
-			intervals = append(intervals, arg)
+		timeoutInterval, err = toDuration(intervals[0])
+		if err != nil {
+			g.Fail(err.Error(), offset+baseOffset)
 		}
 	}
-	if len(intervals) > 0 {
-		timeoutInterval = toDuration(intervals[0])
-	}
 	if len(intervals) > 1 {
-		pollingInterval = toDuration(intervals[1])
+		pollingInterval, err = toDuration(intervals[1])
+		if err != nil {
+			g.Fail(err.Error(), offset+baseOffset)
+		}
 	}
 
-	return NewAsyncAssertion(AsyncAssertionTypeConsistently, actual, g, timeoutInterval, pollingInterval, ctx, offset)
+	return NewAsyncAssertion(asyncAssertionType, actual, g, timeoutInterval, pollingInterval, ctx, offset)
 }
 
 func (g *Gomega) SetDefaultEventuallyTimeout(t time.Duration) {

vendor/github.com/onsi/gomega/internal/polling_signal_error.go

@@ -0,0 +1,106 @@
+package internal
+
+import (
+	"errors"
+	"fmt"
+	"time"
+)
+
+type PollingSignalErrorType int
+
+const (
+	PollingSignalErrorTypeStopTrying PollingSignalErrorType = iota
+	PollingSignalErrorTypeTryAgainAfter
+)
+
+type PollingSignalError interface {
+	error
+	Wrap(err error) PollingSignalError
+	Attach(description string, obj any) PollingSignalError
+	Now()
+}
+
+var StopTrying = func(message string) PollingSignalError {
+	return &PollingSignalErrorImpl{
+		message:                message,
+		pollingSignalErrorType: PollingSignalErrorTypeStopTrying,
+	}
+}
+
+var TryAgainAfter = func(duration time.Duration) PollingSignalError {
+	return &PollingSignalErrorImpl{
+		message:                fmt.Sprintf("told to try again after %s", duration),
+		duration:               duration,
+		pollingSignalErrorType: PollingSignalErrorTypeTryAgainAfter,
+	}
+}
+
+type PollingSignalErrorAttachment struct {
+	Description string
+	Object      any
+}
+
+type PollingSignalErrorImpl struct {
+	message                string
+	wrappedErr             error
+	pollingSignalErrorType PollingSignalErrorType
+	duration               time.Duration
+	Attachments            []PollingSignalErrorAttachment
+}
+
+func (s *PollingSignalErrorImpl) Wrap(err error) PollingSignalError {
+	s.wrappedErr = err
+	return s
+}
+
+func (s *PollingSignalErrorImpl) Attach(description string, obj any) PollingSignalError {
+	s.Attachments = append(s.Attachments, PollingSignalErrorAttachment{description, obj})
+	return s
+}
+
+func (s *PollingSignalErrorImpl) Error() string {
+	if s.wrappedErr == nil {
+		return s.message
+	} else {
+		return s.message + ": " + s.wrappedErr.Error()
+	}
+}
+
+func (s *PollingSignalErrorImpl) Unwrap() error {
+	if s == nil {
+		return nil
+	}
+	return s.wrappedErr
+}
+
+func (s *PollingSignalErrorImpl) Now() {
+	panic(s)
+}
+
+func (s *PollingSignalErrorImpl) IsStopTrying() bool {
+	return s.pollingSignalErrorType == PollingSignalErrorTypeStopTrying
+}
+
+func (s *PollingSignalErrorImpl) IsTryAgainAfter() bool {
+	return s.pollingSignalErrorType == PollingSignalErrorTypeTryAgainAfter
+}
+
+func (s *PollingSignalErrorImpl) TryAgainDuration() time.Duration {
+	return s.duration
+}
+
+func AsPollingSignalError(actual interface{}) (*PollingSignalErrorImpl, bool) {
+	if actual == nil {
+		return nil, false
+	}
+	if actualErr, ok := actual.(error); ok {
+		var target *PollingSignalErrorImpl
+		if errors.As(actualErr, &target) {
+			return target, true
+		} else {
+			return nil, false
+		}
+	}
+
+	return nil, false
+}