NamedResources: &resourceapi.NamedResourcesResources{
							Instances: []resourceapi.NamedResourcesInstance{{Name: "one"}, {Name: "two"}},
						},
					},
				},
				&resourceapi.ResourceSlice{
					NodeName:   "node-b",
					DriverName: "driver",
					ResourceModel: resourceapi.ResourceModel{
						NamedResources: &resourceapi.NamedResourcesResources{

		},
		"int-slice": {

	testcases := map[string]struct {
		resources   []*resourceapi.NamedResourcesResources
		allocations []*resourceapi.NamedResourcesAllocationResult

		expectModel Model
	}{
		"empty": {},

		"nil": {
			resources:   []*resourceapi.NamedResourcesResources{nil},
			allocations: []*resourceapi.NamedResourcesAllocationResult{nil},
		},

		"available": {
			resources: []*resourceapi.NamedResourcesResources{
				{

func AddAllocation(m *Model, result *resourceapi.NamedResourcesAllocationResult) {
	if result == nil {
		return
	}
	for i := range m.Instances {
		if m.Instances[i].Instance.Name == result.Name {
			m.Instances[i].Allocated = true
			break
		}
	}
}

func NewClaimController(filter *resourceapi.NamedResourcesFilter, requests []*resourceapi.NamedResourcesRequest) (*Controller, error) {
	c := &Controller{}

		AddFunc: func(obj any) {
			slice, ok := obj.(*resourceapi.ResourceSlice)
			if !ok {
				return
			}
			logger.V(5).Info("ResourceSlice add", "slice", klog.KObj(slice))
			c.queue.Add(slice.DriverName)
		},
		UpdateFunc: func(old, new any) {
			oldSlice, ok := old.(*resourceapi.ResourceSlice)
			if !ok {
				return
			}
			newSlice, ok := new.(*resourceapi.ResourceSlice)
			if !ok {
				return
			}

See the License for the specific language governing permissions and
limitations under the License.
*/

package dra

import (
	"context"
	"fmt"
	"time"

	v1 "k8s.io/api/core/v1"
	resourceapi "k8s.io/api/resource/v1alpha2"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/apimachinery/pkg/util/wait"

var (
	configMapResource     = api.Resource("configmaps")
	secretResource        = api.Resource("secrets")
	resourceSlice         = resourceapi.Resource("resourceslices")
	pvcResource           = api.Resource("persistentvolumeclaims")
	pvResource            = api.Resource("persistentvolumes")
	resourceClaimResource = resourceapi.Resource("resourceclaims")
	vaResource            = storageapi.Resource("volumeattachments")

}

func TestAdmitResourceSlice(t *testing.T) {
	apiResource := resourceapi.SchemeGroupVersion.WithResource("resourceslices")
	nodename := "mynode"
	mynode := &user.DefaultInfo{Name: "system:node:" + nodename, Groups: []string{"system:nodes"}}
	err := "can only create ResourceSlice with the same NodeName as the requesting node"

	sliceNode := &resourceapi.ResourceSlice{
		ObjectMeta: metav1.ObjectMeta{
			Name: "something",

}

using ResourceOp = std::pair<int, XlaResourceOpKind>;

string ResourceOpToString(const ResourceOp& resource_op) {
  return absl::StrCat(
      resource_op.first, ": ",
      XlaResourceOpInfo::XlaResourceOpKindToString(resource_op.second));
}

// A copy-on-write set used to store the set of ResourceOps reaching a node in a
// TensorFlow graph.
//

							Requests: api.ResourceList{api.ResourceCPU: resource.MustParse("1m")},
							Limits:   api.ResourceList{api.ResourceCPU: resource.MustParse("2m")},
						},
					}, {
						Name: "bar",
						Resources: api.ResourceRequirements{
							Requests: api.ResourceList{api.ResourceCPU: resource.MustParse("1m")},
							Limits:   api.ResourceList{api.ResourceCPU: resource.MustParse("2m")},
						},
					}},
				},