super();
    }

    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {
        int start = bufferIndex;

        buffer[bufferIndex++] = (byte)0x00;        // Reserved
        buffer[bufferIndex++] = (byte)0x00;        // Reserved
        buffer[bufferIndex++] = (byte)0x00;        // Reserved

        totalParameterCount = readInt4( buffer, bufferIndex );
        if( bufDataStart == 0 ) {

		}
		if size > maxChunkSize {
			cr.err = errChunkTooBig
			return n, cr.err
		}
	}

	if cap(cr.buffer) < size {
		cr.buffer = make([]byte, size)
	} else {
		cr.buffer = cr.buffer[:size]
	}

	// Now, we read the payload.
	_, err = io.ReadFull(cr.reader, cr.buffer)
	if err == io.EOF && size != 0 {
		err = io.ErrUnexpectedEOF
	}
	if err != nil && err != io.EOF {
		cr.err = err

import java.nio.Buffer;

/**
 * Wrappers around {@link Buffer} methods that are covariantly overridden in Java 9+. See
 * https://github.com/google/guava/issues/3990
 */
@GwtIncompatible
@ElementTypesAreNonnullByDefault
final class Java8Compatibility {
  static void clear(Buffer b) {
    b.clear();
  }

  static void flip(Buffer b) {
    b.flip();
  }

        bufferIndex += 8;
        lastWriteTime = readTime( buffer, bufferIndex );
        bufferIndex += 8;
        changeTime = readTime( buffer, bufferIndex );
        bufferIndex += 8;
        extFileAttributes = readInt4( buffer, bufferIndex );
        bufferIndex += 4;
        allocationSize = readInt8( buffer, bufferIndex );
        bufferIndex += 8;
        endOfFile = readInt8( buffer, bufferIndex );

        this.setNumEntries(SMBUtil.readInt2(buffer, bufferIndex));
        bufferIndex += 2;
        this.isEndOfSearch = ( buffer[ bufferIndex ] & 0x01 ) == 0x01 ? true : false;
        bufferIndex += 2;
        this.eaErrorOffset = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.lastNameOffset = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        return bufferIndex - start;
    }

  private fun sourceReader(source: Source?): Callable<ByteString> {
    return Callable {
      val buffer = Buffer()
      while (source!!.read(buffer, 16384) != -1L) {
      }
      source.close()
      buffer.readByteString()
    }
  }

  private fun assertFile(
    prefix: ByteString,
    upstreamSize: Long,
    metadataSize: Int,

            e.nextEntryOffset = readInt4( buffer, bufferIndex );
            e.fileIndex = readInt4( buffer, bufferIndex + 4 );
            e.creationTime = readTime( buffer, bufferIndex + 8 );
    //      e.lastAccessTime = readTime( buffer, bufferIndex + 16 );
            e.lastWriteTime = readTime( buffer, bufferIndex + 24 );
    //      e.changeTime = readTime( buffer, bufferIndex + 32 );

    out.write(b);

    verify(hashFunction).newHasher();
    verify(hasher).putByte((byte) b);
    verifyNoMoreInteractions(hashFunction, hasher);
  }

  public void testWrite_putByteArray() throws Exception {
    byte[] buf = new byte[] {'y', 'a', 'm', 's'};
    HashingOutputStream out = new HashingOutputStream(hashFunction, buffer);
    out.write(buf);

        override fun onRetryChange(timeMs: Long) {
          callbacks.add(timeMs)
        }
      }
    val buffer = Buffer().writeUtf8(source)
    val reader = ServerSentEventReader(buffer, callback)
    while (reader.processNextEvent()) {
    }
    assertThat(buffer.size, "Unconsumed buffer: ${buffer.readUtf8()}")
      .isEqualTo(0)
  }

      val name = "SocksProxy $fromAddress to $toAddress"
      threadName(name) {
        val buffer = Buffer()
        try {
          sink.use {
            source.use {
              while (true) {
                val byteCount = source.read(buffer, 8192L)
                if (byteCount == -1L) break
                sink.write(buffer, byteCount)
                sink.emit()
              }
            }
          }