}

  private fun assertRoute(
    route: Route,
    address: Address,
    proxy: Proxy,
    socketAddress: InetAddress,
    socketPort: Int,
  ) {
    assertThat(route.address).isEqualTo(address)
    assertThat(route.proxy).isEqualTo(proxy)
    assertThat(route.socketAddress.address).isEqualTo(socketAddress)
    assertThat(route.socketAddress.port).isEqualTo(socketPort)
  }

		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,
			},

		},
		{
			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")},

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

	}

	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

    private final Address address;
    private final DaemonContext context;
    private final byte[] token;
    private final Clock clock;

    private State state;
    private long lastBusy;

    public DaemonInfo(Address address, DaemonContext context, byte[] token, State state) {
        this(address, context, token, state, Time.clock());
    }

    @VisibleForTesting

        }

        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));

{
    "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": {

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

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