listeners = append(listeners, lb.virtualOutboundListener)
	}
	listeners = append(listeners, lb.inboundListeners...)

	log.Debugf("Build %d listeners for node %s including %d outbound, %d http proxy, "+
		"%d virtual outbound",
		nListener,
		lb.node.ID,
		nOutbound,
		nHTTPProxy,
		nVirtual,
	)
	return listeners
}

		waypointServices.orderedServices = model.SortServicesByCreationTime(unorderedServices)
	}
	return workloads, waypointServices
}

// filterWaypointOutboundServices is used to determine the set of outbound clusters we need to build for waypoints.
// Waypoints typically only have inbound clusters, except in cases where we have a route from
// a service owned by the waypoint to a service not owned by the waypoint.
// It looks at:

		}
		name := fmt.Sprintf("%s.%s", wl.Info.Name, wl.Info.Namespace)
		if filter.Direction != "outbound" {
			for _, c := range wl.Connections.Inbound {
				fmt.Fprintf(w, "%v\tInbound\t%v\t%v\t%v\n", name, lookupIP(c.ActualDst), lookupIP(c.Src), c.OriginalDst)
			}
		}
		if filter.Direction != "inbound" {
			for _, c := range wl.Connections.Outbound {

					},
				},
			},
			expectedSubsetClusters: []*cluster.Cluster{
				{
					Name:                 "outbound|8080|foobar|foo.default.svc.cluster.local",
					ClusterDiscoveryType: &cluster.Cluster_Type{Type: cluster.Cluster_EDS},
					EdsClusterConfig: &cluster.Cluster_EdsClusterConfig{
						ServiceName: "outbound|8080|foobar|foo.default.svc.cluster.local",
					},
				},
			},
		},
		{

          ignoreCase: true
        - ignoreCase: true
          prefix: x-prefix-
        - ignoreCase: true
          suffix: -suffix
    pathPrefix: /check
    serverUri:
      cluster: outbound|9000||my-custom-ext-authz.foo.svc.cluster.local
      timeout: 10s
      uri: http://my-custom-ext-authz.foo.svc.cluster.local
  statusOnError:
    code: Forbidden
  transportApiVersion: V3
  withRequestBody:

        ],
        "routes": [
         {
          "match": {
           "prefix": "/get",
           "case_sensitive": true
          },
          "route": {
           "cluster": "outbound|8000||httpbin.default.svc.cluster.local",
           "timeout": "0s",
           "retry_policy": {
            "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",

          ignoreCase: true
        - ignoreCase: true
          prefix: x-prefix-
        - ignoreCase: true
          suffix: -suffix
    pathPrefix: /check
    serverUri:
      cluster: outbound|9000||my-custom-ext-authz.foo.svc.cluster.local
      timeout: 10s
      uri: http://my-custom-ext-authz.foo.svc.cluster.local
  statusOnError:
    code: Forbidden
  transportApiVersion: V3
  withRequestBody:

		}
		if got[0] != clusterName {
			t.Fatalf("expected cluster %v got %v", clusterName, got[0])
		}
	}

	cluster1 := "outbound|80||local.default.svc.cluster.local"
	sendEDSReqAndVerify(cluster1)
	cluster2 := "outbound|80||hello.default.svc.cluster.local"
	sendEDSReqAndVerify(cluster2)
}

// nolint: lll
func TestAdsPushScoping(t *testing.T) {

        ],
        "routes": [
         {
          "match": {
           "case_sensitive": true,
           "path_separated_prefix": "/get"
          },
          "route": {
           "cluster": "outbound|8000||httpbin.default.svc.cluster.local",
           "timeout": "0s",
           "retry_policy": {
            "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",

	InboundCapture          = Command{"InboundCapture", "redirect inbound request to proxy"}
	KubevirtCommand         = Command{"KubevirtCommand", "Kubevirt outbound redirect"}
	ExcludeInterfaceCommand = Command{"ExcludeInterfaceCommand", "Excluded interface"}
	UndefinedCommand        = Command{"UndefinedCommand", ""}
)

var IDToCommand = map[string]Command{