} else {
                return null;
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public Collection<Deployment> getRunningDeployments() {
        lock.lock();
        try {
            List<Deployment> runningDeployments = new ArrayList<>();
            for (RegisteredDeployment deployment : deployments.values()) {

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  resourceVersion: "99"
  labels:
    name: nginx
spec:
  selector:
    matchLabels:
      name: nginx2
  replicas: 3
  template:
    metadata:
      labels:
        name: nginx2
    spec:
      containers:
      - name: nginx
        image: registry.k8s.io/nginx:test-cmd
        ports:

		if resource.Resource == "deployments" {
			// co-locate deployments in all API groups
			return "/deployments"
		}
		return ""
	})
	mapper.RegisterKindFor(gvr("extensions", "v1beta1", "deployments"), "", gvk("extensions", "v1beta1", "Deployment"))
	mapper.RegisterKindFor(gvr("apps", "v1", "deployments"), "", gvk("apps", "v1", "Deployment"))

---
apiVersion: v1
kind: Namespace
metadata:
  name: bookinfo2
  labels:
    istio-injection: "enabled"
spec: {}
---
# Deployment should not generate a warning: although two services using that deployment
# using the same port, they are in different namespaces.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: conflicting-ports
  namespace: bookinfo
  labels:
    app: conflicting-ports
    version: v1
spec:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: calico-typha-horizontal-autoscaler
  namespace: kube-system
  labels:
    k8s-app: calico-typha-autoscaler
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: calico-typha-autoscaler
  template:
    metadata:
      labels:
        k8s-app: calico-typha-autoscaler
    spec:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deploy-con-sec-uid
  labels:
    app: helloworld
    version: v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloworld
      version: v1
  template:
    metadata:
      labels:
        app: helloworld
        version: v1
    spec:
      securityContext:
        runAsUser: 1337
      containers:
      - name: helloworld

apiVersion: apps/v1
kind: Deployment
metadata:
  name: external-forward-proxy
spec:
  replicas: 1
  selector:
    matchLabels:
      app: external-forward-proxy
  template:
    metadata:
      labels:
        app: external-forward-proxy
    spec:
      securityContext:
        runAsUser: 65534
        runAsGroup: 65534
        fsGroup: 65534
      containers:
      - name: external-forward-proxy

			testFn(ctx, svc)
		})
	}
}

// nDestinations splits the given deployments into subsets of size n. A deployment may be present in multiple subsets to
// ensure every deployment is included.
func nDestinations(ctx framework.TestContext, n int, deployments echo.Services) (out []echo.Services) {
	nDests := len(deployments)
	if nDests < n {

	logger.V(4).Info("Started syncing deployment", "deployment", klog.KRef(namespace, name), "startTime", startTime)
	defer func() {
		logger.V(4).Info("Finished syncing deployment", "deployment", klog.KRef(namespace, name), "duration", time.Since(startTime))
	}()

	deployment, err := dc.dLister.Deployments(namespace).Get(name)
	if errors.IsNotFound(err) {

	deploymentsClient := client.AppsV1().Deployments(metav1.NamespaceSystem)
	deployments, err := deploymentsClient.List(context.TODO(), metav1.ListOptions{LabelSelector: "k8s-app=kube-dns"})
	if err != nil {
		return "", errors.Wrap(err, "couldn't retrieve DNS addon deployments")
	}

	switch len(deployments.Items) {
	case 0:
		return "", nil
	case 1: