val deflated = deflater.deflate(goldenValue)
    assertThat(deflated.size).isLessThan(goldenValue.size)
    val inflated = inflater.inflate(deflated)

    assertThat(inflated).isEqualTo(goldenValue)
  }

  @Test fun `inflate deflate empty message`() {
    val deflater = MessageDeflater(false)
    val inflater = MessageInflater(false)

    val goldenValue = "".encodeUtf8()

		"the quick brown fox jumped over",
	}

	deflated := make([]bytes.Buffer, 2)
	for i, s := range ss {
		w, _ := NewWriter(&deflated[i], 1)
		w.Write([]byte(s))
		w.Close()
	}

	inflated := make([]bytes.Buffer, 2)

	f := NewReader(&deflated[0])
	io.Copy(&inflated[0], f)
	f.(Resetter).Reset(&deflated[1], nil)
	io.Copy(&inflated[1], f)
	f.Close()

	for i, s := range ss {

            it.put("dir/deflated.txt", "bytes".bytes, ClasspathEntryVisitor.Entry.CompressionMethod.DEFLATED)
        }

        then:
        def zip = new ZipTestFixture(file)
        zip.hasCompression("store.txt", ZipEntry.STORED)
        zip.hasCompression("undefined.txt", ZipEntry.DEFLATED)
        zip.hasCompression("dir/deflated.txt", ZipEntry.DEFLATED)
    }

    def "can construct a directory"() {

    /**
     * Sets the compression level of the entries of the archive. If set to {@link ZipEntryCompression#DEFLATED} (the default), each entry is
     * compressed using the DEFLATE algorithm. If set to {@link ZipEntryCompression#STORED} the entries of the archive are left uncompressed.
     *
     * @param entryCompression {@code STORED} or {@code DEFLATED}
     */
    public void setEntryCompression(ZipEntryCompression entryCompression) {

        switch (entry.getMethod()) {
            case java.util.zip.ZipEntry.STORED:
                return ZipCompressionMethod.STORED;
            case java.util.zip.ZipEntry.DEFLATED:
                return ZipCompressionMethod.DEFLATED;
            default:
                return ZipCompressionMethod.OTHER;
        }
    }

/**
 * Specifies the compression level of an archives contents.
 */
public enum ZipEntryCompression {
    /** Contents are not compressed */
    STORED,

    /** Contents are compressed using the 'deflate' algorithm */
    DEFLATED

                <td>metadataCharset</td>
                <td>Platform default encoding</td>
            </tr>
            <tr>
                <td>entryCompression</td>
                <td><literal>ZipEntryCompression.DEFLATED</literal></td>
            </tr>
            <tr>
                <td>metadataCharset</td>
                <td>Platform default encoding</td>
            </tr>
            <tr>
                <td>zip64</td>

     */
    void visit(Entry entry) throws IOException;

    interface Entry {
        enum CompressionMethod {
            /**
             * The entry is compressed with DEFLATE algorithm.
             */
            DEFLATED,
            /**
             * The entry is not compressed and stored as is.
             */
            STORED,
            /**

            switch (entry.getCompressionMethod()) {
                case STORED:
                    return CompressionMethod.STORED;
                case DEFLATED:
                    return CompressionMethod.DEFLATED;
                default:
                    // Zip entries can be in many formats but JARs are unlikely to have them as JVM doesn't

public interface ZipEntry {
    /**
     * The compression method used for an entry
     */
    enum ZipCompressionMethod {
        /**
         * The entry is compressed with DEFLATE algorithm.
         */
        DEFLATED,

        /**
         * The entry is stored uncompressed.
         */
        STORED,
        /**