hasher = HASH_FN.newHasher();
    hasher
        .putByte((byte) 0x01)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();

public interface PrimitiveSink {
  /**
   * Puts a byte into this sink.
   *
   * @param b a byte
   * @return this instance
   */
  @CanIgnoreReturnValue
  PrimitiveSink putByte(byte b);

  /**
   * Puts an array of bytes into this sink.
   *
   * @param bytes a byte array
   * @return this instance
   */
  @CanIgnoreReturnValue
  PrimitiveSink putBytes(byte[] bytes);

  /**

        assertEquals("0.1 kB", format.format(_50_bytes, ScaleUnit.KILOBYTE));
        assertEquals("0 MB", format.format(_50_bytes, ScaleUnit.MEGABYTE));
        assertEquals("0 GB", format.format(_50_bytes, ScaleUnit.GIGABYTE));

        long _999_bytes = 999L;
        assertEquals("999 B", format.format(_999_bytes));
        assertEquals("999 B", format.format(_999_bytes, ScaleUnit.BYTE));

		if debugPrint {
			fmt.Println("connected stream mux:", ack.MuxID)
		}
	}()

	// Data inbound to the handler
	var handlerIn chan []byte
	if inboundCap > 0 {
		m.inbound = make(chan []byte, inboundCap)
		handlerIn = make(chan []byte, 1)
		go func(inbound chan []byte) {
			wg.Wait()
			defer xioutil.SafeClose(handlerIn)
			m.handleInbound(c, inbound, handlerIn)
		}(m.inbound)
	}
	// Fill outbound block.

 *
 */
public class Smb2FlushRequest extends ServerMessageBlock2Request<Smb2FlushResponse> implements RequestWithFileId {

    private byte[] fileId;


    /**
     * @param config
     * @param fileId
     */
    public Smb2FlushRequest ( Configuration config, byte[] fileId ) {
        super(config, SMB2_FLUSH);
        this.fileId = fileId;
    }


    @Override

	r := NewReader([]byte(data))
	if got, want := r.Len(), 11; got != want {
		t.Errorf("r.Len(): got %d, want %d", got, want)
	}
	if n, err := r.Read(make([]byte, 10)); err != nil || n != 10 {
		t.Errorf("Read failed: read %d %v", n, err)
	}
	if got, want := r.Len(), 1; got != want {
		t.Errorf("r.Len(): got %d, want %d", got, want)
	}
	if n, err := r.Read(make([]byte, 1)); err != nil || n != 1 {

  }

  public void testRead_withProcessor() throws IOException {
    final byte[] processedBytes = new byte[bytes.length];
    ByteProcessor<byte[]> processor =
        new ByteProcessor<byte[]>() {
          int pos;

          @Override
          public boolean processBytes(byte[] buf, int off, int len) throws IOException {
            System.arraycopy(buf, off, processedBytes, pos, len);

        this.macAddress = new byte[6];
    }


    @Override
    int writeBodyWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }


    @Override
    int readBodyWireFormat ( byte[] src, int srcIndex ) {
        return readResourceRecordWireFormat(src, srcIndex);
    }


    @Override
    int writeRDataWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }

     */
    @Override
    public void getUserSessionKey ( CIFSContext tc, byte[] chlng, byte[] dest, int offset ) throws SmbException {
        if ( this.hashesExternal ) {
            return;
        }
        super.getUserSessionKey(tc, chlng, dest, offset);
    }

    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int readSetupWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }