void testReadSetupWireFormat() {
        // Arrange
        byte[] buffer = new byte[100];
        int bufferIndex = 0;
        int len = 100;

        // Act
        int result = response.readSetupWireFormat(buffer, bufferIndex, len);

        // Assert
        assertEquals(0, result);
    }

    @Test

        AtomicInteger calls = new AtomicInteger();
        doAnswer(inv -> {
            int len = inv.getArgument(2);
            // First call returns len-1, second returns 1
            return calls.getAndIncrement() == 0 ? Math.max(1, len - 1) : 1;
        }).when(raf).read(any(byte[].class), anyInt(), anyInt());
        byte[] dst = new byte[4];

        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

                        this.serverSignature = new PacSignature(bufferData);
                        if (log.isDebugEnabled()) {
                            log.debug(String.format("Server signature is type %d @ %d len %d", this.serverSignature.getType(), bufferOffset,
                                    bufferSize));
                        }
                        // Clear signature from checksum copy

     * @param len
     *            The length of data to process
     */
    public void update(final byte[] input, final int offset, final int len) {
        if (log.isTraceEnabled()) {
            log.trace("update: " + this.updates + " " + offset + ":" + len);
            log.trace(Hexdump.toHexString(input, offset, Math.min(len, 256)));
        }
        if (len == 0) {
            return; /* CRITICAL */

        return 0;
    }

    @Override
    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;

        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

    super(new DataOutputStream(Preconditions.checkNotNull(out)));
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    // Override slow FilterOutputStream impl
    out.write(b, off, len);
  }

  @Override
  public void writeBoolean(boolean v) throws IOException {
    ((DataOutputStream) out).writeBoolean(v);
  }

  @Override

     * @return string length
     */
    public int stringWireLength(final String str, final int offset) {
        int len = str.length() + 1;
        if (this.useUnicode) {
            len = str.length() * 2 + 2;
            len = offset % 2 != 0 ? len + 1 : len;
        }
        return len;
    }

    /**
     * Calculates the length of a null-terminated string in the buffer.
     *

        hashFunction.hashBytes(bytes), hashFunction.newHasher(size).putBytes(bytes).hash());
    int off = random.nextInt(size);
    int len = random.nextInt(size - off);
    assertEquals(
        hashFunction.hashBytes(bytes, off, len),
        hashFunction.newHasher(size).putBytes(bytes, off, len).hash());
  }

  private static void assertHashByteBufferEquivalence(HashFunction hashFunction, Random random) {