dropped in 2.0.

## Version 1.5.4

_2014-04-14_

 * Drop ALPN support in Android. There's a concurrency bug in all
   currently-shipping versions.
 * Support asynchronous disconnects by breaking the socket only. This should
   prevent flakiness from multiple threads concurrently accessing a stream.

## Version 1.5.3

_2014-03-29_

 * Fix bug where the Content-Length header was not always dropped when

	LastOnline    time.Time          `json:"lastOnline"`
	Online        bool               `json:"isOnline"`
	Latency       madmin.LatencyStat `json:"latency"`

	// replication metrics across buckets roll up
	ReplicatedSize int64 `json:"replicatedSize"`
	// Total number of completed operations
	ReplicatedCount int64 `json:"replicatedCount"`
	// Failed captures replication errors in various time windows

    println("Proxy Server 1 is ${server1.socketAddress}")
    println("Proxy Server 2 is ${server2.socketAddress}")

    // Since myproxy:8008 won't resolve, redirect with DNS to proxyServer1
    // Then redirect socket connection to server1
    dns["myproxy"] = listOf(proxyServer1)
    socketFactory[proxyServer1] = server1.socketAddress

    client = client.newBuilder().proxySelector(proxySelector).build()

    public CurlRequest compression(final String compression) {
        this.compression = compression;
        return this;
    }

    /**
     * Sets the SSL socket factory for secure connections.
     *
     * @param sslSocketFactory the SSL socket factory
     * @return this CurlRequest instance
     */
    public CurlRequest sslSocketFactory(final SSLSocketFactory sslSocketFactory) {

    private final Object group; // RdmaActiveEndpointGroup<DisniRdmaEndpoint>

    /**
     * Create new DiSNI RDMA connection
     *
     * @param remote remote socket address
     * @param local local socket address
     * @param group DiSNI endpoint group
     * @throws IOException if connection creation fails
     */

  when {
    // If there was a protocol problem, don't recover.
    e is ProtocolException -> false

    // If there was an interruption or timeout (SocketTimeoutException), don't recover.
    // For the socket connect timeout case we do not try the same host with a different
    // ConnectionSpec: we assume it is unreachable.
    e is InterruptedIOException -> false

      assertEquals(200, response.code)
      assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      assertEquals(Protocol.HTTP_2, response.protocol)

      assertThat(response.exchangeAccessor!!.connectionAccessor.socket())
        .isInstanceOf<SSLSocketImpl>()
    }
  }

  @Test
  fun testSupportedProtocols() {
    val factory = SSLSocketFactoryImpl()
    val s = factory.createSocket() as SSLSocketImpl

    int DEFAULT_PORT = 445;

    /** Default maximum multiplex count */
    int DEFAULT_MAX_MPX_COUNT = 10;
    /** Default response timeout in milliseconds */
    int DEFAULT_RESPONSE_TIMEOUT = 30000;
    /** Default socket timeout in milliseconds */
    int DEFAULT_SO_TIMEOUT = 35000;
    /** Default receive buffer size in bytes */
    int DEFAULT_RCV_BUF_SIZE = 60416;
    /** Default send buffer size in bytes */

 * limitations under the License.
 */
package okhttp3

import java.io.File
import java.net.InetSocketAddress
import java.net.Proxy
import java.net.ProxySelector
import java.net.Socket
import java.net.URI
import java.net.URL
import java.nio.charset.Charset
import java.security.KeyPair
import java.security.Principal
import java.security.cert.Certificate
import java.security.cert.X509Certificate

                authSequence = ASN1Util.as(ASN1Sequence.class, stream);
            }
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos ticket", e);
        }

        this.authorizations = new ArrayList<>();
        Enumeration<?> authElements = authSequence.getObjects();
        while (authElements.hasMoreElements()) {