Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

  public void testInt() {
    Sink sink = new Sink(4);
    sink.putInt(0x04030201);
    HashCode unused = sink.hash();
    sink.assertInvariants(4);
    sink.assertBytes(new byte[] {1, 2, 3, 4});
  }

      return delegate.contentLength();
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
      BufferedSink bufferedSink = Okio.buffer(sink(sink));
      delegate.writeTo(bufferedSink);
      bufferedSink.flush();
    }

    public Sink sink(Sink sink) {
      return new ForwardingSink(sink) {
        private long totalBytesWritten = 0L;
        private boolean completed = false;

  private CharSink sink;

  public CharSinkTester(
      CharSinkFactory factory, String string, String suiteName, String caseDesc, Method method) {
    super(factory, string, suiteName, caseDesc, method);
    this.lines = getLines(string);
    this.expectedLines = getLines(expected);
  }

  @Override
  protected void setUp() throws Exception {
    this.sink = factory.createSink();
  }

        // Mapped inline to the sequence: [b2].
        sink.writeByte(ranges[rangesIndex + 2].code)
      }

      123 -> {
        // Mapped inline to the sequence: [b2a].
        sink.writeByte(ranges[rangesIndex + 2].code or 0x80)
      }

      124 -> {
        // Mapped inline to the sequence: [b2, b3].
        sink.writeByte(ranges[rangesIndex + 2].code)
        sink.writeByte(ranges[rangesIndex + 3].code)
      }

    assertThat(sink.getString()).isEqualTo("");
    sink.write(STRING);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());
    assertThat(sink.getString()).isEqualTo(STRING);
  }

  public void testWriteFrom_reader() throws IOException {
    StringReader reader = new StringReader(STRING);
    sink.writeFrom(reader);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());

enumerations or code snippets that are not further specified. The character <code>…</code>
(as opposed to the three characters <code>...</code>) is not a token of the Go
language.
</p>

<p>
A link of the form [<a href="#Language_versions">Go 1.xx</a>] indicates that a described
language feature (or some aspect of it) was changed or added with language version 1.xx and
thus requires at minimum that language version to build.

    for (shift in (lengthByteCount - 1) * 8 downTo 0 step 8) {
      sink.writeByte((v shr shift).toInt())
    }
  }

  fun writeBitString(bitString: BitString) {
    val sink = sink()
    sink.writeByte(bitString.unusedBitsCount)
    sink.write(bitString.byteString)
  }

  fun writeOctetString(byteString: ByteString) {
    sink().write(byteString)
  }

  fun writeUtf8(value: String) {

    assertTrue(sink.wasStreamClosed());
    assertArrayEquals(new byte[] {1, 2, 3, 4}, sink.getBytes());
  }

  public void testWrite_bytes() throws IOException {
    assertArrayEquals(new byte[0], sink.getBytes());
    sink.write(bytes);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());
    assertArrayEquals(bytes, sink.getBytes());
  }

  public void testWriteFrom_inputStream() throws IOException {

    assertTrue(sink.wasStreamClosed());
    assertArrayEquals(new byte[] {1, 2, 3, 4}, sink.getBytes());
  }

  public void testWrite_bytes() throws IOException {
    assertArrayEquals(new byte[0], sink.getBytes());
    sink.write(bytes);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());
    assertArrayEquals(bytes, sink.getBytes());
  }

  public void testWriteFrom_inputStream() throws IOException {

  /**
   * An HTTP body with alternating chunk sizes and chunk bodies. It is the caller's responsibility
   * to buffer chunks; typically by using a buffered sink with this sink.
   */
  private inner class ChunkedSink : Sink {
    private val timeout = ForwardingTimeout(socket.sink.timeout())
    private var closed: Boolean = false

    override fun timeout(): Timeout = timeout

    override fun write(
      source: Buffer,