in: &networking.VirtualService{
				Hosts:    []string{"foo.bar"},
				Gateways: []string{"test-gateway"},
				Http: []*networking.HTTPRoute{{
					Delegate: &networking.Delegate{
						Name:      "test",
						Namespace: "test",
					},
				}},
			},
			valid: true,
		},
		{
			name: "root applies to sidecar with delegate",
			in: &networking.VirtualService{
				Hosts: []string{"foo.bar"},

		return cluster
	}
	vhosts := []string{}
	for _, vh := range route.GetVirtualHosts() {
		if describeDomains(vh) == "" {
			vhosts = append(vhosts, describeRoutes(vh))
		} else {
			vhosts = append(vhosts, fmt.Sprintf("%s %s", describeDomains(vh), describeRoutes(vh)))
		}
	}
	return fmt.Sprintf("Inline Route: %s", strings.Join(vhosts, "; "))
}

			ingressConfigTemplate := `
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: %s
spec:
  ingressClassName: %s
  tls:
  - hosts: ["foo.example.com"]
    secretName: k8s-ingress-secret-foo
  - hosts: ["bar.example.com"]
    secretName: k8s-ingress-secret-bar
  rules:
  - http:
      paths:
      - backend:
          service:
            name: b
            port:

    const val MAX_RESPONSE_SIZE = 64 * 1024

    private fun buildBootstrapClient(builder: Builder): Dns {
      val hosts = builder.bootstrapDnsHosts

      return if (hosts != null) {
        BootstrapDns(builder.url!!.host, hosts)
      } else {
        builder.systemDns
      }
    }

    internal fun isPrivateHost(host: String): Boolean {

	// Deprecated. Was added for experimentation only.
	//
	// Deprecated: Marked as deprecated in dns/proto/nds.proto.
	AltHosts []string `protobuf:"bytes,5,rep,name=alt_hosts,json=altHosts,proto3" json:"alt_hosts,omitempty"`
}

func (x *NameTable_NameInfo) Reset() {
	*x = NameTable_NameInfo{}
	if protoimpl.UnsafeEnabled {
		mi := &file_dns_proto_nds_proto_msgTypes[1]

			istioConfigs: []runtime.Object{
				&v1alpha3.VirtualService{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "bookinfo",
						Namespace: "default",
					},
					Spec: v1alpha32.VirtualService{
						Hosts:    []string{"productpage"},
						Gateways: []string{"fake-gw"},
						Http: []*v1alpha32.HTTPRoute{
							{
								Match: []*v1alpha32.HTTPMatchRequest{
									{
										Uri: &v1alpha32.StringMatch{

			},
			container: v1.Container{
				Name: "container1",
				VolumeMounts: []v1.VolumeMount{
					{
						MountPath:        "/etc/hosts",
						Name:             "disk",
						ReadOnly:         false,
						MountPropagation: &propagationHostToContainer,
					},
					{
						MountPath:        "/mnt/path3",
						Name:             "disk",

  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "*"
  - port:
      number: 31400
      name: tcp
      protocol: TCP
    hosts:
    - "*"
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: echo
spec:
  hosts:
  - "*"
  gateways:
  - echo-gateway
  http:
  - match:
    - uri:

  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "some-external-site.com"
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: route-via-egressgateway
spec:
  hosts:
    - "some-external-site.com"
  gateways:
  - istio-egressgateway
  - mesh
  http:
    - match:
      - gateways:

	// Set up ground truth hostname values
	hosts := map[host.Name]bool{
		mock.HelloService.Hostname: false,
		mock.WorldService.Hostname: false,
	}

	count := 0
	// Compare return value to ground truth
	for _, svc := range services {
		if counted, existed := hosts[svc.Hostname]; existed && !counted {
			count++
			hosts[svc.Hostname] = true
		}
	}

	if count != len(hosts) {