ret, err := m.DiscoveryClient(name)
	if err != nil {
		panic(err)
	}
	return ret
}

// FakeDiscoveryWithError inherits DiscoveryInterface(via FakeDiscovery) with some methods accepting testing data.
type FakeDiscoveryWithError struct {
	fakediscovery.FakeDiscovery
	PossibleResources []*metav1.APIResourceList
	Err               error
}

		fakeclient := apiclient.NewDryRunClientWithOpts(dryRunOpts)
		// As we know the return of Discovery() of the fake clientset is of type *fakediscovery.FakeDiscovery
		// we can convert it to that struct.
		fakeclientDiscovery, ok := fakeclient.Discovery().(*fakediscovery.FakeDiscovery)
		if !ok {
			return nil, errors.New("couldn't set fake discovery's server version")
		}
		// Lastly, set the right server version to be used

			gitVersion: "v1.28.9-eks-036c24b",
			want:       128,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			c := NewFakeClient()
			c.Kube().Discovery().(*fakediscovery.FakeDiscovery).FakedServerVersion = &kubeVersion.Info{Major: tt.major, Minor: tt.minor, GitVersion: tt.gitVersion}
			if got := GetVersionAsInt(c); got != tt.want {
				t.Errorf("TestGetVersionAsInt() = %v, want %v", got, tt.want)

			major:        "1",
			minor:        "24",
			expErr:       false,
			operatorYaml: o3,
		},
	}

	for i, tt := range tests {
		k8sClient := kube.NewFakeClient()
		k8sClient.Kube().Discovery().(*fakediscovery.FakeDiscovery).FakedServerVersion = &version.Info{
			Major: tt.major,
			Minor: tt.minor,
		}
		op := &pkgAPI.IstioOperator{}
		err = yaml.Unmarshal([]byte(tt.operatorYaml), op)
		if err != nil {

	var errBuf bytes.Buffer

	for i, c := range cases {
		t.Run(fmt.Sprintf("case %d %s", i, c.version), func(t *testing.T) {
			k8sClient := kube.NewFakeClient()
			k8sClient.Kube().Discovery().(*fakediscovery.FakeDiscovery).FakedServerVersion = c.version

			logger := clog.NewConsoleLogger(&outBuf, &errBuf, nil)
			IsK8VersionSupported(k8sClient, logger)

			errMsgTrim := strings.TrimSpace(c.logMsg)

			wantParsedVersion:  "",
			wantErr:            true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			client := clientsetfake.NewSimpleClientset()
			client.Discovery().(*fakediscovery.FakeDiscovery).FakedServerVersion = tt.version

			g := &KubeVersionGetter{
				client: client,
			}
			clusterVersion, parsedVersion, err := g.ClusterVersion()

			if (err != nil) != tt.wantErr {

	// via NewClientBackedDryRunGetterFromKubeconfig() and for GetActions there seems to be no analog to
	// Discovery().Serverversion() resource for a dynamic client(?).
	fakeclientDiscovery, ok := g.client.Discovery().(*fakediscovery.FakeDiscovery)
	if ok {
		clusterVersionInfo = fakeclientDiscovery.FakedServerVersion
	} else {
		clusterVersionInfo, err = g.client.Discovery().ServerVersion()
		if err != nil {

		t.Run(tt.name, func(t *testing.T) {
			buf := &bytes.Buffer{}
			client := kube.NewFakeClient(tt.objects...)
			kube.SetObjectFilter(client, tt.discoveryNamespaceFilter)
			client.Kube().Discovery().(*fakediscovery.FakeDiscovery).FakedServerVersion = &kubeVersion.Info{Major: "1", Minor: "28"}
			kclient.NewWriteClient[*k8sbeta.GatewayClass](client).Create(customClass)
			kclient.NewWriteClient[*k8sbeta.Gateway](client).Create(tt.gw.DeepCopy())

		},
	}
	gcAdmit := &gcPermissionsEnforcement{
		Handler:   apiserveradmission.NewHandler(apiserveradmission.Create, apiserveradmission.Update),
		whiteList: whiteList,
	}

	fakeDiscoveryClient := &fakediscovery.FakeDiscovery{Fake: &coretesting.Fake{}}
	fakeDiscoveryClient.Resources = []*metav1.APIResourceList{
		{
			GroupVersion: corev1.SchemeGroupVersion.String(),
			APIResources: []metav1.APIResource{

	scheme := runtime.NewScheme()
	scheme.AddKnownTypeWithName(customGVK, &v1.Service{})
	fakeScaleClient := &scalefake.FakeScaleClient{}
	fakeDiscovery := &discoveryfake.FakeDiscovery{
		Fake: &core.Fake{},
	}
	fakeClock := clocktesting.NewFakeClock(now)

	dc := NewDisruptionControllerInternal(
		ctx,
		informerFactory.Core().V1().Pods(),