func (f fakeInstance) Addresses() []string {
	panic("implement me")
}

func (f fakeInstance) Workloads() (echo.Workloads, error) {
	panic("implement me")
}

func (f fakeInstance) WorkloadsOrFail(test.Failer) echo.Workloads {
	panic("implement me")
}

func (f fakeInstance) MustWorkloads() echo.Workloads {
	panic("implement me")
}

func (f fakeInstance) Clusters() cluster.Clusters {
	panic("implement me")

		return nil, err
	}
	return reg, nil
})

func TestRegistry(t test.Failer) prometheus.Gatherer {
	r, err := reg.Get()
	if err != nil {
		t.Fatal(err)
	}
	return r
}

func New(t test.Failer) *MetricsTest {
	r := TestRegistry(t)
	mt := &MetricsTest{t: t, reg: r, deltas: computeDeltas(t, r)}
	return mt
}

func computeDeltas(t test.Failer, reg prometheus.Gatherer) map[metricKey]float64 {
	res := map[metricKey]float64{}

					c.StableName(), err, s))
			}
		}
	}
	return outErr
}

func (c *configFactory) WaitForConfigOrFail(ctx resource.Context, t test.Failer, ns string, yamlText ...string) {
	err := c.WaitForConfig(ctx, ns, yamlText...)
	if err != nil {
		// TODO(https://github.com/istio/istio/issues/37148) fail hard in this case
		t.Log(err)
	}
}

// license that can be found in the LICENSE file.

package P

type A1[T any] struct{}

func (*A1[T]) m1(T) {}

type A2[T any] interface {
	m2(T)
}

type B1[T any] struct {
	filler int
	*A1[T]
	A2[T]
}

type B2[T any] interface {
	A2[T]
}

type C[T any] struct {
	filler1 int
	filler2 int
	B1[T]
}

type D[T any] struct {
	filler1 int
	filler2 int

		TypeMeta: metav1.TypeMeta{},
		ObjectMeta: metav1.ObjectMeta{
			Name: defaultTagWebhookName,
			Labels: map[string]string{
				label.IoIstioRev.Name: revision,
			},
		},
	}
}

func expectRevision(t test.Failer, watcher DefaultWatcher, expected string) {
	t.Helper()
	retry.UntilSuccessOrFail(t, func() error {
		got := watcher.GetDefault()
		if got != expected {

func NewGenerator(t test.Failer, cfg Config) Generator {
	fillInDefaults(&cfg)
	return &generator{
		Config:  cfg,
		t:       t,
		stop:    make(chan struct{}),
		stopped: make(chan struct{}),
	}
}

var _ Generator = &generator{}

type generator struct {
	Config
	t       test.Failer
	result  Result
	stop    chan struct{}
	stopped chan struct{}
}

	WriteYAML(filenamePrefix string, contents ...string) ([]string, error)

	// WriteYAMLOrFail calls WriteYAML and fails the test if an error occurs.
	WriteYAMLOrFail(t test.Failer, filenamePrefix string, contents ...string) []string
}

type writerImpl struct {
	workDir string
}

// NewFileWriter creates a new FileWriter that stores files under workDir.

package ptr

import (
	"testing"

	"github.com/google/go-cmp/cmp"

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

// Cannot use assert.assertEqual due to import loop
func assertEqual[T any](t test.Failer, a, b T) {
	t.Helper()
	if !cmp.Equal(a, b) {
		t.Fatalf("Left: %v\nRight: %v", a, b)
	}
}

func TestEmpty(t *testing.T) {
	type ts struct{}
	assertEqual(t, Empty[string](), "")

	From      Caller
	Opts      CallOptions
	Responses echo.Responses
}

type Caller interface {
	// Call from this Instance to a target Instance.
	Call(options CallOptions) (CallResult, error)
	CallOrFail(t test.Failer, options CallOptions) CallResult
}

type Callers []Caller

// Instances returns an Instances if all callers are Instance, otherwise returns nil.
func (c Callers) Instances() Instances {
	var out Instances

	if err := t.Execute(&b, data); err != nil {
		return "", err
	}

	return b.String(), nil
}

// ExecuteOrFail calls Execute and fails the test if it returns an error.
func ExecuteOrFail(t test.Failer, t2 *template.Template, data any) string {
	t.Helper()
	s, err := Execute(t2, data)
	if err != nil {
		t.Fatal(err)
	}
	return s