}

	if err := DB.AutoMigrate(&Person{}, &Address{}); err != nil {
		t.Fatalf("Failed to migrate, got %v", err)
	}

	address1 := Address{Name: "address 1"}
	address2 := Address{Name: "address 2"}
	person := Person{Name: "person", Addresses: []Address{address1, address2}}
	DB.Create(&person)

	var addresses1 []Address

		equal  bool
		reason string
	}{
		{
			rsA: &RealServer{
				Address: netutils.ParseIPSloppy("10.20.30.40"),
				Port:    80,
			},
			rsB: &RealServer{
				Address: netutils.ParseIPSloppy("10.20.30.41"),
				Port:    80,
			},
			equal:  false,
			reason: "IPv4 address not equal",
		},
		{
			rsA: &RealServer{
				Address: netutils.ParseIPSloppy("2012::beef"),
				Port:    80,
			},

              "endpoint": {
                "address":{
                  "socket_address": {"address": "accesslog-service", "port_value": 15000}
                }
              }
            }]
          }]
        }
      }
      
    ],
    "listeners":[
      {
        "address": {
          "socket_address": {
            "protocol": "TCP",
            "address": "0.0.0.0",
            

            {
                "locality": {},
                "lbEndpoints": [
                    {
                        "endpoint": {
                            "address": {
                                "socketAddress": {
                                    "address": "127.0.0.1",
                                    "portValue": 15020
                                }
                            },

  - lbEndpoints:
    - endpoint:
        address:
          socketAddress:
            address: 10.244.0.8
            portValue: 53
        healthCheckConfig: {}
      healthStatus: HEALTHY
      loadBalancingWeight: 1
      metadata:
        filterMetadata:
          istio:
            workload: coredns;kube-system;;;Kubernetes
    - endpoint:
        address:
          socketAddress:

		},
		{
			name: "dual-stack node",
			addresses: []v1.NodeAddress{
				{Type: v1.NodeInternalIP, Address: "1.2.3.4"},
				{Type: v1.NodeExternalIP, Address: "4.3.2.1"},
				{Type: v1.NodeExternalIP, Address: "4.3.2.2"},
				{Type: v1.NodeInternalIP, Address: "a:b::c:d"},
				{Type: v1.NodeExternalIP, Address: "d:c::b:a"},
			},
			expectIPs: []net.IP{netutils.ParseIPSloppy("1.2.3.4"), netutils.ParseIPSloppy("a:b::c:d")},

{
    "0.0.0.0_7070": {
      "name": "0.0.0.0_7070",
      "address": {
        "Address": {
          "SocketAddress": {
            "address": "0.0.0.0",
            "PortSpecifier": {
              "PortValue": 7070
            }
          }
        }
      },
      "filter_chains": [
        {
          "filters": [
            {
              "name": "envoy.tcp_proxy",
              "ConfigType": {

        }

        private Map<Address, DaemonInfo> readInfosMap(Decoder decoder, List<Address> addresses) throws Exception {
            Map<Address, DaemonInfo> infosMap = new LinkedHashMap<Address, DaemonInfo>(addresses.size());
            DaemonInfo.Serializer daemonInfoSerializer = new DaemonInfo.Serializer(addresses);
            for (Address address : addresses) {
                infosMap.put(address, daemonInfoSerializer.read(decoder));

            "address": "{{ .localhost }}",
            {{ else }}
            "address": "{{ .wildcard }}",
            {{ end }}
            "port_value": {{ .envoy_prometheus_port }}
          }
        },
        {{- if .dual_stack }}
        "additionalAddresses": [
          {
            "address": {
              "socket_address": {
                "protocol": "TCP",

        "endpoints": [
          {
            "lb_endpoints": [
              {
                "endpoint": {
                  "address": {
                    "Address": {
                      "SocketAddress": {
                        "address": "127.0.0.1",
                        "PortSpecifier": {
                          "PortValue": 17070
                        }
                      }