return TaskExecuterResult.WITHOUT_OUTPUTS
        }
        0 * _
        state.outcome == TaskExecutionOutcome.EXECUTED
        !state.failure
    }

    def 'should catch exception of delegate and set the outcome to failure'() {
        given:
        def failure = new RuntimeException("Failure")

        when:
        executer.execute(task, state, context)

        result.assertNotOutput("$PLUGIN_ID applied")
        result.assertNotOutput("$PLUGIN_TASK executed")
    }

    private static GradleExecuter pluginTaskExecutedWith(GradleExecuter executer) {
        return executer.withTasks(PLUGIN_TASK)
    }

    private void precompiledGroovyPluginBuiltWith(GradleExecuter executer) {
        file("plugins/src/main/groovy/${PLUGIN_ID}.gradle") << """

        """

        when:
        executer.withJavaHome highestLTS.javaHome
        succeeds "compileJava"
        then:
        executedAndNotSkipped ":compileJava"

        when:
        executer.withJavaHome lowestLTS.javaHome
        succeeds "compileJava"
        then:
        skipped ":compileJava"

        when:
        executer.withJavaHome lowestLTS.javaHome

        // Only one build should clone
        repo.expectCloneSomething()

        executer.withTasks('resolve')
        def build1 = executer.start()

        executer.withTasks('resolve')
        def build2 = executer.start()

        build1.waitForFinish()
        build2.waitForFinish()

        // Wait for each build to list versions

        );
        executer = new FinalizePropertiesTaskExecuter(executer);
        executer = new ResolveTaskExecutionModeExecuter(repository, executer);
        executer = new SkipTaskWithNoActionsExecuter(taskExecutionGraph, executer);
        executer = new SkipOnlyIfTaskExecuter(executer);
        executer = new CatchExceptionTaskExecuter(executer);

        output.contains('system_property_available in included settings.gradle: true')

        cleanup:
        cleanupDaemons(executer, executionVersion)
    }

    static void cleanupDaemons(GradleExecuter executer, GradleDistribution executionVersion) {
        new DaemonLogsAnalyzer(executer.daemonBaseDir, executionVersion.version.version).killAll()
    }

        succeeds("tasks")

        executer.usingProjectDirectory(file("buildSrc"))
        fails("tasks")

        file("buildSrc").assertIsEmptyDir()
        executer.gradleUserHomeDir.file(BuildScopeCacheDir.UNDEFINED_BUILD).assertDoesNotExist()
    }

    def "does not fail when executing #flag in undefined build"() {
        when:
        executer.requireDaemon().requireIsolatedDaemons()
        succeeds(flag)

        dir
    }

    void startBuild(String javaHome = null, String buildEncoding = null) {
        run {
            executer.withTasks("watch")
            executer.withDaemonIdleTimeoutSecs(daemonIdleTimeout)
            executer.withArguments(
                "-Dorg.gradle.daemon.healthcheckinterval=${periodicCheckInterval * 1000}",

        when:
        executer.usingProjectDirectory(originalLocation)
        executer.withGradleUserHomeDir(originalHome)
        withBuildCache().run "jar", "customTask"

        then:
        executedAndNotSkipped ":compileJava", ":jar", ":customTask"

        when:
        executer.usingProjectDirectory(originalLocation)

        def block = server.expectAndBlock("block")
        def build = executer.withTasks("block").start()
        block.waitForAllPendingCalls()

        daemons.daemon.assertBusy()
        executer.useOnlyRequestedJvmOpts()
        executer.withBuildJvmOpts('-Xmx128m')
        executer.run()

        when:
        def out = executer.withArguments("--status").run().normalizedOutput

        then: