controller: true
    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
spec:
  hard:
    hardKey: "0"
  scopeSelector:
    matchExpressions:
    - operator: operatorValue
      scopeName: scopeNameValue
      values:
      - valuesValue
  scopes:
  - scopesValue
status:
  hard:
    hardKey: "0"
  used:

func CalculateUsage(namespaceName string, scopes []corev1.ResourceQuotaScope, hardLimits corev1.ResourceList, registry Registry, scopeSelector *corev1.ScopeSelector) (corev1.ResourceList, error) {
	// find the intersection between the hard resources on the quota
	// and the resources this controller can track to know what we can
	// look to measure updated usage stats for

		selectors = append(selectors, corev1.ScopedResourceSelectorRequirement{
			ScopeName: scope,
			Operator:  corev1.ScopeSelectorOpExists})
	}
	if quota.Spec.ScopeSelector != nil {
		selectors = append(selectors, quota.Spec.ScopeSelector.MatchExpressions...)
	}
	return selectors
}

// CalculateUsageStats is a utility function that knows how to calculate aggregate usage.

			quota: &corev1.ResourceQuota{
				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
				Spec: corev1.ResourceQuotaSpec{
					ScopeSelector: &corev1.ScopeSelector{
						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
							{
								ScopeName: corev1.ResourceQuotaScopePriorityClass,
								Operator:  corev1.ScopeSelectorOpExists},
						},

apiVersion: v1
kind: ResourceQuota
metadata:
  name: gcp-critical-pods
  namespace: kube-system
  labels:
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  hard:
    pods: "1000000000"
  scopeSelector:
    matchExpressions:
    - operator : In
      scopeName: PriorityClass

        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "spec": {
    "hard": {
      "hardKey": "0"
    },
    "scopes": [
      "scopesValue"
    ],
    "scopeSelector": {
      "matchExpressions": [
        {
          "scopeName": "scopeNameValue",
          "operator": "operatorValue",
          "values": [
            "valuesValue"
          ]
        }
      ]

	Namespace string
	// Scopes that must match counted objects
	Scopes []corev1.ResourceQuotaScope
	// Resources are the set of resources to include in the measurement
	Resources     []corev1.ResourceName
	ScopeSelector *corev1.ScopeSelector
}

// UsageStats is result of measuring observed resource use in the system
type UsageStats struct {
	// Used maps resource to quantity used
	Used corev1.ResourceList
}

	tests := []struct {
		name               string
		objs               []runtime.Object
		quotaScopes        []corev1.ResourceQuotaScope
		quotaScopeSelector *corev1.ScopeSelector
		want               corev1.ResourceList
	}{
		{
			name: "nil case",
		},
		{
			name: "all pods in running state",
			objs: []runtime.Object{
				makePod("p1", "", cpu1, api.PodRunning),

	}
	if err := s.AddGeneratedConversionFunc((*v1.ScopeSelector)(nil), (*core.ScopeSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ScopeSelector_To_core_ScopeSelector(a.(*v1.ScopeSelector), b.(*core.ScopeSelector), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*core.ScopeSelector)(nil), (*v1.ScopeSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {

		}
	}
	if in.Scopes != nil {
		in, out := &in.Scopes, &out.Scopes
		*out = make([]ResourceQuotaScope, len(*in))
		copy(*out, *in)
	}
	if in.ScopeSelector != nil {
		in, out := &in.ScopeSelector, &out.ScopeSelector
		*out = new(ScopeSelector)
		(*in).DeepCopyInto(*out)
	}
	return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceQuotaSpec.