break
		}
	}
	if specVersion == nil && len(specVersion.SelectableFields) == 0 {
		return nil
	}
	selectableFields := make([]any, len(specVersion.SelectableFields))
	for i, sf := range specVersion.SelectableFields {
		props := map[string]any{
			"fieldPath": strings.TrimPrefix(sf.JSONPath, "."),
		}
		selectableFields[i] = props
	}
	return selectableFields

            "format": "formatValue",
            "description": "descriptionValue",
            "priority": 5,
            "JSONPath": "JSONPathValue"
          }
        ],
        "selectableFields": [
          {
            "jsonPath": "jsonPathValue"
          }
        ]
      }
    ],
    "additionalPrinterColumns": [
      {
        "name": "nameValue",

		strategy.selectableFieldSet = prepareSelectableFields(selectableFields)
	}
	return strategy
}

func prepareSelectableFields(selectableFields []v1.SelectableField) []selectableField {
	result := make([]selectableField, len(selectableFields))
	for i, sf := range selectableFields {
		name := strings.TrimPrefix(sf.JSONPath, ".")

		parser := jsonpath.New("selectableField")

	}
	return labels.Set(configMap.Labels), SelectableFields(configMap), nil
}

// Matcher returns a selection predicate for a given label and field selector.
func Matcher(label labels.Selector, field fields.Selector) pkgstorage.SelectionPredicate {
	return pkgstorage.SelectionPredicate{
		Label:    label,
		Field:    field,
		GetAttrs: GetAttrs,
	}
}

			},
			map[string]any{
				"fieldPath": "spec.size",
			},
			map[string]any{
				"fieldPath": "spec.branded",
			},
		}
		if !reflect.DeepEqual(selectableFields, expected) {
			t.Errorf("expected %v but got %v", selectableFields, expected)
		}
	})

	t.Run("OpenAPIv2", func(t *testing.T) {
		v2, err := discoveryClient.OpenAPISchema()
		if err != nil {
			t.Fatal(err)
		}

	if !ok {
		return nil, nil, fmt.Errorf("not a clustertrustbundle")
	}

	selectableFields := generic.MergeFieldsSets(generic.ObjectMetaFieldsSet(&bundle.ObjectMeta, false), fields.Set{
		"spec.signerName": bundle.Spec.SignerName,
	})

	return labels.Set(bundle.Labels), selectableFields, nil

					Group: "bar.k8s.io",
					Versions: []apiextensionsv1.CustomResourceDefinitionVersion{
						{
							Name:             "v1",
							Schema:           validation,
							SelectableFields: tt.selectableFields,
						},
					},
					Names: apiextensionsv1.CustomResourceDefinitionNames{
						Plural:   "foos",
						Singular: "foo",
						Kind:     "Foo",
						ListKind: "FooList",
					},

	spec.SelectableFields = nil
	for i := range spec.Versions {
		spec.Versions[i].SelectableFields = nil
	}
}

func specHasSelectableFields(spec *apiextensions.CustomResourceDefinitionSpec) bool {
	if spec.SelectableFields != nil {
		return true
	}
	for _, v := range spec.Versions {
		if v.SelectableFields != nil {
			return true
		}
	}

	return false

	_ "k8s.io/kubernetes/pkg/apis/core/install"
)

func TestSelectableFieldLabelConversions(t *testing.T) {
	apitesting.TestSelectableFieldLabelConversionsOfKind(t,
		"v1",
		"Secret",
		SelectableFields(&api.Secret{}),
		nil,
	)

    kind: kindValue
    listKind: listKindValue
    plural: pluralValue
    shortNames:
    - shortNamesValue
    singular: singularValue
  preserveUnknownFields: true
  scope: scopeValue
  selectableFields:
  - jsonPath: jsonPathValue
  subresources:
    scale:
      labelSelectorPath: labelSelectorPathValue
      specReplicasPath: specReplicasPathValue
      statusReplicasPath: statusReplicasPathValue