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;
        }
    }

                <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>

            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,
        /**

        private void configureCompression(ZipArchiveEntry entry, CompressionMethod compressionMethod, byte[] contents) {
            if (shouldCompress(compressionMethod)) {
                entry.setMethod(ZipArchiveEntry.DEFLATED);
            } else {
                entry.setMethod(ZipArchiveEntry.STORED);
                // A stored ZipEntry requires setting size and CRC32 upfront.
                // See https://stackoverflow.com/q/1206970.

                return !unsafe
            }

            @Override
            ZipEntry.ZipCompressionMethod getCompressionMethod() {
                return ZipEntry.ZipCompressionMethod.DEFLATED
            }
        }
        return new DefaultZipEntryContext(zipEntry, file.path, "foo.zip")
    }

    RegularFileSnapshotContext snapshotContext(File file, FileType fileType = FileType.RegularFile) {