ServerAddress: "ExternalAddress",
		},
	}
	internalAddressCIDRMap := []metav1.ServerAddressByClientCIDR{
		publicAddressCIDRMap[0],
		{
			ClientCIDR:    "10.0.0.0/24",
			ServerAddress: "serviceIP",
		},
	}
	internalIP := "10.0.0.1"
	publicIP := "1.1.1.1"
	testCases := []struct {
		Request     http.Request
		ExpectedMap []metav1.ServerAddressByClientCIDR
	}{
		{
			Request:     http.Request{},

)

var (
	serviceIP = "1.2.3.4"
	hostname  = "foo.bar.com"
	nodeIP    = "10.0.0.2"
)

var ingressService = &corev1.Service{
	ObjectMeta: metav1.ObjectMeta{
		Name:      "istio-ingress",
		Namespace: IngressNamespace,
	},
	Status: corev1.ServiceStatus{
		LoadBalancer: corev1.LoadBalancerStatus{
			Ingress: []corev1.LoadBalancerIngress{{
				IP: serviceIP,
			}},
		},
	},
}

	}
	return err
}

// getMasterServiceUpdateIfNeeded sets service attributes for the given apiserver service.
func getMasterServiceUpdateIfNeeded(svc *corev1.Service, servicePorts []corev1.ServicePort, serviceType corev1.ServiceType) (s *corev1.Service, updated bool) {
	// Determine if the service is in the format we expect
	// (servicePorts are present and service type matches)

	// Values to build the IP addresses used by discovery
	// The range of IPs to be assigned to services with type=ClusterIP or greater
	ServiceIPRange net.IPNet
	// The IP address for the GenericAPIServer service (must be inside ServiceIPRange)
	APIServerServiceIP net.IP

	// dual stack services, the range represents an alternative IP range for service IP
	// must be of different family than primary (ServiceIPRange)

---
apiVersion: v1
kind: Service
metadata:
  name: my-service2 # Skipped because it has an istio: label
  namespace: istio-system
  labels:
    istio: xxx
spec:
  selector:
    app: my-service2
  ports:
    - name: foo
      protocol: TCP
      port: 8080
      targetPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: my-service3 # Skipped because it's in a kube system namespace

		// the validation allows it
		if len(service.Spec.IPFamilies) < 2 {
			if *(service.Spec.IPFamilyPolicy) != api.IPFamilyPolicySingleStack {
				// add the alt ipfamily
				if service.Spec.IPFamilies[0] == api.IPv4Protocol {
					service.Spec.IPFamilies = append(service.Spec.IPFamilies, api.IPv6Protocol)
				} else {
					service.Spec.IPFamilies = append(service.Spec.IPFamilies, api.IPv4Protocol)
				}
			}

        final TestService service

        ServiceWithDependency(TestService service) {
            this.service = service
        }
    }

    private static class ServiceWithMultipleDependencies {
        final List<TestService> services

        ServiceWithMultipleDependencies(List<TestService> services) {
            this.services = services
        }
    }

			if sidecarConfig == nil {
				services := sidecarScope.EgressListeners[0].services
				if !reflect.DeepEqual(services, sidecarScope.services) {
					t.Errorf("services in default egress listener not equals sidecar scope services: %v",
						cmp.Diff(services, sidecarScope.services, cmpopts.IgnoreFields(AddressMap{}, "mutex")))
				}
			}

			for _, s1 := range sidecarScope.services {
				serviceFound = false

		{name: "dot service", services: []string{service3}},
		{name: "underscore service", services: []string{service4}},
		{name: "at service", services: []string{service5}},
		{name: "colon service", services: []string{service6}},
		{name: "invalid service new line", services: []string{invalid1}, wantErr: true},
		{name: "invalid service with dot", services: []string{invalid2}, wantErr: true},

           }]
         },
        "http2_protocol_options": {}
      },
      {
      "name": "service1",
      "type": "STRICT_DNS",
      "connect_timeout": {
        "seconds": 5,
        "nanos": 0
      },
      "lb_policy": "ROUND_ROBIN",
      "load_assignment": {
        "cluster_name": "service1",
        "endpoints": [{
          "lb_endpoints": [{
            "endpoint": {