def toolingApiInvoker = (ToolingApiGradleClient) buildInvoker
        toolingApiInvoker.runOperation(initialAction) { builder ->
            builder.setJvmArguments(jvmArgs)
            builder.withArguments(gradleArgs)
            tapiAction.accept(builder)
        }
    }

        generator.addWarning()
        generator.save()
        possibleFileLocations.put(generator.sourceFile.absolutePath, 1)

        when:
        executer.withArguments("--info")
        withInstallations(AvailableJavaHomes.getJdk(JavaVersion.VERSION_1_8))
        succeeds(":compileJava")

        then:
        outputContains(DiagnosticToProblemListener.FORMATTER_FALLBACK_MESSAGE)

        if (!parameterizedModelType.isParameterized()) {
            throw new IllegalArgumentException("Expecting a parameterized type, got: " + parameterizedType + ".");
        }
        return typeOf(parameterizedModelType.withArguments(modelTypeListFrom(typeArguments)));
    }

    private final ModelType<T> type;

    private TypeOf(ModelType<T> type) {
        this.type = type;
    }

    protected TypeOf() {

            .withTestKitDir(IntegrationTestBuildContext.INSTANCE.gradleUserHomeDir)
            .withProjectDir(testProjectDir)
            .forwardOutput()
            .withArguments(
                tasks.toList() + outputParameters() + repoMirrorParameters() + configurationCacheParameters() + toolchainParameters() + kotlinDslParameters()
            ) as DefaultGradleRunner

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

        gradleProvider.applyTo(gradleRunner)
        gradleRunner
    }

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

            ?: currentType

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

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

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