input: svcTestCase{
			svc: svctest.MakeService("foo", svctest.SetTypeExternalName),
		},
		output: svctest.MakeService("foo", svctest.SetTypeExternalName),
		expect: true,
	}, {
		name: "ClusterIPs_unspecified",
		input: svcTestCase{
			svc:              svctest.MakeService("foo", svctest.SetTypeClusterIP),
			expectClusterIPs: true,
		},

	HelloService = MakeService(ServiceArgs{
		Hostname:        "hello.default.svc.cluster.local",
		Address:         "10.1.0.0",
		ServiceAccounts: []string{},
		ClusterID:       "cluster-1",
	})

	// ReplicatedFooServiceName is a service replicated in all clusters.
	ReplicatedFooServiceName = host.Name("foo.default.svc.cluster.local")
	ReplicatedFooServiceV1   = MakeService(ServiceArgs{

func TestMakeIP(t *testing.T) {
	HelloService := MakeService(ServiceArgs{
		Hostname:        "hello.default.svc.cluster.local",
		Address:         "10.1.0.0",
		ServiceAccounts: []string{},
		ClusterID:       "cluster-1",
	})
	HelloInstanceV0 := MakeIP(HelloService, 0)

	if HelloInstanceV0 != "10.1.1.0" {
		t.Fatalf("MakeIP() can not handle ip4 address.")
	}

	HelloService1 := MakeService(ServiceArgs{

				makeService("tcp1.com", "multiAddrInternal", "2.2.2.0/16",
					map[string]int{"tcp-444": 444}, false, model.Passthrough),
				makeService("tcp2.com", "multiAddrInternal", "1.1.1.0/16",
					map[string]int{"tcp-444": 444}, false, model.Passthrough),
				makeService("tcp2.com", "multiAddrInternal", "2.2.2.0/16",
					map[string]int{"tcp-444": 444}, false, model.Passthrough),
			},
		},
	}

		s := xds.NewFakeDiscoveryServer(t, xds.FakeOptions{})
		makeService(t, s.KubeClient().Kube(), service)
		makeIstioObject(t, s.Store(), workloadEntry)
		expectEndpoints(t, s, "outbound|80||service.namespace.svc.cluster.local", []string{"2.3.4.5:80"}, nil)

		newSvc := service.DeepCopy()
		newSvc.Spec.Ports[0].Port = 8080
		makeService(t, s.KubeClient().Kube(), newSvc)

type Tweak func(*api.Service)

// MakeService helps construct Service objects (which pass API validation) more
// legibly and tersely than a Go struct definition.  By default this produces
// a ClusterIP service with a single port and a trivial selector.  The caller
// can pass any number of tweak functions to further modify the result.
func MakeService(name string, tweaks ...Tweak) *api.Service {

			Labels:          map[string]string{"version": fmt.Sprintf("v%d", version)},
			Locality:        locality,
		},
		Service:     service,
		ServicePort: port,
	}
}

// MakeService creates a memory service
func MakeService(args ServiceArgs) *model.Service {
	return &model.Service{
		CreationTime: time.Now(),
		Hostname:     args.Hostname,
		ClusterVIPs: model.AddressMap{

			pod:             makePod(v1.PodRunning, true, false),
			service:         makeService(false),
			expectedReady:   1,
			expectedUnready: 0,
		},
		{
			name:            "pod running phase being deleted",
			pod:             makePod(v1.PodRunning, true, true),
			service:         makeService(false),
			expectedReady:   0,
			expectedUnready: 0,
		},
		{

	store := serviceStore{
		servicesBySE: map[types.NamespacedName][]*model.Service{},
	}

	expectedServices := []*model.Service{
		makeService("*.istio.io", "httpDNSRR", constants.UnspecifiedIP, map[string]int{"http-port": 80, "http-alt-port": 8080}, true, model.DNSRoundRobinLB),
		makeService("*.istio.io", "httpDNSRR", constants.UnspecifiedIP, map[string]int{"http-port": 80, "http-alt-port": 8080}, true, model.DNSLB),
	}

			Gateways: gws,
		})
	}

	svcLabels := map[string]string{
		"version": "v1.1",
	}

	// Explicit test service, in the v2 memory registry. Similar with mock.MakeService,
	// but easier to read.
	memRegistry.AddService(&model.Service{
		Hostname:       "service5.default.svc.cluster.local",
		DefaultAddress: "10.10.0.1",
		Ports: []*model.Port{
			{
				Name:     "http-main",