contentType: MediaType?,
  offset: Int,
  byteCount: Int,
): RequestBody {
  checkOffsetAndCount(size.toLong(), offset.toLong(), byteCount.toLong())
  return object : RequestBody() {
    override fun contentType() = contentType

    override fun contentLength() = byteCount.toLong()

    override fun writeTo(sink: BufferedSink) {
      sink.write(this@commonToRequestBody, offset, byteCount)
    }
  }
}

     * @return 変換された{@link Long}
     */
    public static Long toLong(final Object o) {
        return toLong(o, null);
    }

    /**
     * {@link Long}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @param pattern
     *            パターン文字列
     * @return 変換された{@link Long}
     */
    public static Long toLong(final Object o, final String pattern) {
        if (o == null) {

      @Suppress("UNUSED_VARIABLE")
      val ttl = buf.readInt().toLong() and 0xffffffffL // ttl
      val length = buf.readShort().toInt() and 0xffff

      if (type == TYPE_A || type == TYPE_AAAA) {
        val bytes = ByteArray(length)
        buf.read(bytes)
        result.add(InetAddress.getByAddress(bytes))
      } else {
        buf.skip(length.toLong())
      }
    }

    return result
  }

 *
 */
public class LongConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToLong() throws Exception {
        assertEquals(new Long("1000"), LongConversionUtil.toLong("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveLong() throws Exception {
        assertEquals(1000, LongConversionUtil.toPrimitiveLong("1,000"));
    }

    /**

    override fun execute(ctx: ComponentMetadataContext) {
        ctx.details.run {
            if (id.group.startsWith("com.fasterxml.jackson")) {
                // declare that Jackson modules belong to the platform defined by the Jackson BOM
                belongsTo("com.fasterxml.jackson:jackson-bom:${id.version}", false)
            }
        }
    }
}
// end::bom-alignment-rule[]

// tag::alignment-rule[]

    def "runs methods in worker process and returns the result"() {
        when:
        def builder = workerFactory.singleRequestWorker(TestWorker.class)
        def worker = builder.build()
        def result = worker.run(12.toLong())

        then:
        result == "[12]"
    }

    def "infers worker implementation classpath"() {
        given:
        def cl = compileToDirectoryAndLoad("CustomTestWorker", """

    void execute(ComponentMetadataContext ctx) {
        ctx.details.with {
            if (id.group.startsWith("com.fasterxml.jackson")) {
                // declare that Jackson modules belong to the platform defined by the Jackson BOM
                belongsTo("com.fasterxml.jackson:jackson-bom:${id.version}", false)
            }
        }
    }
}
// end::bom-alignment-rule[]

// tag::alignment-rule[]

  return Buffer()
    .write(this)
    .asResponseBody(contentType, size.toLong())
}

internal fun ByteString.commonToResponseBody(contentType: MediaType?): ResponseBody {
  return Buffer()
    .write(this)
    .asResponseBody(contentType, size.toLong())
}

internal fun BufferedSource.commonAsResponseBody(
  contentType: MediaType?,
  contentLength: Long,
): ResponseBody =

    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun buildEmptyForm() {
    val body = FormBody.Builder().build()
    val expected = ""
    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)

 */
class HeadersReader(val source: BufferedSource) {
  private var headerLimit = HEADER_LIMIT.toLong()

  /** Read a single line counted against the header size limit. */
  fun readLine(): String {
    val line = source.readUtf8LineStrict(headerLimit)
    headerLimit -= line.length.toLong()
    return line
  }

  /** Reads headers or trailers. */
  fun readHeaders(): Headers {