}

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

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

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

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

  //
  if (b != address.size) {
    if (compress == -1) return null // Address didn't have compression or enough groups.
    address.copyInto(address, address.size - (b - compress), compress, b)
    address.fill(0.toByte(), compress, compress + (address.size - b))
  }

  return address
}

/** Decodes an IPv4 address suffix of an IPv6 address, like 1111::5555:6666:192.168.0.1. */

   *
   * @param hostAddr an RFC 3986 section 3.2.2 encoded IPv4 or IPv6 address
   * @return an InetAddress representing the address in {@code hostAddr}
   * @throws IllegalArgumentException if {@code hostAddr} is not a valid IPv4 address, or IPv6
   *     address surrounded by square brackets, or if the address has a scope id that fails
   *     validation against interfaces on the machine
   */

            "lb_endpoints": [{
              "endpoint": {
                "address":{
                  "socket_address": {"address": "lightstep-satellite", "port_value": 8080}
                }
              }
            }]
          }]
        }
      }
      
      
    ],
    "listeners":[
      {
        "address": {
          "socket_address": {
            "protocol": "TCP",

            "lb_endpoints": [{
              "endpoint": {
                "address":{
                  "socket_address": {"address": "localhost", "port_value": 6000}
                }
              }
            }]
          }]
        }
      }
      
      
    ],
    "listeners":[
      {
        "address": {
          "socket_address": {
            "protocol": "TCP",

   *
   * @param hostAddr an RFC 3986 section 3.2.2 encoded IPv4 or IPv6 address
   * @return an InetAddress representing the address in {@code hostAddr}
   * @throws IllegalArgumentException if {@code hostAddr} is not a valid IPv4 address, or IPv6
   *     address surrounded by square brackets, or if the address has a scope id that fails
   *     validation against interfaces on the machine
   */

        when:
        outgoingConnector.connect(address)

        then:
        ConnectException e = thrown()
        e.message.startsWith "Could not connect to server ${address}."
        e.cause instanceof java.net.ConnectException
    }

    def "the exception includes last failure when cannot connect"() {