val unzipDir = outputs.dir(input.name)                              // <3>
        unzipTo(input, unzipDir)                                            // <4>
    }

    private fun unzipTo(zipFile: File, unzipDir: File) {
        // implementation...
// end::artifact-transform-unzip[]
        ZipFile(zipFile).use { zip ->
            val outputDirectoryCanonicalPath = unzipDir.canonicalPath

        def unzipDir = outputs.dir(input.name)                              // <3>
        unzipTo(input, unzipDir)                                            // <4>
    }

    private static void unzipTo(File zipFile, File unzipDir) {
        // implementation...
// end::artifact-transform-unzip[]
        new ZipFile(zipFile).withCloseable { zip ->
            def outputDirectoryCanonicalPath = unzipDir.canonicalPath

        succeeds("packageDistribution")

        then:
        def tmpOutDir = dslDir.file("tmp")
        def zipFile = dslDir.file("build/dist/my-distribution.zip")
        zipFile.isFile()
        zipFile.unzipTo(tmpOutDir)
        tmpOutDir.file("my-report.pdf").isFile()
        tmpOutDir.file("numbers.csv").isFile()
        tmpOutDir.file("metrics/scatterPlot.pdf").isFile()

        where:
        dsl << ['groovy', 'kotlin']

                }
            }

            """
        then:
        succeeds('customDistZip')
        and:
        file('build/distributions/TestProject-custom.zip').usingNativeTools().unzipTo(file("unzip"))
        file("unzip/TestProject-custom/someFile").assertIsFile()
    }

    def "can publish distribution"() {
        when:
        buildFile << """
            apply plugin:'distribution'

        File unzipDir = outputs.dir(unzippedDirName);
        try {
            unzipTo(zippedFile, unzipDir);
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    private static void unzipTo(File headersZip, File unzipDir) throws IOException {

        then:
        file("build/child").mode == 0777
        file("build/child/reference.txt").mode == 0746
        where:
        taskName | unpackMethod
        "Zip"    | "unzipTo"
        "Tar"    | "untarTo"
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "file and directory permissions can be overridden in #taskName task"() {
        given:
        createDir('parent') {

import org.gradle.api.provider.Provider
import org.gradle.api.tasks.IgnoreEmptyDirectories
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.kotlin.dsl.support.unzipTo
import org.gradle.work.DisableCachingByDefault
import java.io.File


/**
 * This dependency transform is responsible for extracting the sources from

        }
        """

        when:
        run 'distZip'

        then:
        def expandDir = file('expanded')
        file('build/distributions/DefaultJavaDistribution.zip').unzipTo(expandDir)
        expandDir.assertHasDescendants(
                'DefaultJavaDistribution/lib/commons-collections-3.2.2.jar',
                'DefaultJavaDistribution/lib/commons-cli-1.2.jar',

        outputFile.exists()
        outputFile.unzipTo(unpackDir)
        unpackDir.file("README").text == "README"
        unpackDir.file("subdir/A").text == "A"

        when:
        subDir.file("B").text = "B"

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":zip")
        outputFile.exists()
        outputFile.unzipTo(unpackDir)
        unpackDir.file("subdir/B").text == "B"

                zip.write(content)
                zip.closeEntry()
            }
        }

        try {
            unzipTo(file("output/directory"), maliciousZip)
            fail()
        } catch (ex: IllegalArgumentException) {