// Values returns the operator values for the installed control plane.
	Values() (OperatorValues, error)
	ValuesOrFail(test.Failer) OperatorValues
	// MeshConfig used by the Istio installation.
	MeshConfig() (*meshconfig.MeshConfig, error)
	MeshConfigOrFail(test.Failer) *meshconfig.MeshConfig
	// UpdateMeshConfig used by the Istio installation.

		if err := Wrap(func(t Failer) {
			t.Fatalf("failed")
		}); err == nil {
			t.Fatalf("expected error, got none")
		}
	})
	t.Run("success", func(t *testing.T) {
		if err := Wrap(func(t Failer) {}); err != nil {
			t.Fatalf("expected no error, got: %v", err)
		}
	})
	t.Run("cleanup", func(t *testing.T) {
		done := false
		if err := Wrap(func(t Failer) {
			t.Cleanup(func() {
				done = true
			})

	msg := &admin.ServerInfo{}
	if err := s.adminRequest("server_info", msg); err != nil {
		return nil, err
	}

	return msg, nil
}

func (s *sidecar) InfoOrFail(t test.Failer) *admin.ServerInfo {
	t.Helper()
	info, err := s.Info()
	if err != nil {
		t.Fatal(err)
	}
	return info
}

func (s *sidecar) Config() (*admin.ConfigDump, error) {
	msg := &admin.ConfigDump{}

	"istio.io/istio/pkg/kube/controllers"
	"istio.io/istio/pkg/kube/kclient"
	"istio.io/istio/pkg/test"
)

type directClient[T controllers.Object, PT any, TL runtime.Object] struct {
	kclient.Writer[T]
	t      test.Failer
	client kube.Client
}

func (d *directClient[T, PT, TL]) Get(name, namespace string) T {
	api := kubeclient.GetClient[T, TL](d.client, namespace)
	res, err := api.Get(context.Background(), name, metav1.GetOptions{})

func CompareContent(t test.Failer, content []byte, goldenFile string) {
	t.Helper()
	golden := ReadGoldenFile(t, content, goldenFile)
	CompareBytes(t, content, golden, goldenFile)
}

// ReadGoldenFile reads the content of the golden file and fails the test if an error is encountered
func ReadGoldenFile(t test.Failer, content []byte, goldenFile string) []byte {
	t.Helper()

	"istio.io/istio/pkg/test/util/assert"
	"istio.io/istio/pkg/util/sets"
)

type TestClient[T controllers.Object] struct {
	c kclient.ReadWriter[T]
	t test.Failer
	TestWriter[T]
}

type TestWriter[T controllers.Object] struct {
	c kclient.Writer[T]
	t test.Failer
}

func (t TestClient[T]) Get(name, namespace string) T {
	return t.c.Get(name, namespace)
}

	TemplateOrFail(t test.Failer) *param.Template

	// MustTemplate calls Template and panics if an error occurs.
	MustTemplate() *param.Template

	// YAML reads the yaml from this Source. If this source contains parameters,
	// it is evaluated as a template.
	YAML() (string, error)

	// YAMLOrFail calls GetYAML and fails if an error occurs.
	YAMLOrFail(t test.Failer) string

		}
	}
	return res, nil
}

func ReadDirOrFail(t test.Failer, filePath string, extensions ...string) []string {
	t.Helper()
	res, err := ReadDir(filePath, extensions...)
	if err != nil {
		t.Fatal(err)
	}
	return res
}

func WriteOrFail(t test.Failer, filePath string, contents []byte) {
	t.Helper()
	err := os.WriteFile(filePath, contents, os.ModePerm)

	Factory

	// Copy returns a deep copy of this Plan.
	Copy() Plan

	// Apply this config.
	Apply(opts ...apply.Option) error
	ApplyOrFail(t test.Failer, opts ...apply.Option)

	// Delete this config.
	Delete() error
	DeleteOrFail(t test.Failer)

	for _, c := range [][]byte{
		{},
		[]byte("."),
		bytes.Repeat([]byte("."), 1000),
	} {
		f.Add(c)
	}
}

// T Returns the underlying test.Failer. Should be avoided where possible; in oss-fuzz many functions do not work.
func (h Helper) T() test.Failer {
	return h.t