// See the License for the specific language governing permissions and
// limitations under the License.

package retry

import (
	"net/http"
	"strconv"
	"strings"

	route "github.com/envoyproxy/go-control-plane/envoy/config/route/v3"
	previouspriorities "github.com/envoyproxy/go-control-plane/envoy/extensions/retry/priority/previous_priorities/v3"
	wrappers "google.golang.org/protobuf/types/known/wrapperspb"

		}
		return nil
	}, retry.Timeout(time.Second), retry.BackoffDelay(time.Millisecond))
	if err != nil {
		t.t.Fatal(err)
	}
	t.Empty()
}

// WaitCompare waits for an event to happen and ensures it meets a custom comparison function
func (t *Tracker[T]) WaitCompare(f func(T) bool) {
	t.t.Helper()
	var err error
	retry.UntilSuccessOrFail(t.t, func() error {
		t.mu.Lock()

---
`).ApplyOrFail(t, apply.NoCleanup)
			cs := t.Clusters().Default().(*kubecluster.Cluster)
			retry.UntilSuccessOrFail(t, func() error {
				_, err := kubetest.CheckPodsAreReady(kubetest.NewPodFetch(cs, gatewayNs.Name(), "istio=ingressgateway"))
				return err
			}, retry.Timeout(time.Minute*2), retry.Delay(time.Second))

			}
			cont <- struct{}{}
			eventNum.Inc()
		}, quitChan)
		retry.UntilSuccessOrFail(t, func() error {
			if int(eventNum.Load()) != len(expectedTCPEvents) {
				return fmt.Errorf("waiting for %v events", len(expectedTCPEvents)-int(eventNum.Load()))
			}
			return nil
		}, retry.Delay(time.Millisecond*10), retry.Timeout(time.Second))
		close(quitChan)
	})
	t.Run("http", func(t *testing.T) {

						}
						if !tracing.VerifyEchoTraces(ctx, appNsInst.Name(), cluster.Name(), traces) {
							return errors.New("cannot find expected traces")
						}
						return nil
					}, retry.Delay(3*time.Second), retry.Timeout(80*time.Second))
				})

			}
		})

			return nil
		}
		success.Inc()
		return nil
	})
	go queue.Run(test.NewStop(t))
	retry.UntilOrFail(t, queue.HasSynced)
	queue.Add(types.NamespacedName{Name: "success"})
	retry.UntilOrFail(t, func() bool { return success.Load() == 1 })
	queue.Add(types.NamespacedName{Name: "conflict-success"})
	retry.UntilOrFail(t, func() bool { return success.Load() == 2 && retries.Load() == 5 })

func EventuallyEqual[T any](t test.Failer, fetch func() T, expected T, retryOpts ...retry.Option) {
	t.Helper()
	var a T
	// Unit tests typically need shorter default; opts can override though
	ro := []retry.Option{retry.Timeout(time.Second * 2), retry.BackoffDelay(time.Millisecond * 2)}
	ro = append(ro, retryOpts...)
	err := retry.UntilSuccess(func() error {
		a = fetch()
		if !cmp.Equal(a, expected, opts(expected)...) {

	"istio.io/istio/pkg/test/util/retry"
)

// TestIstioctlMetrics contains a basic validation of the experimental
// metrics command. It validates that values are being returned when there is
// traffic and that the expected default output format is matched.
func TestIstioctlMetrics(t *testing.T) {
	framework.NewTest(t).
		Run(func(t framework.TestContext) {
			retry.UntilSuccessOrFail(t, func() error {

import (
	"fmt"
	"strings"
	"testing"

	"istio.io/istio/pkg/test/framework"
	"istio.io/istio/pkg/test/framework/components/echo"
	"istio.io/istio/pkg/test/framework/components/istioctl"
	"istio.io/istio/pkg/test/util/retry"
)

func TestPiggyback(t *testing.T) {
	// nolint: staticcheck
	framework.
		NewTest(t).RequiresSingleCluster().
		RequiresLocalControlPlane().
		RequireIstioVersion("1.10.0").

	handles := atomic.NewInt32(0)
	task := func() error {
		handles.Inc()
		return nil
	}
	q := NewQueue(0)
	q.Push(task)
	stop := make(chan struct{})
	go q.Run(stop)
	retry.UntilOrFail(t, q.HasSynced, retry.Delay(time.Microsecond))
	// Must always be 1 since we are synced
	assert.Equal(t, handles.Load(), 1)
	close(stop)
	assert.NoError(t, WaitForClose(q, time.Second))