&model.Port{
					Name:     "tcp-port-8081",
					Port:     8081,
					Protocol: protocol.TCP,
				},
			},
			MeshExternal: true,
			Resolution:   model.DNSLB,
		},
		{
			Hostname: kube.ServiceHostname("svc3", "nsA", defaultFakeDomainSuffix),
			Ports: model.PortList{
				&model.Port{
					Name:     "tcp-port-8082",
					Port:     8082,
					Protocol: protocol.TCP,
				},

			clusters: map[string][]string{
				"inbound|8080||": nil,
				"inbound|8081||": nil,
				"inbound|8082||": nil,
				"inbound|8083||": nil,
			},
			telemetry: map[string][]string{
				"inbound|8080||": {string(service.Hostname)},
				"inbound|8081||": {string(service.Hostname)},
				"inbound|8082||": {string(serviceAlt.Hostname)},
				"inbound|8083||": {string(serviceAlt.Hostname)},
			},
		},
		{

				},
			},
			Ports: []v1.EndpointPort{{Port: 8080, Protocol: "TCP"}},
		}},
	})
	endpoints.serviceStore.Add(&v1.Service{
		ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: ns},
		Spec: v1.ServiceSpec{
			Selector: map[string]string{"foo": "bar"},
			Ports:    []v1.ServicePort{{Port: 80, Protocol: "TCP", TargetPort: intstr.FromInt32(8080)}},
		},
	})
	pod0.ResourceVersion = "3"

    // four-per-em space
    assertThat(parse("http://h/\u2005").encodedPath).isEqualTo("/%E2%80%85")
    // six-per-em space
    assertThat(parse("http://h/\u2006").encodedPath).isEqualTo("/%E2%80%86")
    // figure space
    assertThat(parse("http://h/\u2007").encodedPath).isEqualTo("/%E2%80%87")
    // punctuation space
    assertThat(parse("http://h/\u2008").encodedPath).isEqualTo("/%E2%80%88")
    // thin space

				Address: "2.3.4.5",
				Labels:  labels,
				Ports: map[string]uint32{
					serviceEntry.Spec.(*networking.ServiceEntry).Ports[0].Name: 8080,
				},
			},
		})

		instances := []EndpointResponse{{
			Address: workloadEntry.Spec.(*networking.WorkloadEntry).Address,
			Port:    8080,
		}}
		expectServiceEndpoints(t, fx, expectedSvc, 80, instances)
	})

		buildServiceWithPort("test3.com", 8080, protocol.HTTP, tnow.Add(2*time.Second)),
	}
	servicesConflictWithVirtualListener := []*model.Service{
		buildServiceWithPort("test4.com", 15001, protocol.HTTP, tnow.Add(1*time.Second)),
		buildServiceWithPort("test5.com", 15006, protocol.TCP, tnow),
		buildServiceWithPort("test6.com", 8081, protocol.HTTP, tnow.Add(2*time.Second)),
	}

                                },
                                "exact_match_map": {
                                  "map": {
                                    "8080": {
                                      "action": {
                                        "name": "inbound-vip|8080||reviews12.default.svc.cluster.local-http",
                                        "typed_config": {

		// https://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
		{"2.2250738585072011e-308", 2.225073858507201e-308, Below},
		// https://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
		{"2.2250738585072012e-308", 2.2250738585072014e-308, Above},
	} {
		for i := 0; i < 2; i++ {
			// test both signs

                                                "socket_address": {
                                                    "address": "10.244.0.176",
                                                    "port_value": 8080
                                                }
                                            },
                                            "health_check_config": {}
                                        },

		{
			Port:     7442,
			Protocol: "HTTP",
			Name:     "http-tls",
		},
	}

	port803x = []*Port{
		{
			Port:     8031,
			Protocol: "TCP",
			Name:     "tcp-1",
		},
		{
			Port:     8032,
			Protocol: "TCP",
			Name:     "tcp-2",
		},
		{
			Port:     8033,
			Protocol: "TCP",
			Name:     "tcp-3",
		},
		{
			Port:     8034,
			Protocol: "TCP",
			Name:     "tcp-4",