kind: Gateway
metadata:
  name: gateway-addresses
spec:
  gatewayClassName: acme-lb
  addresses:
  - value: 1200:0000:AB00:1234:0000:2552:7777:1313
  - value: 21DA:D3:0:2F3B:2AA:FF:FE28:9C5A
  - value: "2001:db8:3c4d:15:0:d234:3eee::"
  - value: "1234::"
  - value: "1.1.1.1"
  - value: "1.2.3.4"
  - value: "0.0.0.0"
  - value: "9.255.255.255"
  - value: "11.0.0.0"
  - type: IPAddress
    value: "255.255.255.255"

			}
			if tt.obj.Name != "" {
				opts.Configs = append(opts.Configs, tt.obj)
			}
			s := xds.NewFakeDiscoveryServer(t, opts)
			s.Connect(s.SetupProxy(&model.Proxy{IPAddresses: []string{"1.2.3.4"}}), nil, []string{v3.ClusterType})
			retry.UntilSuccessOrFail(t, func() error {
				clients := s.Discovery.AllClients()
				if len(clients) != 1 {

	m := model.AddressMap{
		Addresses: map[cluster.ID][]string{
			c1ID: c1Addresses,
			c2ID: c2Addresses,
		},
	}

	g.Expect(m.GetAddressesFor(c1ID)).To(Equal(c1Addresses))
	g.Expect(m.GetAddressesFor(c2ID)).To(Equal(c2Addresses))
}

func TestAddressMapSetAddressesFor(t *testing.T) {
	g := NewWithT(t)

	m := model.AddressMap{}
	m.SetAddressesFor(c1ID, c1Addresses)
	m.SetAddressesFor(c2ID, c2Addresses)

							// as when app access itself by pod ip will not flow through this listener.
							// Simultaneously, it will be duplicate with inbound listener.
							if instance.Address == node.IPAddresses[0] {
								continue
							}
							listenerOpts.bind.binds = []string{instance.Address}
							lb.buildSidecarOutboundListener(listenerOpts, listenerMap, virtualServices, actualWildcards)
						}
					} else {

import (
	"net"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

type Addresses interface {
	ServerAddressByClientCIDRs(net.IP) []metav1.ServerAddressByClientCIDR
}

// DefaultAddresses is a default implementation of Addresses that will work in most cases
type DefaultAddresses struct {
	// CIDRRules is a list of CIDRs and Addresses to use if a client is in the range
	CIDRRules []CIDRRule

    val dns = FakeDns()
    val ipAddresses = mutableListOf<InetAddress>()
    dns["android.com"] = ipAddresses
    client =
      client.newBuilder()
        .dns(dns)
        .build()
    server.enqueue(MockResponse())
    val request = Request(server.url("/").newBuilder().host("android.com").build())
    executeSynchronously(request).assertFailure("$dns returned no addresses for android.com")

		for k, v := range originalServices {
			if gotIPMap[v] != k {
				t.Errorf("ipaddress changed for service %s. expected: %s, got: %s", k, v, serviceIPMap[k])
			}
		}
		for k, v := range gotIPMap {
			if net.ParseIP(k) == nil {
				t.Errorf("invalid ipaddress for service %s. got: %s", v, k)
			}
		}
	}

	// Validate that IP addresses are allocated for original list of services.
	for k := range originalServices {

spec:
  hosts:
    - 'istio.io'
  addresses:
    - 10.0.0.1
  exportTo:
    - "."
  ports:
    - number: 443
      name: https
      protocol: HTTPS
  location: MESH_EXTERNAL
  resolution: DNS
---
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: service-entry-test-03 # Expected: validation error missing addresses and protocol
  namespace: default
spec:
  hosts:

apiVersion: networking.k8s.io/v1alpha1
kind: IPAddress
metadata:
  annotations:
    annotationsKey: annotationsValue
  creationTimestamp: "2008-01-01T01:01:01Z"
  deletionGracePeriodSeconds: 10
  deletionTimestamp: "2009-01-01T01:01:01Z"
  finalizers:
  - finalizersValue
  generateName: generateNameValue
  generation: 7
  labels:
    labelsKey: labelsValue
  managedFields:
  - apiVersion: apiVersionValue
    fieldsType: fieldsTypeValue

apiVersion: networking.k8s.io/v1alpha1
kind: IPAddress
metadata:
  annotations:
    annotationsKey: annotationsValue
  creationTimestamp: "2008-01-01T01:01:01Z"
  deletionGracePeriodSeconds: 10
  deletionTimestamp: "2009-01-01T01:01:01Z"
  finalizers:
  - finalizersValue
  generateName: generateNameValue
  generation: 7
  labels:
    labelsKey: labelsValue
  managedFields:
  - apiVersion: apiVersionValue
    fieldsType: fieldsTypeValue