}

    void configureProxy(GradleExecuter executer, String proxyScheme, String userName = null, String password = null) {
        configureProxyHost(executer, proxyScheme)

        if (userName) {
            executer.withArgument("-D${proxyScheme}.proxyUser=${userName}")
        }
        if (password) {
            executer.withArgument("-D${proxyScheme}.proxyPassword=${password}")
        }
    }

    }

    public <T extends GradleExecuter> T configure(T executer) {
        executer.beforeExecute(new Action<GradleExecuter>() {
            void execute(GradleExecuter e) {
                if (server.running) {
                    e.withArgument("-D${PLUGIN_PORTAL_OVERRIDE_URL_PROPERTY}=${uri.toString()}")
                }
            }
        })
        executer
    }


    @Override

        List<String> gav = Splitter.on(":").splitToList(coordinates)
        return publishAs(gav.get(0), gav.get(1), gav.get(2), mavenRepo, executer)
    }

    PluginHttpPublicationResults publishAs(String group, String artifact, String version, MavenHttpPluginRepository mavenRepo, GradleExecuter executer) {

        file('src/main/resources/org/gradle/resource.txt').createFile()

        executer.withTasks('classes').run()
        file('build/resources/main').assertHasDescendants('org/gradle/resource.txt')

        file('src/main/resources/org/gradle/resource.txt').assertIsFile().delete()
        file('src/main/resources/org/gradle/resource2.txt').createFile()

        executer.withTasks('classes').run()

        given:
        executer.requireOwnGradleUserHomeDir()
        executer.gradleUserHomeDir.file("init.gradle") << """
            println 'running init script'
            assert System.getProperty('foo') == 'bar'
        """
        executer.gradleUserHomeDir.file("gradle.properties") << "systemProp.foo=bar"

            compileGroovy.options.debug = false
'''

        executer.withTasks('compileGroovy').run().assertTasksSkipped(':compileJava')

        executer.withTasks('compileGroovy').run().assertTasksSkipped(':compileJava', ':compileGroovy')
    }

    @Test
    void recompilesDependentClasses() {
        executer.withTasks("classes").run();

        // Update interface, compile should fail

            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)

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

        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