go func() {
			defer wg.Done()
			quotas, err := accessor.GetQuotas(testNamespace1)
			if err != nil {
				t.Errorf("unexpected error: %v", err)
			}
			if len(quotas) != len(resourceQuotas) {
				t.Errorf("Expected %d resource quotas, got %d", len(resourceQuotas), len(quotas))
			}
			for _, q := range quotas {
				if q.Namespace != testNamespace1 {

//     and the running quota doesn't change.  If it did fit, check to see if any quota was changed.  If there was no quota change
//     mark the waiter as succeeded.  If some quota did change, update the running quotas
//  2. If no running quota was changed, return now since no updates are needed.

// mechanism supported by Linux
type LinuxVolumeQuotaApplier interface {
	// GetQuotaOnDir gets the quota ID (if any) that applies to
	// this directory
	GetQuotaOnDir(path string) (QuotaID, error)

	// SetQuotaOnDir applies the specified quota ID to a directory.
	// Negative value for bytes means that a non-enforcing quota
	// should be applied (perhaps by setting a quota too large to
	// be hit)

	// never have been one, and we have no way to know otherwise
	klog.V(3).Infof("clearQuotaOnDir fails %v", err)
	return nil
}

// SupportsQuotas -- Does the path support quotas
// Cache the applier for paths that support quotas.  For paths that don't,
// don't cache the result because nothing will clean it up.
// However, do cache the device->applier map; the number of devices
// is bounded.

}

// GetConsumption returns the consumption in bytes if available via quotas
func (v linuxVolumeQuotaApplier) GetConsumption(_ string, id QuotaID) (int64, error) {
	return getQuantity(v.mountpoint, id, "-b", 1024, v.allowEmptyOutput)
}

// GetInodes returns the inodes in use if available via quotas
func (v linuxVolumeQuotaApplier) GetInodes(_ string, id QuotaID) (int64, error) {

      port:
        number: 9080
---
apiVersion: config.istio.io/v1alpha2
kind: QuotaSpec
metadata:
  name: request-count
  namespace: istio-system
spec:
  rules:
  - quotas:
    - charge: 1

		return quota
	}
	cachedQuota := uncastCachedQuota.(*corev1.ResourceQuota)

	if etcdVersioner.CompareResourceVersion(quota, cachedQuota) >= 0 {
		e.updatedQuotas.Remove(key)
		return quota
	}
	return cachedQuota
}

func (e *quotaAccessor) GetQuotas(namespace string) ([]corev1.ResourceQuota, error) {
	// determine if there are any quotas in this namespace
	// if there are no quotas, we don't need to do anything

)

// Interface -- quota interface
type Interface interface {
	// GetQuotaOnDir gets the quota ID (if any) that applies to
	// this directory
	GetQuotaOnDir(m mount.Interface, path string) (common.QuotaID, error)

	// Does the path provided support quotas, and if so, what types
	SupportsQuotas(m mount.Interface, path string) (bool, error)
	// Assign a quota (picked by the quota mechanism) to a path,
	// and return it.

	"k8s.io/kubernetes/pkg/registry/core/resourcequota"
	"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
)

// REST implements a RESTStorage for resource quotas.
type REST struct {
	*genericregistry.Store
}

// NewREST returns a RESTStorage object that will work against resource quotas.
func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST, error) {
	store := &genericregistry.Store{

				// We are only interested in observing updates to quota.spec to drive updates to quota.status.
				// We ignore all updates to quota.Status because they are all driven by this controller.
				// IMPORTANT:
				// We do not use this function to queue up a full quota recalculation.  To do so, would require
				// us to enqueue all quota.Status updates, and since quota.Status updates involve additional queries