},
	}
	for _, tc := range tests {
		crd := generateCRDwithCondition(tc.crdCondition)
		SetCRDCondition(crd, tc.newCondition)
		if len(tc.expectedcrdCondition) != len(crd.Status.Conditions) {
			t.Errorf("%v expected %v, got %v", tc.name, tc.expectedcrdCondition, crd.Status.Conditions)
		}
		for i := range tc.expectedcrdCondition {
			if !IsCRDConditionEquivalent(&tc.expectedcrdCondition[i], &crd.Status.Conditions[i]) {

	for _, depCRD := range deprecatedCRDs {
		var group, kind string
		switch crd := r.Message.(type) {
		case *k8sext.CustomResourceDefinition:
			group = crd.Spec.Group
			kind = crd.Spec.Names.Kind
		case *k8sext.CustomResourceDefinitionSpec:
			group = crd.Group
			kind = crd.Names.Kind
		}
		if group == depCRD.Group && kind == depCRD.Names.Kind {
			ctx.Report(gvk.CustomResourceDefinition,

# Monitor

This package provides the ability to populate a `crd.Controller` dynamically via a function that provides
additional config. The monitor will acquire snapshots of additional changes and populate the `crd.Controller`
as needed.

## Creating a Monitor

To create a monitor, you should provide the `crd.Controller`, a polling interval, and
a function that returns `[]*model.Config`.

```golang
monitor := file.NewMonitor(

				return err
			}
			for _, crd := range crdl.Items {
				if !strings.HasSuffix(crd.Name, "gateway.networking.k8s.io") {
					continue
				}
				found := false
				for _, c := range crd.Status.Conditions {
					if c.Type == apiextensions.Established && c.Status == apiextensions.ConditionTrue {
						found = true
					}
				}
				if !found {
					return fmt.Errorf("crd %v not ready: %+v", crd.Name, crd.Status)
				}

		}

		gks := []schema.GroupKind{}

		// We need to parse the list to get the gvk, I guess that's fine.
		for _, crd := range (*list).Items {
			// Look for group, version, and kind
			group, _, _ := unstructured.NestedString(crd.Object, "spec", "group")
			kind, _, _ := unstructured.NestedString(crd.Object, "spec", "names", "kind")

			gks = append(gks, schema.GroupKind{
				Group: group,
				Kind:  kind,
			})
		}

			},
			queryParam:       "UnknownQueryParam",
			expectedSupports: false,
		},
		"Field validation query param supported for found CRD in primary verifier": {
			crds: []schema.GroupKind{
				{
					Group: "example.com",
					Kind:  "ExampleCRD",
				},
			},
			// GVK matches above CRD GroupKind
			gvk: schema.GroupVersionKind{
				Group:   "example.com",
				Version: "v1",
				Kind:    "ExampleCRD",
			},

	// update validation via update because the cache priming in CreateCRDUsingRemovedAPI will fail otherwise
	t.Logf("Updating CRD to validate apiVersion")
	noxuDefinition, err = UpdateCustomResourceDefinitionWithRetry(apiExtensionClient, noxuDefinition.Name, func(crd *apiextensionsv1.CustomResourceDefinition) {
		for i := range crd.Spec.Versions {
			crd.Spec.Versions[i].Schema = &apiextensionsv1.CustomResourceValidation{
				OpenAPIV3Schema: &apiextensionsv1.JSONSchemaProps{

	}

	// Determine whether we should expect to be asked to "convert" autoscaling/v1 Scale types
	convertScale := false
	selectableFields := map[schema.GroupVersion]sets.Set[string]{}
	for _, version := range crd.Spec.Versions {
		gv := schema.GroupVersion{Group: crd.Spec.Group, Version: version.Name}
		if version.Subresources != nil && version.Subresources.Scale != nil {

			old := tc.oldCRD.DeepCopy()

			dropDisabledFields(tc.crd, tc.oldCRD)

			// old crd should never be changed
			if diff := cmp.Diff(tc.oldCRD, old); diff != "" {
				t.Fatalf("old crd changed from %v to %v\n%v", tc.oldCRD, old, diff)
			}

			if diff := cmp.Diff(tc.expectedCRD, tc.crd); diff != "" {
				t.Fatalf("unexpected crd: %v\n%v", tc.crd, diff)
			}
		})
	}

	// Now that the feature gate is disabled again, update the CRD to trigger an openAPI update
	crd, err = apiExtensionClient.ApiextensionsV1().CustomResourceDefinitions().Get(ctx, crd.Name, metav1.GetOptions{})
	crd.Spec.Versions[0].SelectableFields = []apiextensionsv1.SelectableField{
		{JSONPath: ".spec.color"},
		{JSONPath: ".spec.quantity"},
	}