for _, handler := range admissionHandler {
		if !handler.Handles(a.GetOperation()) {
			continue
		}
		if validator, ok := handler.(ValidationInterface); ok {
			err := validator.Validate(ctx, a, o)
			if err != nil {
				return err
			}
		}
	}
	return nil
}

// Handles will return true if any of the handlers handles the given operation

type ReadyFunc func() bool

// Handler is a base for admission control handlers that
// support a predefined set of operations
type Handler struct {
	operations sets.String
	readyFunc  ReadyFunc
}

// Handles returns true for methods that this handler supports
func (h *Handler) Handles(operation Operation) bool {
	return h.operations.Has(string(operation))

  TensorHandle* packed_handle;
  TF_RETURN_IF_ERROR(TensorHandle::CreatePackedHandle(
      std::move(handles), eager_ctx, &packed_handle));
  // The call to `CreatePackedHandle` incremented the handles' reference count,
  // which we must now decrement to make the packed handle the owner of those
  // handles. We can't loop through the `handles` vector because it was
  // `std::move`d in the call above.

	for tcName, tc := range testCases {
		var handler Interface = fakeHandler{tc.admit, tc.admitAnnotations, tc.validate, tc.validateAnnotations, tc.handles}
		ctx := audit.WithAuditContext(context.Background())
		ac := audit.AuditContextFrom(ctx)
		ae := &ac.Event
		ae.Level = auditinternal.LevelMetadata
		auditHandler := WithAudit(handler)
		a := attributes()

		}
	}
	return nil
}

// Handles will return true if any of the admission andler handlers handle the given operation.
func (r *reinvoker) Handles(operation admission.Operation) bool {
	r.t.Helper()
	return r.admission.Handles(operation)

	if validator, ok := r.admissionChain.(ValidationInterface); ok {
		return validator.Validate(ctx, a, o)
	}
	return nil
}

// Handles will return true if any of the admission chain handlers handle the given operation.
func (r *reinvoker) Handles(operation Operation) bool {
	return r.admissionChain.Handles(operation)

//
// The method panics if the handle is invalid.
func (h Handle) Value() any {
	v, ok := handles.Load(uintptr(h))
	if !ok {
		panic("runtime/cgo: misuse of an invalid Handle")
	}
	return v
}

// Delete invalidates a handle. This method should only be called once
// the program no longer needs to pass the handle to C and the C code
// no longer has a copy of the handle value.
//

}

func BenchmarkMakeManyMany(b *testing.B) {
	benchmarkMake(b, testDataLarge[:])
}

func benchmarkMake(b *testing.B, testData []string) {
	handles := make([]Handle[string], 0, len(testData))
	for i := range testData {
		handles = append(handles, Make(testData[i]))
	}

	b.ReportAllocs()
	b.ResetTimer()

	b.RunParallel(func(pb *testing.PB) {
		i := 0
		for pb.Next() {
			_ = Make(testData[i])

)

func TestQueue(t *testing.T) {
	handles := atomic.NewInt32(0)
	q := NewQueue("custom", WithReconciler(func(key types.NamespacedName) error {
		handles.Inc()
		return nil
	}))
	q.Add(types.NamespacedName{Name: "something"})
	stop := make(chan struct{})
	go q.Run(stop)
	retry.UntilOrFail(t, q.HasSynced, retry.Delay(time.Microsecond))
	assert.Equal(t, handles.Load(), 1)
	q.Add(types.NamespacedName{Name: "something else"})

import java.lang.annotation.Annotation;

/**
 * Handles validation, dependency handling, and skipping for a property marked with a given annotation.
 *
 * <p>Each handler must be registered as a global service.</p>
 */
@ServiceScope(Scope.Global.class)
public interface PropertyAnnotationHandler {
    /**
     * The annotation type which this handler is responsible for.
     */