archiveFileName = "$archName"
                destinationDirectory = projectDir
                from 'parent'
            }
            """
        when:
        run "pack"
        file(archName).usingNativeTools()."$unpackMethod"(file("build"))
        then:
        file("build/child").mode == 0777
        file("build/child/reference.txt").mode == 0746
        where:
        taskName | unpackMethod

                    }
                }
            }

            """
        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 << """

        def distZipDir = file('build/unzip')
        distZipFile.usingNativeTools().unzipTo(distZipDir)
        checkApplicationImage('mega-app', distZipDir.file('mega-app'))

        def distTarFile = file('build/distributions/mega-app.tar')
        distTarFile.assertIsFile()

        def distTarDir = file('build/untar')
        distTarFile.usingNativeTools().untarTo(distTarDir)

                System.out.println("downloading $url")
                distributionZip.copyFrom(url)

                System.out.println("unzipping ${distributionZip} to ${gradleHomeDir}")
                distributionZip.usingNativeTools().unzipTo(versionDir)

                markerFile.createFile()
            }
        }

        distributionZip.assertIsFile()
        gradleHomeDir.assertIsDir()
    }

        TestFile superGradleHome = super.getGradleHomeDir()

        if (!superGradleHome.isDirectory() || superGradleHome.listFiles({ it.isDirectory() } as FileFilter).size() == 0) {
            super.binDistribution.usingNativeTools().unzipTo(superGradleHome)
        }
        return new TestFile(superGradleHome.listFiles({ it.isDirectory() } as FileFilter).first())
    }

    static boolean isCommitDistribution(String version) {

        succeeds('distZip')

        then:
        def distFile = dslDir.file('build/distributions/my-app-1.0.2.zip')
        distFile.assertIsFile()

        def installDir = dslDir.file('unzip')
        distFile.usingNativeTools().unzipTo(installDir)

        checkApplicationImage(installDir.file('my-app-1.0.2'), executableDir)

        where:
        dsl << ['groovy', 'kotlin']
        executableDir << ['bin', 'customBin']
    }

        then:
        javaLink != javaHome
        javaLink.canonicalFile == javaHome.canonicalFile

        cleanup:
        javaLink.usingNativeTools().deleteDir()
    }

    def "honours jvm sys property that contain a space in gradle.properties"() {
        given:
        file("gradle.properties") << 'org.gradle.jvmargs=-Dsome-prop="i have space"'

            @Override
            void beforeBuild(BuildContext context) {
                def archive = tempDir.file(name)
                if (!archive.exists()) {
                    builder(archiveContentsDir.usingNativeTools(), archive)
                }
                File target = new File(invocationSettings.projectDir, name)
                FileUtils.copyFile(archive, target)
            }
        }
    }

    def setup() {
        createSampleProjectSetup()
    }

    def cleanup() {
        if (testDirectoryProvider.cleanup) {
            testDirectory.usingNativeTools().deleteDir() //remove symlinks
        }
    }

    @Requires([UnitTestPreconditions.UnixDerivative, PluginTestPreconditions.BashAvailable])
    def "can execute generated Unix start script in Bash"() {

        then:
        result.output.contains("my app")

        // Don't follow links when cleaning up test files
        testDirectory.usingNativeTools().deleteDir()
    }

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor)
    def "uses script basename as application name for use in log messages"() {
        when: