// set issuer, podStore and secretStore to allow the token endpoint to be initialised
	rest, err := NewREST(restOptions, fakeTokenGenerator{"fake"}, nil, 0, panicGetter{}, panicGetter{}, nil, false)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return rest, server
}

// A basic fake token generator which always returns a static string
type fakeTokenGenerator struct {
	staticToken string
}

      containers:
        - name: hello
          image: "fake.docker.io/google-samples/hello-go-gke:1.0"
          ports:
            - name: http
              containerPort: 80
          livenessProbe:
            httpGet:
              port: http
          readinessProbe:
            httpGet:
              port: 3333
        - name: world
          image: "fake.docker.io/google-samples/hello-go-gke:1.0"
          ports:

	t.Helper()
	crd := &v1.CustomResourceDefinition{
		ObjectMeta: metav1.ObjectMeta{
			Name:        fmt.Sprintf("%s.%s", g.Resource, g.Group),
			Annotations: annotations,
		},
	}
	// Metadata client fake is not kept in sync, so if using a fake client update that as well
	fmc, ok := c.Metadata().(*metadatafake.FakeMetadataClient)
	if !ok {
		return
	}
	fmg := fmc.Resource(gvr.CustomResourceDefinition)

	"k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	utilfeature "k8s.io/apiserver/pkg/util/feature"
	clientset "k8s.io/client-go/kubernetes"
	"k8s.io/client-go/kubernetes/fake"
	featuregatetesting "k8s.io/component-base/featuregate/testing"
	"k8s.io/kubernetes/pkg/features"
)

type conditionMergeTestCase struct {
	description     string
	pvc             *v1.PersistentVolumeClaim

        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = true)
        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)

        if (mainModule.testModule.directives.contains(Directives.COPY_RESOLUTION_MODE)) {
            fakeKtFile.originalFile = mainFile
        }

     * }
     * ```
     *
     * In the class scope of `B`, there is a callable symbol `foo` that takes a `String`. This symbol is derived from the original symbol
     * in `A` that takes the type parameter `T` (fake override). Given such a fake override symbol, [unwrapFakeOverrides] recovers the
     * original declared symbol.
     *

    * If you didn't use FastAPI and used Starlette directly (or another tool, like Sanic, Flask, Responder, etc) you would have to implement all the data validation and serialization yourself....

			istioCtl := istioctl.NewOrFail(t, t, istioctl.Config{})
			cs := t.Clusters().Default()
			t.Cleanup(func() {
				cleanupIstioResources(t, cs, istioCtl)
			})

			// Install with a fake tag to make the installation fail
			_, _, err := istioCtl.Invoke([]string{
				"install", "--skip-confirmation",
				"--set", "tag=0.20.0-faketag",
				"--readiness-timeout", "5s",
			})
			assert.Error(t, err)

			TrafficPolicy: &networking.TrafficPolicy{Tls: &networking.ClientTLSSettings{
				Mode:              networking.ClientTLSSettings_MUTUAL,
				ClientCertificate: "fake",
				PrivateKey:        "fake",
				CaCertificates:    "fake",
			}},
		},
	}
	drIstioMTLS := config.Config{
		Meta: config.Meta{
			GroupVersionKind: gvk.DestinationRule,
			Name:             "dr",
			Namespace:        "test",

		if err != nil {
			return nil, err
		}
	} else {
		client, err = buildClient(kubeconfigPath)
		if err != nil {
			return nil, err
		}
	}

	// support fake VMs by default
	vmSupport := true
	if vmP := cfg.Meta.Bool(vmSupportMetaKey); vmP != nil {
		vmSupport = *vmP
	}

	return &Cluster{
		filename:  kubeconfigPath,
		CLIClient: client,
		vmSupport: vmSupport,