this.connectionType = mode.second

    if (connectionType == H2) {
      platform.assumeHttp2Support()
    }

    // Sockets on some platforms can have large buffers that mean writes do not block when
    // required. These socket factories explicitly set the buffer sizes on sockets created.
    server = MockWebServer()
    server.serverSocketFactory =
      object : DelegatingServerSocketFactory(ServerSocketFactory.getDefault()) {

 * Fix: Support the `PATCH` method.
 * Fix: Support request bodies on `DELETE` method.
 * Fix: Drop the `okhttp-protocols` module.
 * Internal: Replaced internal byte array buffers with pooled buffers ("OkBuffer").


## Version 1.3.0

_2014-01-11_

 * New: Support for "PATCH" HTTP method in client and MockWebServer.
 * Fix: Drop `Content-Length` header when redirected from POST to GET.

 * limitations under the License.
 */
package okhttp3.tls.internal.der

import java.math.BigInteger
import okio.Buffer
import okio.BufferedSink
import okio.ByteString

internal class DerWriter(
  sink: BufferedSink,
) {
  /** A stack of buffers that will be concatenated once we know the length of each. */
  private val stack = mutableListOf(sink)

        assertSame(a, first, "First get should return first cached buffer");
        assertSame(c, second, "Second get should return second cached buffer");
        assertNotSame(d, third, "Third get should allocate a new buffer (not the dropped one)");
        assertEquals(3, third.length, "Allocated buffer length matches configured maximum size");
    }

    int initialBufferSize = min(BUFFER_SIZE, max(128, Integer.highestOneBit(totalLen) * 2));
    // Starting with an 8k buffer, double the size of each successive buffer. Smaller buffers
    // quadruple in size until they reach 8k, to minimize the number of small reads for longer
    // streams. Buffers are retained in a deque so that there's no copying between buffers while

   * Use this method to create a degenerate Okio Buffer where each byte is in a separate segment of
   * the internal list.
   */
  @JvmStatic
  fun fragmentBuffer(buffer: Buffer): Buffer {
    // Write each byte into a new buffer, then clone it so that the segments are shared.
    // Shared segments cannot be compacted so we'll get a long chain of short segments.
    val result = Buffer()
    while (!buffer.exhausted()) {
      val box = Buffer()

  private static long fingerprint(byte[] bytes, int length) {
    return HASH_FN.hashBytes(bytes, 0, length).asLong();
  }

  /**
   * Tests that the Java port of Fingerprint2011 provides the same results on buffers up to 800
   * bytes long as the original implementation in C++. See http://cl/106539598
   */
  public void testMultipleLengths() {
    int iterations = 800;
    byte[] buf = new byte[iterations * 4];

        byte[] buffer = new byte[8];

        // Path consumed (2 bytes)
        SMBUtil.writeInt2(0, buffer, 0);

        // Number of referrals (2 bytes) - 0
        SMBUtil.writeInt2(0, buffer, 2);

        // Flags (2 bytes)
        SMBUtil.writeInt2(0, buffer, 4);

        // Padding (2 bytes)
        buffer[6] = 0;
        buffer[7] = 0;

        return buffer;
    }

        );
        when(mockNdrBuffer.dec_ndr_small()).thenReturn(4, 5);
        when(mockDeferredNdrBuffer.dec_ndr_long()).thenReturn(5, 0, 5, // name buffer: buffers, 0, bufferl
                6, 0, 6, // dns_domain buffer: buffers, 0, bufferl
                7, 0, 7 // dns_forest buffer: buffers, 0, bufferl
        );
        when(mockDeferredNdrBuffer.dec_ndr_short()).thenReturn((int) (short) 'a', (int) (int) (short) 'b', (int) (int) (short) 'c',

 * [Thrifty](https://github.com/Microsoft/thrifty): An implementation of Apache Thrift for Android.