originalJar.withCloseable {
            Enumeration<? extends ZipEntry> entries = originalJar.entries()
            while (entries.hasMoreElements()) {
                ZipEntry entry = entries.nextElement()
                if (entry.getName().contains("BasePlatformTestCase")) {
                    ZipEntry newEntry = new ZipEntry(entry.getName())

        0 * _
    }

    def "does not cache zip entries"() {
        def expectedHash = TestHashCodes.hashCodeFrom(123)
        def zipEntry = Mock(ZipEntry)
        def zipEntryContext = new DefaultZipEntryContext(zipEntry, "foo", "foo.zip")

        when:
        def actualHash = cachingHasher.hash(zipEntryContext)

        then:
        1 * delegate.hash(zipEntryContext) >> expectedHash

        writeElastisearchJsonApi(zos, id, "nodes", "hot_threads");
    }

    protected void writeElastisearchJsonApi(final ZipOutputStream zos, final String id, final String v1, final String v2) {
        final ZipEntry entry = new ZipEntry(id + "/es_" + v1 + "_" + v2 + ".json");
        try {
            zos.putNextEntry(entry);
            try (CurlResponse response = ComponentUtil.getCurlHelper().get("/_" + v1 + "/" + v2).execute()) {

    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        ZipOutputStream zipOutput = new ZipOutputStream(output.openOutput());
        for (DataSource input : inputs) {
            ZipEntry entry = new ZipEntry(input.getName());
            entry.setSize(input.getLength());
            zipOutput.putNextEntry(entry);
            PackerUtils.packEntry(input, zipOutput, buffer);
            zipOutput.closeEntry();
        }

            protected void doExecute(ZipInputStream inputStream) throws Exception {
                ZipEntry zipEntry = inputStream.getNextEntry()
                while (zipEntry != null) {
                    String name = zipEntry.name

                    // only check Gradle core, non-relocated classes

                        jarOutputStream.addEntry(entry, zip)
                    }
                }
            }
        }
    }

    private fun JarOutputStream.addEntry(entry: ZipEntry, zip: ZipFile) {
        putNextEntry(ZipEntry(entry.name))
        zip.getInputStream(entry).use { it.copyTo(this) }
        closeEntry()
// tag::artifact-transform-minify[]
    }
}
// end::artifact-transform-minify[]

            maybeAddParent(name);
            ZipArchiveEntry zipEntry = newZipEntryWithFixedTime(name);
            configureCompression(zipEntry, compressionMethod, content);
            outputStream.setEncoding("UTF-8");
            outputStream.putArchiveEntry(zipEntry);
            outputStream.write(content);
            outputStream.closeArchiveEntry();
        }

        try {
            def entries = zipFile.getEntries()
            def zipEntry = entries.nextElement()
            if(zipEntry.getName().equalsIgnoreCase('META-INF/')) {
                zipEntry = entries.nextElement()
            }
            def firstEntryName = zipEntry.getName()
            assert firstEntryName.equalsIgnoreCase(JarFile.MANIFEST_NAME)
        } finally {

 * limitations under the License.
 */

package org.gradle.internal.fingerprint.hashing;

import org.gradle.api.internal.file.archive.ZipEntry;

import java.util.function.Supplier;

public interface ZipEntryContext {
    ZipEntry getEntry();

    String getFullName();

    String getRootParentName();

    Supplier<String[]> getRelativePathSegments();

            boolean canReopen() {
                return !unsafe
            }

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