* <ul>
 *   <li>Treating ISO control characters and specified space characters as spaces.</li>
 *   <li>Appending alphanumeric characters (0-9, A-Z, a-z) to the buffer.</li>
 *   <li>Appending symbol characters (!-/, :-@, [-`, {-~) to the buffer.</li>
 *   <li>Optionally removing duplicate terms based on a flag.</li>
 *   <li>Limiting the maximum size of alphanumeric and symbol terms.</li>
 * </ul>
 *

        .Builder()
        .body(
          Buffer()
            .write(ByteArray(responseBodySize)),
        ).throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    cancelLater(call, 500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {

    }

    @Test
    void testVerifySignature() {
        byte[] buffer = new byte[] { 1, 2, 3 };
        int offset = 0;
        int size = 3;

        // Simulate successful verification
        when(mockResponse.verifySignature(buffer, offset, size)).thenReturn(true);
        assertTrue(mockResponse.verifySignature(buffer, offset, size));

        // Simulate failed verification

import okhttp3.internal.closeQuietly
import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.buffer
import okio.source

/** Replays prerecorded outgoing frames and records incoming frames.  */
class MockHttp2Peer : Closeable {
  private var frameCount = 0
  private var client = false
  private val bytesOut = Buffer()
  private var writer = Http2Writer(bytesOut, client)

                        byte[] buffer = inv.getArgument(0);
                        int remaining = includeContent.length - index[0];
                        if (remaining <= 0) {
                            return -1;
                        }
                        int toRead = Math.min(buffer.length, remaining);
                        System.arraycopy(includeContent, index[0], buffer, 0, toRead);

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

import java.math.BigInteger
import java.net.ProtocolException
import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.ForwardingSource
import okio.Source
import okio.buffer

/**
 * Streaming decoder of data encoded following Abstract Syntax Notation One (ASN.1). There are
 * multiple variants of ASN.1, including:
 *

	public fun <init> (Ljava/lang/String;Lokhttp3/Headers;Ljava/util/List;JLokio/Buffer;ILjava/net/Socket;Ljava/io/IOException;)V
	public synthetic fun <init> (Ljava/lang/String;Lokhttp3/Headers;Ljava/util/List;JLokio/Buffer;ILjava/net/Socket;Ljava/io/IOException;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
	public final fun getBody ()Lokio/Buffer;
	public final fun getBodySize ()J

        thread.start();
        thread.join(1000);

        String output = thread.getOutput();
        String[] lines = output.split("\n");

        assertTrue("Buffer should be limited to 10 items", lines.length <= 10);
        assertTrue("Last lines should be kept", output.contains("line15"));
    }

    public void test_run_maxBufferSizeConstant() {

        try (InputStream stream = response.getContentAsStream()) {
            assertNotNull(stream);
            byte[] buffer = new byte[1024];
            int bytesRead = stream.read(buffer);
            assertEquals(data.length, bytesRead);
            assertArrayEquals(data, Arrays.copyOf(buffer, bytesRead));
        }
    }

    @Test
    public void testGetContentAsStreamWithoutCache() {

        final int start = bufferIndex;
        if (in.read(buffer, bufferIndex, length) != length) {
            throw new IOException("invalid session request wire format");
        }
        bufferIndex += calledName.readWireFormat(buffer, bufferIndex);
        bufferIndex += callingName.readWireFormat(buffer, bufferIndex);
        return bufferIndex - start;