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

    private fun JarOutputStream.addEntry(entry: ZipEntry, zip: ZipFile) {
        putNextEntry(ZipEntry(entry.name))
        zip.getInputStream(entry).use { it.copyTo(this) }

        when:
        project.pluginManager.apply(DistributionPlugin)
        project.version = '1.2'

        then:
        def zip = project.tasks.distZip
        zip.archiveFile.get().asFile == project.file("build/distributions/test-project-1.2.zip")
        def tar = project.tasks.distTar
        tar.archiveFile.get().asFile == project.file("build/distributions/test-project-1.2.tar")
    }

    <modelVersion>4.0.0</modelVersion>
    <groupId>io.github.helpermethod</groupId>
    <artifactId>zip-forge</artifactId>
    <version>1.0.1</version>
    <name>zip-forge</name>
    <description>A tiny, formatter-friendly Java DSL for creating ZIP files.</description>
    <url>https://github.com/helpermethod/zip-forge</url>
    <licenses>
        <license>
            <name>The Apache License, Version 2.0</name>

import java.io.File
import java.util.zip.ZipEntry
import java.util.zip.ZipOutputStream


class ZipTest : TestWithTempFiles() {

    @Test
    fun `unzip fails on path traversal attempts`() {

        val maliciousZip = file("malicious.zip").apply {
            ZipOutputStream(outputStream()).use { zip ->
                val content = "suspicious".toByteArray()

        'task.flatMap { it.outDir }.zip(provider { "baz" }) { d, f -> d.file(f) }' | _
        'task.get().outDir.zip(provider { "baz" }) { d, f -> d.file(f) }'          | _
        'provider { "baz" }.zip(task.flatMap { it.outDir }) { f, d -> d.file(f) }' | _
        'provider { "baz" }.zip(task.get().outDir) { f, d -> d.file(f) }'          | _
    }

tasks.register('zip') {
    doLast {
        ant.zip(destfile: 'archive.zip') {
            fileset(dir: 'src') {
                include(name: '**.xml')
                exclude(name: '**.java')
            }
        }
    }

// license that can be found in the LICENSE file.

package zip_test

import (
	"archive/zip"
	"bytes"
	"compress/flate"
	"fmt"
	"io"
	"log"
	"os"
)

func ExampleWriter() {
	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Add some files to the archive.
	var files = []struct {
		Name, Body string
	}{

exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.zip
stdout '^rsc.io/sampler v1.3.0$'
! exists $GOPATH/pkg/mod/cache/download/rsc.io/sampler/@v/v1.2.1.zip
exists $GOPATH/pkg/mod/cache/download/rsc.io/sampler/@v/v1.3.0.zip
stdout '^golang\.org/x/text v0.0.0-20170915032832-14c0d48ead0c$'
! exists $GOPATH/pkg/mod/cache/download/golang.org/x/text/@v/v0.0.0-20170915032832-14c0d48ead0c.zip
cmp go.mod go.mod.go117

 * limitations under the License.
 */
package org.gradle.api.internal.file.archive

import org.apache.commons.compress.archivers.zip.Zip64RequiredException
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream
import org.gradle.api.file.RelativePath
import org.gradle.api.internal.DocumentationRegistry
import org.gradle.api.internal.file.CopyActionProcessingStreamAction

        and: "where a build edits each archive differently via a visitor"
        file('build.gradle') << """
            ${defineUpdateTask('zip')}
            ${defineVerifyTask('zip')}

            def theArchive1 = rootProject.file('test1.zip')
            def theArchive2 = rootProject.file('test2.zip')

            tasks.register('update1', UpdateTask) {
                archive = theArchive1