if r := cmp.Compare(a.Namespace, b.Namespace); r != 0 {
			return r
		}
		if r := cmp.Compare(a.Name, b.Name); r != 0 {
			return r
		}
		return cmp.Compare(a.Hostname, b.Hostname)
	})
	fmt.Fprintln(w, "NAMESPACE\tSERVICE NAME\tSERVICE VIP\tWAYPOINT")

	for _, svc := range svcs {
		var ip string
		if len(svc.Addresses) > 0 {
			_, ip, _ = strings.Cut(svc.Addresses[0], "/")
		}

        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "subsets": [
    {
      "addresses": [
        {
          "ip": "ipValue",
          "hostname": "hostnameValue",
          "nodeName": "nodeNameValue",
          "targetRef": {
            "kind": "kindValue",
            "namespace": "namespaceValue",
            "name": "nameValue",

  uid: uidValue
subsets:
- addresses:
  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:
      apiVersion: apiVersionValue
      fieldPath: fieldPathValue
      kind: kindValue
      name: nameValue
      namespace: namespaceValue
      resourceVersion: resourceVersionValue
      uid: uidValue
  notReadyAddresses:
  - hostname: hostnameValue
    ip: ipValue

	Node                  string            `json:"node"`
	Network               string            `json:"network,omitempty"`
	Status                string            `json:"status"`
	Hostname              string            `json:"hostname"`
	ApplicationTunnel     ApplicationTunnel `json:"applicationTunnel,omitempty"`
	AuthorizationPolicies []string          `json:"authorizationPolicies,omitempty"`
}

type ApplicationTunnel struct {

	clusterName := model.BuildSubsetKey(model.TrafficDirectionOutbound, "", service.Hostname, port.Port)
	dr := proxy.SidecarScope.DestinationRule(model.TrafficDirectionOutbound, proxy, service.Hostname)
	var eb *endpoints.EndpointBuilder
	if service.Resolution == model.DNSLB || service.Resolution == model.DNSRoundRobinLB {
		eb = endpoints.NewCDSEndpointBuilder(

		}
	}
	return clusters
}

// `inbound-vip||hostname|port`. EDS routing to the internal listener for each pod in the VIP.
func (cb *ClusterBuilder) buildWaypointInboundVIPCluster(proxy *model.Proxy, svc *model.Service, port model.Port, subset string) *clusterWrapper {
	clusterName := model.BuildSubsetKey(model.TrafficDirectionInboundVIP, subset, svc.Hostname, port.Port)

	discoveryType := convertResolution(cb.proxyType, svc)

	if err != nil {
		return result, fmt.Errorf("was provided in an invalid format")
	}

	parsedHostname := parsedWebhookURL.Hostname()
	if ip := net.ParseIP(parsedHostname); ip != nil {
		result.ip = ip
		return result, nil
	}

	result.hostName = parsedHostname

	return result, nil

		TLSSettings: &common.TLSSettings{
			RootCert:   mustReadCert("root-cert.pem"),
			ClientCert: mustReadCert("cert-chain.pem"),
			Key:        mustReadCert("key.pem"),
			// Override hostname to match the SAN in the cert we are using
			Hostname: "server.default.svc",
		},
		// Do not inject, as we are testing non-Istio TLS here
		Subsets: []echo.SubsetConfig{{
			Version:     "v1",

	}
	klog.Warningf("%s variable unset - falling back to etcd-%s variable", etcdHostnameEnv, hostnameEnv)
	if hostname, err := lookupEnv(hostnameEnv); err == nil {
		return fmt.Sprintf("etcd-%s", hostname), nil
	}
	return "", fmt.Errorf("defaulting --name failed due to all ETCD_NAME, ETCD_HOSTNAME and HOSTNAME unset")
}

func (opts *migrateOpts) validateAndDefault() error {
	var err error

	if opts.name == "" {

			name:      "dns-round-robin-2",
		},
	}
	store.addInstances(cpKey, instances)

	assert.Equal(t, store.getByKey(instancesKey{
		hostname:  "example.com",
		namespace: "dns",
	}), expected)
	assert.Equal(t, store.getByKey(instancesKey{
		hostname:  "example.com",
		namespace: otherNs.Namespace,
	}), otherNsExpected)