}
        def gradleRunner = GradleRunner.create()
            .withTestKitDir(testKitDir)
            .withProjectDir(testDirectory)
            .withArguments(allArgs)
            .withDebug(debug)

        gradleProvider.applyTo(gradleRunner)
        gradleRunner
    }

    static String helloWorldTask() {
        """
        task helloWorld {

        ivyRepo.module('org', 'projectB', '1.6')
            .publish()

        ivyRepo.module('org', 'projectC', 'alpha-12')
            .publish()

        when:
        executer.withArguments("-PuseDynamicResolve=true")
        run 'retrieve'

        then:
        file('libs').assertHasDescendants('projectA-1.2.jar', 'projectB-1.6.jar', 'projectC-alpha-12.jar')

        when:

            ?: currentType

    } while (oldType !== currentType)
    if (typeArguments.isNotEmpty()) {
        currentType = currentType.withArguments { typeProjection ->
            typeProjection.replaceType(
                typeProjection.type?.simplifyType(session, useSitePosition, visited)
            )
        }
    }
    return currentType
}

                    maven {
                        url '${mavenRepo.uri}'
                    }
                }
            }
        """
        executer.inDirectory(pluginBuild).withArguments('--include-build', pluginDependencyA.absolutePath).withTasks('publish').run()
    }

    private void publishPlugin() {
        pluginBuild.buildFile << """
            apply plugin: 'maven-publish'

    void collectDescriptorsFromBuild() {
        try {
            withConnection {
                ProjectConnection connection ->
                    connection.newBuild().forTasks('build')
                        .withArguments("--continue")
                        .addProgressListener(events)
                        .setStandardOutput(System.out)
                        .setStandardError(System.err)
                        .run()

        gradlePropertiesFile << """
            foo=bar
        """
        def snapshot = gradlePropertiesFile.snapshot()
        executer.withGradleUserHomeDir(dotGradleDir)
        executer.withArguments("--project-cache-dir", dotGradleDir.path)

        then:
        succeeds "init", '--overwrite'
        targetDir.file("gradlew").assertIsFile()
        targetDir.file("settings.gradle.kts").assertIsFile()

            "rootProject.projectDir = new File(settingsDir, '../root')"
        );
        getTestDirectory().createDir("root").file("build.gradle").writelns("task thing");

        inTestDirectory().withArguments("-p", settingsDir.getAbsolutePath()).withTasks("thing").runWithFailure()
            .assertHasDescription("Task 'thing' not found in root project 'gradle'.");
    }

abstract class AbstractJavaCompilerIntegrationSpec extends AbstractIntegrationSpec {

    abstract String compilerConfiguration()

    abstract String logStatement()

    def setup() {
        executer.withArguments("-i")
        buildFile << """
            plugins {
                id("java-library")
            }
            tasks.withType(JavaCompile) {
                options.compilerArgs << '-Xlint:all,-options' << '-Werror'

                doLast {
                    assert project.findProperty('foundProperty') == 'foundValue'
                }
            }
        """

        expect:
        executer.withArguments('-PfoundProperty=foundValue')
        succeeds("run")
    }

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def findPropertyShouldReturnNullIfNotFound() {

        buildFile << """
            tasks.register("noop") {
            }
        """

        when:
        mod.pom.expectGet()
        mod.artifact.expectGet()
        executer.withArguments("-I", "init.gradle")
        fails 'noop'

        then:
        failure.assertHasDescription """Dependency verification failed for configuration 'classpath'
2 artifacts failed verification: