return new String(chars);
  }

  private static byte[] toByteArray(int... bytes) {
    byte[] realBytes = new byte[bytes.length];
    for (int i = 0; i < bytes.length; i++) {
      realBytes[i] = (byte) bytes[i];
    }
    return realBytes;
  }

  private static void assertWellFormed(int... bytes) {
    assertTrue(Utf8.isWellFormed(toByteArray(bytes)));
  }

		name     string
		mutator  func(*mutator, []byte) []byte
		randVals []int
		input    []byte
		expected []byte
	}{
		{
			name:     "byteSliceRemoveBytes",
			mutator:  byteSliceRemoveBytes,
			input:    []byte{1, 2, 3, 4},
			expected: []byte{4},
		},
		{
			name:     "byteSliceInsertRandomBytes",
			mutator:  byteSliceInsertRandomBytes,
			input:    make([]byte, 4, 8),
			expected: []byte{3, 4, 5, 0, 0, 0, 0},

	f.Add([]byte(`escaped\ space`))
	f.Add([]byte(`"unterminated quote`))
	f.Add([]byte(`'unterminated quote`))
	f.Add([]byte(`unterminated escape\`))
	f.Add([]byte(`"quote with unterminated escape\`))
	f.Add([]byte(`'quoted "double quotes"'`))
	f.Add([]byte(`"quoted 'single quotes'"`))
	f.Add([]byte(`"\$0"`))
	f.Add([]byte(`"\$\0"`))
	f.Add([]byte(`"\$"`))
	f.Add([]byte(`"\$ "`))

}

func gcmLengths(len0, len1 uint64) [16]byte {
	return [16]byte{
		byte(len0 >> 56),
		byte(len0 >> 48),
		byte(len0 >> 40),
		byte(len0 >> 32),
		byte(len0 >> 24),
		byte(len0 >> 16),
		byte(len0 >> 8),
		byte(len0),
		byte(len1 >> 56),
		byte(len1 >> 48),
		byte(len1 >> 40),
		byte(len1 >> 32),
		byte(len1 >> 24),
		byte(len1 >> 16),
		byte(len1 >> 8),
		byte(len1),
	}

  public void testBytes() {
    TestHasher hasher = new TestHasher(); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    hasher.putByte((byte) 1);
    hasher.putBytes(new byte[] {2, 3, 4, 5, 6});
    hasher.putByte((byte) 7);
    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});
    hasher.assertBytes(expected);
  }

  public void testShort() {

   * byte order.
   *
   * @return the next four bytes of the input stream, interpreted as an {@code int} in little-endian
   *     byte order
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue // to skip some bytes
  @Override
  public int readInt() throws IOException {
    byte b1 = readAndCheckByte();
    byte b2 = readAndCheckByte();
    byte b3 = readAndCheckByte();

    assertCrc(0x62a8ab43, fulls);
  }

  public void testFull100() {
    // Test 100 byte array of 0xFF.
    byte[] fulls = new byte[100];
    Arrays.fill(fulls, (byte) 0xFF);
    assertCrc(0xbc753add, fulls);
  }

  public void testAscending() {
    // Test 32 byte arrays of ascending.
    byte[] ascending = new byte[32];
    for (int i = 0; i < 32; i++) {
      ascending[i] = (byte) i;
    }

	START
	BYTE $0xba; BYTE $0xee; BYTE $0x4d; BYTE $0xfa;
	BYTE $0x98; BYTE $0x51; BYTE $0xca; BYTE $0x56;
	BYTE $0xa9; BYTE $0x11; BYTE $0x45; BYTE $0xe8;
	BYTE $0x3e; BYTE $0x99; BYTE $0xc5; BYTE $0x9c;
	BYTE $0xf9; BYTE $0x11; BYTE $0xcb; BYTE $0x8e;
	BYTE $0x80; BYTE $0xda;  BYTE $0xf1; BYTE $0x2f;
	END

// FIPSOnly indicates that crypto/tls/fipsonly is present.
TEXT ·FIPSOnly(SB),NOSPLIT,$0
	START

    private static void longToBytes(long value, byte[] bytes, int offset) {
        bytes[offset] = (byte) (value & 0xFF);
        bytes[offset + 1] = (byte) ((value >>> 8) & 0xFF);
        bytes[offset + 2] = (byte) ((value >>> 16) & 0xFF);
        bytes[offset + 3] = (byte) ((value >>> 24) & 0xFF);
        bytes[offset + 4] = (byte) ((value >>> 32) & 0xFF);
        bytes[offset + 5] = (byte) ((value >>> 40) & 0xFF);

    public int bits() {
      return 64;
    }

    @Override
    public byte[] asBytes() {
      return new byte[] {
        (byte) hash,
        (byte) (hash >> 8),
        (byte) (hash >> 16),
        (byte) (hash >> 24),
        (byte) (hash >> 32),
        (byte) (hash >> 40),
        (byte) (hash >> 48),
        (byte) (hash >> 56)
      };
    }

    @Override
    public int asInt() {