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

        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:
        createDir('parent') {

        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
        "tarTree" | "tgzTo"  | "source.tgz"  | false
        "tarTree" | "tbzTo"  | "source.tbz2" | true

        def snapshot = snapshotter.snapshot(zipTree).snapshot

        then:
        assertSingleFileSnapshot(snapshot)

        when:
        TestFile tar = tempDir.file('archive.tar')
        archiveBaseDir.tarTo(tar)
        def tarTree = TestFiles.fileOperations(tempDir, testFileProvider()).tarTree(tar)
        snapshot = snapshotter.snapshot(tarTree).snapshot

        then:
        assertSingleFileSnapshot(snapshot)

    )
    def "visiting tar trees"() {
        given:
        runner.tasksToRun = ['visitTar']
        runner.addBuildMutator { createArchive(it, "archive.tar") { contents, output -> contents.tarTo(output) } }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    @RunFor(

        given:
        TestFile tar = file('tar-contents')
        tar.create {
            someDir {
                file '1.txt'
            }
        }
        tar.tarTo(file('test.tar'))
        and:
        buildFile << '''
            def res = new ReadableResource() {
                InputStream read() { new FileInputStream(file('test.tar')) }

        new TestFileHelper(this).zipTo(zipFile, useNativeTools, readOnly);
        return this;
    }

    public TestFile tarTo(TestFile tarFile) {
        return tarTo(tarFile, false);
    }

    public TestFile tarTo(TestFile tarFile, boolean readOnly) {
        new TestFileHelper(this).tarTo(tarFile, useNativeTools, readOnly);
        return this;
    }

    public TestFile tgzTo(TestFile tarFile) {

            TestFiles.tmpDirTemporaryFileProvider(tempDirProvider.getTestDirectory()));
    }

    @Override
    protected void archiveFileToRoot(TestFile file) {
        rootDir.tarTo(file);
    }

    @Override
    protected TestFile getArchiveFile() {
        return archiveFile;
    }

    @Override
    protected TarFileTree getTree() {
        return tree;
    }

    @Test

            archiveFileSet.setDirMode("0555")
            archiveTask.add(archiveFileSet)
        } else {
            archiveTask.setBasedir(file)
        }
    }

    void tarTo(TestFile tarFile, boolean nativeTools, boolean readOnly) {
        //TODO: there is an inconsistency here; when using native tools the root folder is put into the TAR, but only its content is packaged by the other branch

        and: "a tar file containing it"
        def tarFile = file("before/files.tar")
        untarredDir.tarTo(tarFile)

        and: "another tar file with the same contents"
        def tarFile2 = file("before/files2.tar")
        untarredDir.tarTo(tarFile2)

        and: "a copy task that copies from both tar files, failing on duplicates"
        buildFile << """