cfg.delayMax = delay * 16
	}
}

// Converge sets the number of successes in a row needed to count a success.
// This is useful to avoid the case where tests like `coin.Flip() == HEADS` will always
// return success due to random variance.
func Converge(successes int) Option {
	return func(cfg *config) {
		cfg.converge = successes
	}
}

package retry

import (
	"fmt"
	"testing"
	"time"
)

func TestConverge(t *testing.T) {
	t.Run("no converge", func(t *testing.T) {
		flipFlop := true
		err := UntilSuccess(func() error {
			flipFlop = !flipFlop
			if flipFlop {
				return fmt.Errorf("flipFlop was true")
			}
			return nil
		}, Converge(2), Timeout(time.Millisecond*10), Delay(time.Millisecond))
		if err == nil {

namespace mlir {
namespace TFDevice {
namespace {

constexpr char kBadDecompositionMessage[] =
    "Resource ops decomposition did not converge";

// Decomposing resource ops should not take more than a few iterations (2-3) to
// converge as only a few patterns create new resource ops that can be further
// decomposed. The rest of the iterations are enough to clean up any dead ops
// created by decomposition.

	// converging by default, so long as the count is greater than the default converge value.
	// This, of course, can be overridden if the user supplies their own converge value.
	if o.Count > callConverge {
		retryOpts = append(retryOpts, retry.Converge(1))
	}

	// Now append user-provided options to override the defaults.
	o.Retry.Options = append(retryOpts, o.Retry.Options...)

		}
		return nil
	}, retry.Timeout(time.Second*5), retry.Converge(5))
	retry.UntilOrFail(t, func() bool {
		return store.Get(r.GroupVersionKind(), configMeta.Name, configMeta.Namespace) == nil
	}, retry.Message("expected no items returned for unknown CRD"), retry.Timeout(time.Second*5), retry.Converge(5))
}

// Ensure that the client can run without CRDs present, but then added later

        |||
      ),
      panels.timeSeries.base('Workload Manager', queries.workloadManager, |||
        Count of active and pending proxies managed by each instance.
        Pending is expected to converge to zero.
      |||
      ),
    ]),
  ], panelHeight=8)
)

  populateWithGenerated(patterns);

  FrozenRewritePatternSet frozen_patterns(std::move(patterns));
  if (failed(applyPatternsAndFoldGreedily(func_op, frozen_patterns))) {
    func_op.emitWarning() << "Failed to converge "
                          << RemoveShardingCustomCallPass::getArgumentName();
  }
}

// DefaultCallRetryOptions returns the default call retry options as specified in command-line flags.
func DefaultCallRetryOptions() []retry.Option {
	return []retry.Option{retry.Timeout(callTimeout), retry.BackoffDelay(callDelay), retry.Converge(callConverge)}
}

// DefaultReadinessTimeout returns the default echo readiness check timeout.
func DefaultReadinessTimeout() time.Duration {
	return readinessTimeout
}

# missing package, only to remove that package when resolving its dependencies.
#
# If we naively iterate 'go mod tidy' until the dependency graph converges, this
# scenario may fail to converge.

# The import graph used in this test looks like:
#
# m --- w
# |
# + --- x
# |
# + --- y
# |
# + --- z
#

        |||
      ),
      panels.heatmap.base(
        'Push Time', queries.pushTime, |||
          Count of active and pending proxies managed by each instance.
          Pending is expected to converge to zero.
        |||
      ),
      panels.heatmap.bytes(
        'Push Size', queries.pushSize, |||
          Size of each xDS push.
        |||
      ),
    ]),
  ], panelHeight=10, startY=3)