if !apiequality.Semantic.DeepEqual(uJSON, uCBOR) {
					t.Fatalf("unstructured via json differed from unstructured via cbor: %v", cmp.Diff(uJSON, uCBOR))
				}

				// original->JSON/CBOR->Unstructured == original->JSON/CBOR->Unstructured->JSON->Unstructured
				buf.Reset()
				if err := jsonSerializer.Encode(uJSON, &buf); err != nil {

	tcs := []struct {
		name          string
		old           *unstructured.Unstructured
		obj           *unstructured.Unstructured
		statusEnabled bool
		expected      *unstructured.Unstructured
	}{
		{
			name:          "/status is enabled, spec changes increment generation",
			statusEnabled: true,
			old: &unstructured.Unstructured{
				Object: map[string]interface{}{
					"metadata": generation1(),

			into:  &unstructured.Unstructured{},

			expectedGVK:    &schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Foo"},
			expectedObject: &unstructured.Unstructured{Object: map[string]interface{}{"apiVersion": "/v1", "kind": "Foo"}},
		},
		{
			data:  []byte(`{"apiVersion":"/v1","kind":"Foo"}`),
			typer: &mockTyper{gvk: &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"}},
			into:  &unstructured.Unstructured{},

				}
			},
		},
		{
			name: "into unstructured",
			data: []byte("\xa2\x6aapiVersion\x61v\x64kind\x61k"),
			into: &unstructured.Unstructured{},
			expectedObj: &unstructured.Unstructured{Object: map[string]interface{}{
				"apiVersion": "v",
				"kind":       "k",
			}},
			expectedGVK: &schema.GroupVersionKind{Version: "v", Kind: "k"},
			assertOnError: func(t *testing.T, err error) {
				if err != nil {

	}

	testCases := []struct {
		desc   string
		obj    *unstructured.Unstructured
		old    *unstructured.Unstructured
		schema apiextensions.JSONSchemaProps
		iters  int // how many times to validate the same update before checking metric
		want   string
	}{
		{
			desc: "valid noop update",
			obj: &unstructured.Unstructured{
				Object: map[string]interface{}{
					"foo": "bar",
				},
			},

					}
				}
				apiVersion, _ := content["apiVersion"].(string)
				kind, _ := content["kind"].(string)
				kind = strings.TrimSuffix(kind, "List")
				var unstructureds []unstructured.Unstructured
				if len(items) > 0 {
					unstructureds = make([]unstructured.Unstructured, len(items))
				}
				for i := range items {
					object, cast := items[i].(map[string]interface{})
					if !cast {

var (
	ownedResourcePredicates = predicate.TypedFuncs[*unstructured.Unstructured]{
		CreateFunc: func(_ event.TypedCreateEvent[*unstructured.Unstructured]) bool {
			// no action
			return false
		},
		GenericFunc: func(_ event.TypedGenericEvent[*unstructured.Unstructured]) bool {
			// no action
			return false
		},
		DeleteFunc: func(e event.TypedDeleteEvent[*unstructured.Unstructured]) bool {
			obj, err := meta.Accessor(e.Object)

				}
			}
		}

		// Update test
		for version2, noxuResourceClient2 := range noxuResourceClients {
			var gottenNoxuInstance *unstructured.Unstructured
			if disabledVersions[version2] {
				gottenNoxuInstance = &unstructured.Unstructured{}
				gottenNoxuInstance.SetName("foo")
			} else {
				gottenNoxuInstance, err = noxuResourceClient2.Get(context.TODO(), "foo", metav1.GetOptions{})

				}
				if iter.HasNext() != types.True {
					t.Error("Expected HasNext to return true")
				}
				next := iter.Next().Value()
				if !reflect.DeepEqual(next, tc.unstructured[i]) {
					t.Errorf("Expected Next to return %v for index %d but got %v", tc.unstructured[i], i, next)
				}
			}
			if iter.HasNext() != types.False {
				t.Error("Expected HasNext to return false")
			}

func getRemainingResourcesCluster(cs cluster.Cluster, gvr schema.GroupVersionResource, ls string) ([]unstructured.Unstructured, []string) {
	usList, _ := cs.Dynamic().Resource(gvr).List(context.TODO(), metav1.ListOptions{LabelSelector: ls})
	var remainingResources []unstructured.Unstructured
	var staleList []string
	if usList != nil && len(usList.Items) != 0 {
		for _, item := range usList.Items {