hasher.putLong(0x0000000001000101L);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher
        .putShort((short) 0x0101)
        .putShort((short) 0x0100)
        .putShort((short) 0x0000)
        .putShort((short) 0x0000);
    assertEquals(hashCode, hasher.hash().asLong());
  }

  public void testHashFloatIsStable() {
    // Just a spot check.  Better than nothing.

          Java8Compatibility.position(bytes, pos);
          hasher.putBytes(bytes);
        }
        return this;
      }

      @Override
      public Hasher putShort(short s) {
        for (Hasher hasher : hashers) {
          hasher.putShort(s);
        }
        return this;
      }

      @Override
      public Hasher putInt(int i) {
        for (Hasher hasher : hashers) {

  @CanIgnoreReturnValue
  public Hasher putBytes(ByteBuffer bytes) {
    update(bytes);
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putShort(short s) {
    ByteBuffer scratch = scratch();
    scratch.putShort(s);
    return update(scratch, Shorts.BYTES);
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putInt(int i) {
    ByteBuffer scratch = scratch();

        buffer.putChar(charSequence.charAt(i));
      }
      return this;
    }

    @Override
    public Hasher putShort(short s) {
      ensureCapacity(Short.BYTES);
      buffer.putShort(s);
      return this;
    }

    @Override
    public Hasher putInt(int i) {
      ensureCapacity(Integer.BYTES);
      buffer.putInt(i);
      return this;

    } else {
      for (int remaining = b.remaining(); remaining > 0; remaining--) {
        putByte(b.get());
      }
    }
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putShort(short s) {
    putByte((byte) s);
    putByte((byte) (s >>> 8));
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putInt(int i) {
    putByte((byte) i);

   * @return this instance
   * @since 23.0
   */
  @CanIgnoreReturnValue
  PrimitiveSink putBytes(ByteBuffer bytes);

  /** Puts a short into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putShort(short s);

  /** Puts an int into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putInt(int i);

  /** Puts a long into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putLong(long l);

  @Override
  Hasher putBytes(byte[] bytes, int off, int len);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(ByteBuffer bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putShort(short s);

  @CanIgnoreReturnValue
  @Override
  Hasher putInt(int i);

  @CanIgnoreReturnValue
  @Override
  Hasher putLong(long l);

  /** Equivalent to {@code putInt(Float.floatToRawIntBits(f))}. */

  @CanIgnoreReturnValue
  public final Hasher putByte(byte b) {
    buffer.put(b);
    munchIfFull();
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putShort(short s) {
    buffer.putShort(s);
    munchIfFull();
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putChar(char c) {
    buffer.putChar(c);
    munchIfFull();

        ByteBuffer buffer = ByteBuffer.allocate(34);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort((short) 0); // dialectIndex
        buffer.put((byte) 0x0F); // securityMode (user, encrypted, sigs enabled, sigs required)
        buffer.putShort((short) 50); // maxMpxCount
        buffer.putShort((short) 10); // maxNumberVcs
        buffer.putInt(8192); // maxBufferSize
        buffer.putInt(65536); // maxRawSize

        short data3 = (short) mostSig; // next 2 bytes

        // Write in little-endian format as specified by MS-SMB2
        bb.putInt(data1); // data1 (4 bytes, little-endian)
        bb.putShort(data2); // data2 (2 bytes, little-endian)
        bb.putShort(data3); // data3 (2 bytes, little-endian)

        // Last 8 bytes (data4) written directly as big-endian bytes
        // Extract individual bytes from leastSig and write them directly