val message = formatMessage(record)

    val time = Instant.ofEpochMilli(record.millis).atZone(offset)

    return if (record.thrown != null) {
      val sw = StringWriter(4096)
      val pw = PrintWriter(sw)
      record.thrown.printStackTrace(pw)
      String.format("%s\t%s%n%s%n", time.format(d), message, sw.toString())
    } else {
      String.format("%s\t%s%n", time.format(d), message)

    val s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    for (i in s.indices) {
      assertRoundTrip(s.substring(0, i).encodeUtf8())
    }
    val random = Random(123456789L)
    val buf = ByteArray(4096)
    random.nextBytes(buf)
    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)

tomcat.URIEncoding = UTF-8
tomcat.useBodyEncodingForURI = true
#tomcat.secure=false
#tomcat.scheme=http
#tomcat.bindAddress=127.0.0.1
#tomcat.proxyPort=

    hpackWriter = Hpack.Writer(4096, false, bytesOut)
  }

  /**
   * Variable-length quantity special cases strings which are longer than 127 bytes.  Values such as
   * cookies can be 4KiB, and should be possible to send.
   *
   *  http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-5.2
   */
  @Test
  fun largeHeaderValue() {
    val value = CharArray(4096)
    Arrays.fill(value, '!')

import okio.Buffer

/**
 * Tests Hpack implementation using https://github.com/http2jp/hpack-test-case/
 */
open class HpackDecodeTestBase {
  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {
      val encoded = testCase.wire ?: continue
      bytesIn.write(encoded)
      hpackReader.readHeaders()
      assertSetEquals(

 */
public abstract class InputStreamUtil {

    /**
     * Do not instantiate.
     */
    protected InputStreamUtil() {
    }

    /** Default buffer size. */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link FileInputStream}.
     *
     * @param file the file (must not be {@literal null})
     * @return a {@link FileInputStream} to read from the file

     *
     * @return the content as a string.
     * @throws CurlException if an error occurs while accessing the content.
     */
    public String getContentAsString() {
        final byte[] bytes = new byte[4096];
        try (BufferedInputStream bis = new BufferedInputStream(getContentAsStream());
                ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int length = bis.read(bytes);

class Http2Reader(
  /** Creates a frame reader with max header table size of 4096. */
  private val source: BufferedSource,
  private val client: Boolean,
) : Closeable {
  private val continuation: ContinuationSource = ContinuationSource(this.source)
  private val hpackReader: Hpack.Reader =
    Hpack.Reader(
      source = continuation,
      headerTableSizeSetting = 4096,
    )

  @Throws(IOException::class)

     */
    protected FileUtil() {
    }

    /** The encoding name for UTF-8. */
    private static final String UTF8 = "UTF-8";

    /** Default Buffer Size */
    protected static final int DEFAULT_BUF_SIZE = 4096; // 4k

    /** Max Buffer Size */
    protected static final int MAX_BUF_SIZE = 10 * 1024 * 1024; // 10m

    /**
     * Returns the canonical path string for this abstract pathname.
     *

 */
public abstract class ReaderUtil {

    /**
     * Do not instantiate.
     */
    protected ReaderUtil() {
    }

    /** Default buffer size */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link Reader} to read from a file with the specified encoding.
     *
     * @param is
     *            the input stream (must not be {@literal null})
     * @param encoding