}
        }.zipTo(zipFile)

        def zipFile2 = file('another-library.jar')
        file('anotherZipContents').create {
            file('thirdFile.txt').text = "third file"
            file('forthFile.txt').text = "forth file"
            subdir {
                file('someEvenOtherFile.log').text = "another file in subdir"
            }
        }.zipTo(zipFile2)

        when:

    }


internal
fun File.normalisedPathRelativeTo(baseDir: File) =
    normaliseFileSeparators(relativeTo(baseDir).path)


fun zipTo(zipFile: File, entries: Sequence<Pair<String, ByteArray>>) {
    zipTo(zipFile.outputStream(), entries)
}


private
fun zipTo(outputStream: OutputStream, entries: Sequence<Pair<String, ByteArray>>) {
    ZipOutputStream(outputStream).use { zos ->
        entries.forEach { entry ->

        def outer = tmpDir.file("outer.jar")
        outerContent.zipTo(outer)
        def originalHash = zipHasher.hash(snapshotContext(outer))

        when:
        def innerContent = tmpDir.createDir("inner")
        def inner = outerContent.file("inner.jar")
        innerContent.zipTo(inner)
        outerContent.zipTo(outer)
        def newHash = zipHasher.hash(snapshotContext(outer))

        then:

package org.gradle.kotlin.dsl.fixtures

import org.gradle.test.fixtures.file.CleanupTestDirectory
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider

import org.gradle.kotlin.dsl.support.zipTo

import org.junit.Rule

import java.io.File


@CleanupTestDirectory(fieldName = "tempFolder")
abstract class TestWithTempFiles {

    @JvmField
    @Rule
    val tempFolder = TestNameTestDirectoryProvider(javaClass)

        outputDir.file("A").text == "original"
        outputDir.file("B").text == "new-file"

        where:
        type      | packType | source        | readonly
        "zipTree" | "zipTo"  | "source.zip"  | true
        "zipTree" | "zipTo"  | "source.zip"  | false
        "tarTree" | "tarTo"  | "source.tar"  | true
        "tarTree" | "tarTo"  | "source.tar"  | false
        "tarTree" | "tgzTo"  | "source.tgz"  | true

            }
        """
        def srcDir = createDir('src') {
            file('foo.ok').write('')
            file('foo.fail').write('')
        }
        if (isZip) {
            srcDir.zipTo(file('src.zip'))
        }

        and:
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun 'ok'

        then:
        outputContains '*foo.ok*'

import org.gradle.kotlin.dsl.fixtures.DeepThought
import org.gradle.kotlin.dsl.fixtures.TestWithTempFiles
import org.gradle.kotlin.dsl.fixtures.classEntriesFor

import org.gradle.kotlin.dsl.support.zipTo

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.CoreMatchers.hasItem
import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test

import java.lang.ClassLoader.getSystemClassLoader

import org.gradle.kotlin.dsl.support.bytecode.beginClass
import org.gradle.kotlin.dsl.support.bytecode.endClass
import org.gradle.kotlin.dsl.support.bytecode.publicDefaultConstructor
import org.gradle.kotlin.dsl.support.zipTo

import org.objectweb.asm.Opcodes.ACC_ABSTRACT
import org.objectweb.asm.Opcodes.ACC_INTERFACE
import org.objectweb.asm.Opcodes.ACC_PRIVATE
import org.objectweb.asm.Opcodes.ACC_PUBLIC

import java.io.File

        and:
        then:
        file("unpacked/testdir").mode == 0753
        file("unpacked/testdir/reference.txt").mode == 0762
        where:
        taskName | packMethod | treeMethod
        "Zip"    | "zipTo"    | "zipTree"
        "Tar"    | "tarTo"    | "tarTree"
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "symlinked file permissions are preserved when using #taskName task"() {
        given:

        def emptyDirectory = file("emptyDir").createDir()
        def emptyZip = file("emptyZip.zip")
        def emptyTar = file("emptyTar.tar")
        emptyDirectory.zipTo(emptyZip)
        emptyDirectory.tarTo(emptyTar)
        buildFile << sourceTask
        buildFile << """
            tasks.register("sourceTask", MySourceTask) {
                sources.setFrom(${inputDeclaration})