"spec": {
                    "replicas": 1
                  },
                  "status": {
                    "available": 1
                  }
                },
                "namedResources": {
                  "name": "nameValue"
                }
              }
            ]
          }
        }
      ],
      "availableOnNodes": {
        "nodeSelectorTerms": [
          {

var slice = &resource.ResourceSlice{
	ObjectMeta: metav1.ObjectMeta{
		Name: "valid-class",
	},
	NodeName:   "valid-node-name",
	DriverName: "testdriver.example.com",
	ResourceModel: resource.ResourceModel{
		NamedResources: &resource.NamedResourcesResources{},
	},
}

func TestClassStrategy(t *testing.T) {
	if Strategy.NamespaceScoped() {
		t.Errorf("ResourceSlice must not be namespace scoped")
	}

			if postIndex < 0 {
				return ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NamedResources == nil {
				m.NamedResources = &NamedResourcesAllocationResult{}
			}
			if err := m.NamedResources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex

	return &resource.ResourceSlice{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},
		NodeName:   name,
		DriverName: "cdi.example.com",
		ResourceModel: resource.ResourceModel{
			NamedResources: &resource.NamedResourcesResources{},
		},
	}
}

func TestCreate(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()

	wrapper.ResourceModel = resourcev1alpha2.ResourceModel{NamedResources: &resourcev1alpha2.NamedResourcesResources{}}
	for _, name := range names {
		wrapper.ResourceModel.NamedResources.Instances = append(wrapper.ResourceModel.NamedResources.Instances,
			resourcev1alpha2.NamedResourcesInstance{Name: name},
		)
	}
	return wrapper
}

	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/apimachinery/pkg/util/validation/field"
	"k8s.io/apiserver/pkg/cel"
	"k8s.io/apiserver/pkg/cel/environment"
	namedresourcescel "k8s.io/dynamic-resource-allocation/structured/namedresources/cel"
	corevalidation "k8s.io/kubernetes/pkg/apis/core/validation"
	"k8s.io/kubernetes/pkg/apis/resource"
)

var (
	validateInstanceName  = corevalidation.ValidateDNS1123Subdomain

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package namedresources

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	resourceapi "k8s.io/api/resource/v1alpha2"
	"k8s.io/kubernetes/test/utils/ktesting"

	return &resource.ResourceSlice{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},
		NodeName:   nodeName,
		DriverName: driverName,
		ResourceModel: resource.ResourceModel{
			NamedResources: &resource.NamedResourcesResources{},
		},
	}
}

func TestValidateResourceSlice(t *testing.T) {
	goodName := "foo"
	badName := "!@#$%^"
	driverName := "test.example.com"
	now := metav1.Now()

								NodeName: "&^!",
								Results: []resource.DriverAllocationResult{
									{
										AllocationResultModel: resource.AllocationResultModel{
											NamedResources: &resource.NamedResourcesAllocationResult{
												Name: "some-resource-instance",
											},
										},
									},
									{

			parameters.DriverRequests[i].Requests[e].NamedResources.Selector = `attributes.bool["no-such-attribute"]`
		}
	}
	return parameters
}

func breakCELInClassParameters(parameters *resourcev1alpha2.ResourceClassParameters) *resourcev1alpha2.ResourceClassParameters {
	parameters = parameters.DeepCopy()
	for i := range parameters.Filters {
		parameters.Filters[i].NamedResources.Selector = `attributes.bool["no-such-attribute"]`
	}