*/
    public static Long toLong(final Object o) {
        return toLong(o, null);
    }

    /**
     * Converts the given object to a {@link Long}.
     *
     * @param o
     *            the object to convert
     * @param pattern
     *            the pattern string
     * @return the converted {@link Long}
     */
    public static Long toLong(final Object o, final String pattern) {

    random.nextBytes(buf)
    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)
    assertThat(encodedLength(data).toLong()).isEqualTo(encodeBuffer.size)
    val decodeBuffer = Buffer()
    decode(encodeBuffer, encodeBuffer.size, decodeBuffer)
    assertEquals(data, decodeBuffer.readByteString())
  }

      @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
  }

    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse()
        .setBody(Buffer().write(ByteArray(responseBodySize)))
        .throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),

import static com.google.common.primitives.UnsignedInts.INT_MASK;
import static com.google.common.primitives.UnsignedInts.compare;
import static com.google.common.primitives.UnsignedInts.toLong;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.math.BigInteger;

  }

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

        .add("Connection", "keep-alive")
        .add("Transfer-Encoding", "chunked")
        .build()
    assertThat(headers2).isNotEqualTo(headers1)
    assertThat(headers2.hashCode()).isNotEqualTo(headers1.hashCode().toLong())
  }

  @Test fun headersToString() {
    val headers =
      Headers
        .Builder()
        .add("A", "a")
        .add("B", "bb")
        .build()

    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)

 *
 */
public class LongConversionUtilTest extends TestCase {

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

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

    /**

      offset: Int = 0,
      byteCount: Int = size,
    ): 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@toRequestBody, offset, byteCount)
        }