}
	return res
}

func (t TestWriter[T]) CreateOrUpdate(object T) T {
	t.t.Helper()
	res, err := kclient.CreateOrUpdate[T](t.c, object)
	if err != nil {
		t.t.Fatalf("createOrUpdate %v/%v: %v", object.GetNamespace(), object.GetName(), err)
	}
	return res
}

func (t TestWriter[T]) CreateOrUpdateStatus(object T) T {
	t.t.Helper()
	_, err := kclient.CreateOrUpdate(t.c, object)
	if err != nil {

	client.RunAndWait(stop)
	go w.Run(stop)
	whc := clienttest.Wrap(t, w.webhooks)
	expectRevision(t, w, "")
	// change default to "red"
	whc.CreateOrUpdate(webhook("red"))
	expectRevision(t, w, "red")

	// change default to "green"
	whc.CreateOrUpdate(webhook("green"))
	expectRevision(t, w, "green")

	// remove default
	whc.Delete(defaultTagWebhookName, "")
	expectRevision(t, w, "")
}

	// or an error if the allocation could not be retrieved.
	Get() (*api.RangeAllocation, error)
	// CreateOrUpdate should create or update the provide allocation, unless a conflict
	// has occurred since the item was last created.
	CreateOrUpdate(*api.RangeAllocation) error

			IP:    "2.3.4.6",
			Ports: []corev1.PortStatus{{Port: 15443, Protocol: corev1.ProtocolTCP}},
		}}}},
	}
	clienttest.Wrap(t, c.services).CreateOrUpdate(svc)
}

func removeLabeledServiceGateway(t *testing.T, c *FakeController) {
	clienttest.Wrap(t, c.services).Delete("istio-labeled-gw", "arbitrary-ns")
}

		return nil, storeerr.InterpretGetError(err, e.resource, "")
	}
	return existing, nil
}

// CreateOrUpdate attempts to update the current etcd state with the provided
// allocation.
func (e *Etcd) CreateOrUpdate(snapshot *api.RangeAllocation) error {
	e.lock.Lock()
	defer e.lock.Unlock()

	last := ""

// limitations under the License.

package kclient

import (
	kerrors "k8s.io/apimachinery/pkg/api/errors"

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

func CreateOrUpdate[T controllers.Object](c Writer[T], object T) (T, error) {
	res, err := c.Create(object)
	if kerrors.IsAlreadyExists(err) {
		// Already exist, update
		return c.Update(object)
	}
	return res, err

			}

			// Create a fake client and create the cluster-info ConfigMap
			client := fakeclient.NewSimpleClientset()
			if err = test.configMap.createOrUpdate(client); err != nil {
				t.Fatalf("could not create ConfigMap: %v", err)
			}

			// Set arbitrary discovery timeout and retry interval
			timeout := time.Millisecond * 500
			interval := time.Millisecond * 20

		gc := &gateway.GatewayClass{
			ObjectMeta: metav1.ObjectMeta{
				Name: name,
			},
			Spec: gateway.GatewayClassSpec{
				ControllerName: gateway.GatewayController(controller),
			},
		}
		classes.CreateOrUpdate(gc)
	}
	deleteClass := func(name string) {
		classes.Delete(name, "")
	}
	expectClass := func(name, controller string) {
		t.Helper()
		retry.UntilSuccessOrFail(t, func() error {
			gc := classes.Get(name, "")

		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: ns,
		},
		Spec: *spec, //nolint: govet
	}
	clienttest.NewWriter[*securityclient.PeerAuthentication](s.T(), s.KubeClient()).CreateOrUpdate(c)
}

func deleteRBAC(s *xds.FakeDiscoveryServer, name string, ns string) {
	clienttest.NewWriter[*securityclient.AuthorizationPolicy](s.T(), s.KubeClient()).Delete(name, ns)
}

			modify(pol)
		}
		s.authz.CreateOrUpdate(pol)
	case gvk.PeerAuthentication:
		pol := &clientsecurityv1beta1.PeerAuthentication{
			ObjectMeta: metav1.ObjectMeta{
				Name:      name,
				Namespace: ns,
			},
			Spec: auth.PeerAuthentication{
				Selector: sel,
			},
		}
		if modify != nil {
			modify(pol)
		}
		s.pa.CreateOrUpdate(pol)
	}
}