*/
    @Test
    public void testReadParameterWordsWireFormat() {
        // Given
        byte[] buffer = new byte[] { (byte) 0xff, (byte) 0xff, 0, 0, 0, 0, 0, 0 };
        SmbComWriteAndXResponse instance = new SmbComWriteAndXResponse(config);

        // When
        int result = instance.readParameterWordsWireFormat(buffer, 0);

        // Then
        assertEquals(8, result);
        assertEquals(0xffffL, instance.getCount());

    int readHeaderWireFormat(final byte[] buffer, final int bufferIndex) {
        command = buffer[bufferIndex + CMD_OFFSET];
        errorCode = readInt4(buffer, bufferIndex + ERROR_CODE_OFFSET);
        flags = buffer[bufferIndex + FLAGS_OFFSET];
        flags2 = readInt2(buffer, bufferIndex + FLAGS_OFFSET + 1);
        tid = readInt2(buffer, bufferIndex + TID_OFFSET);
        pid = readInt2(buffer, bufferIndex + TID_OFFSET + 2);

    }

    private void transferCompleted(TransferEvent event) {
        downloads.remove(event.getResource());

        StringBuilder buffer = new StringBuilder(64);
        pad(buffer, lastLength);
        buffer.append('\r');
        out.println(buffer);
    }

    @Override
    public void transferCorrupted(TransferEvent event) {
        println(
                "transferCorrupted",

        "Expected at least Stats.BYTES = %s remaining , got %s",
        BYTES,
        buffer.remaining());
    return new Stats(
        buffer.getLong(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble());
  }

  private static final long serialVersionUID = 0;

        this.maxDataCount = maxDataCount;
    }

    /**
     * Sets the transaction buffer
     * @param buffer
     *            the transaction buffer to use
     */
    public void setBuffer(final byte[] buffer) {
        this.txn_buf = buffer;
    }

    /**
     * Releases and returns the transaction buffer
     * @return the txn_buf
     */
    public byte[] releaseBuffer() {

        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;
        this.extFileAttributes = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

                    + execution.getGoal());
            buffer.a(' ').strong('(' + execution.getExecutionId() + ')');
        }

        if (project != null) {
            buffer.a(" on project ");
            buffer.project(project.getArtifactId());
        }

        if (cause != null) {
            buffer.a(": ").failure(cause.getMessage());
        }

        return buffer.toString();
    }

     *
     * @param buffer the buffer containing the message data
     * @param bufferIndex the starting offset in the buffer
     * @return the number of bytes read
     */
    protected int readHeaderWireFormat(final byte[] buffer, final int bufferIndex) {
        this.command = buffer[bufferIndex + SmbConstants.CMD_OFFSET];
        this.errorCode = SMBUtil.readInt4(buffer, bufferIndex + SmbConstants.ERROR_CODE_OFFSET);

		buffer = make([]byte, size, 2*size+int64(fi.Erasure.ParityBlocks+fi.Erasure.DataBlocks-1))
	}

	if len(buffer) > int(fi.Erasure.BlockSize) {
		buffer = buffer[:fi.Erasure.BlockSize]
	}

	writers := make([]io.Writer, len(onlineDisks))
	inlineBuffers := make([]*bytes.Buffer, len(onlineDisks))
	for i, disk := range onlineDisks {
		if disk == nil {

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

    @Override
    protected int readParametersWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        setStatus(SMBUtil.readInt2(buffer, bufferIndex));
        bufferIndex += 2;
        this.converter = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;