from file('$mergedManifestFilename')
                }
            }
        """.stripIndent()

        when:
        executer.withDefaultCharacterEncoding('windows-1252').withTasks('jar')
        executer.withArgument("--stacktrace")
        executer.run()

        then:
        def jar = new JarFile(file('dest/test.jar'))
        try {
            def manifest = jar.manifest

        executer.requireDaemon().requireIsolatedDaemons()
    }

    @Requires([IntegTestPreconditions.LowestSupportedLTSJavaHomeAvailable, IntegTestPreconditions.HighestSupportedLTSJavaHomeAvailable ])
    def "up-to-date when executing twice in a row"() {
        given:
        setupRunHelloWorldTask()

        when:
        executer.withJavaHome AvailableJavaHomes.getLowestSupportedLTS().javaHome

        def build1 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build2 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build3 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        poll(120) {

        """

        when:
        execute()

        then:
        executed()
        localCache.empty
        def cacheKey = cacheOperations.getCacheKeyForTask(":t")
        remoteCache.hasCacheEntry(cacheKey)

        when:
        settingsFile << """
            buildCache {
                $localCacheConfig
            }
        """
        execute()

        then:
        cached()

fun createQuickFeedbackTasks() {
    val testType = TestType.CROSSVERSION
    val defaultExecuter = "embedded"
    val prefix = testType.prefix
    testType.executers.forEach { executer ->
        val taskName = "$executer${prefix.capitalize()}Test"
        val testTask = createTestTask(taskName, executer, sourceSet, testType) {
            this.setSystemPropertiesOfTestJVM("latest")
            this.systemProperties["org.gradle.integtest.crossVersion"] = "true"

        when:
        def executer = builder.projectsLoaded(projectsLoadedAction, projectsLoadedHandler)
            .buildFinished(buildFinishedAction, buildFinishedHandler)
            .build()

        then:
        executer.connection == connection
        executer.connectionParameters == parameters
        executer.phasedBuildAction.getProjectsLoadedAction().getAction() == projectsLoadedAction

        keyStore.enableSslWithServerCert(server)

        setupBuildFile(repoType)

        when:
        executer.withStackTraceChecksDisabled() // Jetty logs stuff to console
        keyStore.configureIncorrectServerCert(executer)
        fails "libs"

        then:
        failure.assertHasCause("Could not GET '${server.uri}/repo1/my-group/my-module/1.0/")

        given:
        prepareWrapper()
        def gradleUserHome = testDirectory.file('some-custom-user-home')

        when:
        def executer = wrapperExecuter.withGradleUserHomeDir(null)
        executer.withArguments("-Dgradle.user.home=$gradleUserHome.absolutePath")
        executer.run()

        then:
        installationIn gradleUserHome
    }

    @Issue('https://issues.gradle.org/browse/GRADLE-2802')

    @UsesSample("files/copy")
    def "can copy a single file using task properties for the paths with #dsl dsl"() {
        given:
        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        succeeds('copyReport2')

        then:
        dslDir.file('build/toArchive/my-report.pdf').isFile()

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

        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProjectInTree())

        then:
        model.size() == 2
        model[0].message == "It works from project :"