this.creationTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastAccessTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastWriteTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.changeTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;

      StringBuilder builder = new StringBuilder();
      CharBuffer buffer = CharBuffer.allocate(100);
      while (reader.read(buffer) != -1) {
        Java8Compatibility.flip(buffer);
        builder.append(buffer);
        Java8Compatibility.clear(buffer);
      }
      return builder.toString();
    }
  }

        this.currentLeaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // NewLeaseState (4 bytes)
        this.newLeaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // BreakReason (4 bytes)
        this.breakReason = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // AccessMaskHint (4 bytes)

    @Override
    protected int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int nciphers = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        this.ciphers = new int[nciphers];
        for (int i = 0; i < nciphers; i++) {
            this.ciphers[i] = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;

    }

    /**
     * Runs the thread to continuously read lines from the input stream.
     * Each line is processed by the output callback (if provided) and added to the buffer.
     * The buffer is maintained as a circular buffer with the specified size.
     */
    @Override
    public void run() {
        boolean running = true;
        while (running) {
            try {

        for (b in data.toByteArray()) {
          assertThat(b).isEqualTo(2.toByte())
        }
      }
    }

  private fun gzip(data: ByteArray): Buffer {
    val buffer = Buffer()
    GzipSink(buffer).buffer().write(data).close()
    return buffer
  }

  /** Create a sufficiently large header set to overflow INITIAL_MAX_FRAME_SIZE bytes.  */
  private fun largeHeaders(): List<Header> {

        StringBuilder buffer = new StringBuilder(256);
        buffer.append('\'').append(fieldName).append('\'');

        if (sourceHint != null) {
            buffer.append(" for ").append(sourceHint);
        }

        buffer.append(' ').append(message);

        problems.add(severity, buffer.toString(), -1, -1, null);
    }

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder(64);
        buffer.append("{enabled=");
        buffer.append(enabled);
        buffer.append(", checksums=");
        buffer.append(checksumPolicy);
        buffer.append(", updates=");
        buffer.append(updatePolicy);
        buffer.append('}');
        return buffer.toString();
    }

    /**
     * Read into buffer from current position
     *
     * @param b
     *            buffer
     * @return number of bytes read
     * @throws SmbException if an I/O error occurs during read
     */
    int read(byte[] b) throws SmbException;

    /**
     * Read into buffer from current position
     *
     * @param b
     *            buffer
     * @param off