}
        """.stripIndent()

        createDir('test') {
            file 'mojibak€.txt'
        }
        assert new String('mojibak€.txt').getBytes('ISO-8859-15') != new String('mojibak€.txt').getBytes('UTF-8')

        when:
        succeeds 'jar'

        then:
        def jar = new JarTestFixture(file('dest/test.jar'), 'ISO-8859-15')
        jar.assertContainsFile('mojibak€.txt')

      buffer.putChar(input.charAt(i));
    }
    return hashBytes(buffer.array());
  }

  @Override
  public HashCode hashString(CharSequence input, Charset charset) {
    return hashBytes(input.toString().getBytes(charset));
  }

  @Override
  public abstract HashCode hashBytes(byte[] input, int off, int len);

  @Override
  public HashCode hashBytes(ByteBuffer input) {

    private MemoryAmount(long bytes, String notation) {
        Preconditions.checkArgument(bytes > 0, "bytes must be positive");
        this.bytes = bytes;
        this.notation = notation;
    }

    public long getBytes() {
        return bytes;
    }

    @Override
    public String toString() {
        return notation;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

        super.setUp();
        file1 = File.createTempFile("synonym", ".txt");
        FileUtil.writeBytes(file1.getAbsolutePath(),
                "a1=>A1\nb1,b2 => B1\nc1 => C1, C2\nx1,X1\ny1, Y1, y2"
                        .getBytes(Constants.UTF_8));
        // TODO set up opensearch and dictionaryManager
        synonymFile = new SynonymFile("1", file1.getAbsolutePath(), new Date());
    }

    @Override

        if (text == null) {
            return null;
        }

        final MessageDigest msgDigest = getInstance(algorithm);
        try {
            msgDigest.update(text.getBytes("UTF-8"));
        } catch (final UnsupportedEncodingException e) {
            throw new ClIllegalStateException(e);
        }
        final byte[] digest = msgDigest.digest();

                .collect(Collectors.toList());

            new ObjectMapper().writerWithDefaultPrettyPrinter()
                .writeValue(runtimesFile, json);
            Files.write(runtimesFile.toPath(), "\n".getBytes(StandardCharsets.UTF_8), StandardOpenOption.APPEND);
        }
    }

        int start = dstIndex;
        byte[] descr;
        int which = subCommand == NET_SERVER_ENUM2 ? 0 : 1;

        try {
            descr = DESCR[which].getBytes( "ASCII" );
        } catch( UnsupportedEncodingException uee ) {
            return 0;
        }

        writeInt2( subCommand & 0xFF, dst, dstIndex );
        dstIndex += 2;

    def setup() {
        evilZip.withOutputStream {
            new ZipOutputStream(it).withCloseable { ZipOutputStream zos ->
                zos.putNextEntry(new ZipEntry('../../tmp/evil.sh'))
                zos.write("evil".getBytes('utf-8'))
                zos.closeEntry()
            }
        }
    }

    def "evil.zip has path traversal"() {
        given:
        def entryNames = new ZipFile(evilZip).withCloseable {

                            "# For information about cache directory tags, see:\n" +
                            "#\thttps://bford.info/cachedir/"
                    ).getBytes("UTF-8")
                );
            } finally {
                // stream close is done here so if it throws, we can re-use the outer catch block
                stream.close();
            }

    }
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putString(CharSequence charSequence, Charset charset) {
    return putBytes(charSequence.toString().getBytes(charset));
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes) {
    return putBytes(bytes, 0, bytes.length);
  }

  @Override
  @CanIgnoreReturnValue