* @param outBytes the output byte array
     * @param outOff the offset into the output array
     * @param intLen the number of integers to convert
     */
    public static void spreadIntsToBytes(final int[] inInts, final int inOff, final byte[] outBytes, final int outOff, final int intLen) {

        for (int i = 0; i < intLen; ++i) {

            outBytes[outOff + i * 4] = (byte) (inInts[inOff + i] >>> 24);

          end = nextOutFrame.start
          truncated = false
        } else {
          end = outBytes.size.toLong()
          truncated = nextOutFrame.truncated
        }

        // Write a frame.
        val length = (end - start).toInt()
        outputStream.write(outBytes, start.toInt(), length)

        // If the last frame was truncated, immediately close the connection.
        if (truncated) {

    Sink sink = new Sink(4); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    sink.putByte((byte) 1);
    sink.putBytes(new byte[] {2, 3, 4, 5, 6});
    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);
  }

  public void testShort() {

    Sink sink = new Sink(4); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    sink.putByte((byte) 1);
    sink.putBytes(new byte[] {2, 3, 4, 5, 6});
    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);
  }

  public void testShort() {

  @CanIgnoreReturnValue
  @Override
  Hasher putByte(byte b);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes);

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

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(ByteBuffer bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putShort(short s);

  @CanIgnoreReturnValue
  @Override

  public Hasher putByte(byte b) {
    update(b);
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes) {
    checkNotNull(bytes);
    update(bytes);
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes, int off, int len) {
    checkPositionIndexes(off, off + len, bytes.length);
    update(bytes, off, len);
    return this;
  }

    ByteBuffer bigEndian = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
    assertEquals(
        hashFunction.newHasher().putBytes(littleEndian).hash(),
        hashFunction.newHasher().putBytes(bigEndian).hash());
    assertEquals(ByteOrder.LITTLE_ENDIAN, littleEndian.order());
    assertEquals(ByteOrder.BIG_ENDIAN, bigEndian.order());
  }

    @Override
    public void write(int b) {
      sink.putByte((byte) b);
    }

    @Override
    public void write(byte[] bytes) {
      sink.putBytes(bytes);
    }

    @Override
    public void write(byte[] bytes, int off, int len) {
      sink.putBytes(bytes, off, len);
    }

    @Override
    public String toString() {
      return "Funnels.asOutputStream(" + sink + ")";
    }
  }

    @Override
    public void write(int b) {
      sink.putByte((byte) b);
    }

    @Override
    public void write(byte[] bytes) {
      sink.putBytes(bytes);
    }

    @Override
    public void write(byte[] bytes, int off, int len) {
      sink.putBytes(bytes, off, len);
    }

    @Override
    public String toString() {
      return "Funnels.asOutputStream(" + sink + ")";
    }
  }

    @CanIgnoreReturnValue
    @Override
    public Hasher putByte(byte b) {
      update(1, b & 0xFF);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putBytes(byte[] bytes, int off, int len) {
      checkPositionIndexes(off, off + len, bytes.length);
      int i;
      for (i = 0; i + 4 <= len; i += 4) {
        update(4, getIntLittleEndian(bytes, off + i));
      }