allErrs = append(allErrs, metav1validation.ValidateLabelSelector(capacity.NodeTopology, labelSelectorValidationOptions, field.NewPath("nodeTopology"))...)
	for _, msg := range apivalidation.ValidateClassName(capacity.StorageClassName, false) {
		allErrs = append(allErrs, field.Invalid(field.NewPath("storageClassName"), capacity.StorageClassName, msg))
	}
	if capacity.Capacity != nil {

				Name:   "user",
				Groups: []string{user.AllUnauthenticated, "some-group"},
			},
		},
	}

	for _, test := range tests {
		capacity := make([]string, 0, 1024)
		user := test.inputUser
		user.Groups = append(capacity, user.Groups...) // make sure there is capacity in the groups array to trigger potential mutation
		response := &authenticator.Response{User: user}
		orig := toJson(response)

				Status:     v1.NodeStatus{Capacity: makeResources(10, 20, 32, 0, 0, 0), Allocatable: makeAllocatableResources(10, 20, 32, 0, 0, 0)},
			},
			reasons: []PredicateFailureReason{
				&InsufficientResourceError{ResourceName: v1.ResourceCPU, Requested: 8, Used: 5, Capacity: 10},
				&InsufficientResourceError{ResourceName: v1.ResourceMemory, Requested: 10, Used: 19, Capacity: 20},
			},

			capacity: func() *storage.CSIStorageCapacity {
				capacity := goodCapacity
				capacity.StorageClassName = invalidName
				return &capacity
			}(),
		},
		"good-capacity-value": {
			capacity: func() *storage.CSIStorageCapacity {
				capacity := goodCapacity
				capacity.Capacity = resource.NewQuantity(1, resource.BinarySI)
				return &capacity
			}(),
		},
		"bad-capacity-value": {

	Put(K, V)
	Len() int
	Iterate(func(Pair[K, V]) bool)
}

type HashMap[K comparable, V any] struct {
	m map[K]V
}

func NewHashMap[K comparable, V any](capacity int) HashMap[K, V] {
	var m map[K]V
	if capacity >= 1 {
		m = make(map[K]V, capacity)
	} else {
		m = map[K]V{}
	}

	return HashMap[K, V]{m: m}
}

func (m HashMap[K, V]) Put(k K, v V) {
	m.m[k] = v
}

//
// # The sponge construction
//
// A sponge builds a pseudo-random function from a public pseudo-random
// permutation, by applying the permutation to a state of "rate + capacity"
// bytes, but hiding "capacity" of the bytes.
//
// A sponge starts out with a zero state. To hash an input using a sponge, up
// to "rate" bytes of the input are XORed into the sponge's state. The sponge

     */
    public CaseInsensitiveMap() {
    }

    /**
     * {@link CaseInsensitiveMap}を作成します。
     *
     * @param capacity
     *            初期容量
     */
    public CaseInsensitiveMap(final int capacity) {
        super(capacity);
    }

    /**
     * キーが含まれているかどうかを返します。
     *
     * @param key
     *            キー
     * @return キーが含まれているかどうか
     */

type allocator struct {
	name     string // name for alloc/free functions
	typ      string // the type they return/accept
	mak      string // code to make a new object (takes power-of-2 size as fmt arg)
	capacity string // code to calculate the capacity of an object. Should always report a power of 2.
	resize   string // code to shrink to sub-power-of-two size (takes size as fmt arg)
	clear    string // code for clearing object before putting it on the free list

			Help:           "Total number of watch cache capacity decrease events broken by resource type.",
			StabilityLevel: compbasemetrics.ALPHA,
		},
		[]string{"resource"},
	)

	WatchCacheCapacity = compbasemetrics.NewGaugeVec(
		&compbasemetrics.GaugeOpts{
			Subsystem:      subsystem,
			Name:           "capacity",
			Help:           "Total capacity of watch cache broken by resource type.",

	AccessModes                      []v1.PersistentVolumeAccessMode                    `json:"accessModes,omitempty"`
	Capacity                         *v1.ResourceList                                   `json:"capacity,omitempty"`
	Conditions                       []PersistentVolumeClaimConditionApplyConfiguration `json:"conditions,omitempty"`