import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.jvm.toolchain.internal.InstallationLocation;

import java.util.function.BiConsumer;

/**
 * Reports invalid JVM installations with the provided logger `warn` level.
 */
public class InvalidInstallationWarningReporter implements BiConsumer<InstallationLocation, JvmInstallationMetadata> {

    private final Logger logger;

    applyDefaults(
        model,
        this,
        "compileAllBuild -PignoreIncomingBuildReceipt=true -DdisableLocalCache=true",
        extraParameters = buildScanTag("CompileAll") + " " + "-Porg.gradle.java.installations.auto-download=false"
    )

    artifactRules = """$artifactRules
        platforms/core-runtime/base-services/build/generated-resources/build-receipt/org/gradle/build-receipt.properties
    """.trimIndent()
}) {

    def "logs at info level when invalid toolchain file is provided"() {
        def toolchainsFile = file("toolchains.xml")
        executer.withArgument("-Porg.gradle.java.installations.maven-toolchains-file=${TextUtil.escape(toolchainsFile.absolutePath)}")
        executer.withToolchainDetectionEnabled()
        toolchainsFile << "not xml"

        when:
        succeeds 'javaToolchains', '--info'

import java.util.Set;
import java.util.stream.Collectors;

public class AutoInstalledInstallationSupplier implements InstallationSupplier {

    public static final String AUTO_DOWNLOAD = "org.gradle.java.installations.auto-download";

    private final ToolchainConfiguration configuration;
    private final JdkCacheDirectory cacheDirProvider;

    @Inject

        Collection<String> installations,
        InstallationLocation currentJvm = null,
        Function<String, String> getVersion = { it },
        Function<String, String> getVendor = { "" }
    ) {
        def detector = newJvmMetadataDetector(getVersion, getVendor)
        def registry = createInstallationRegistry(installations, detector)

        def jdks = AvailableJavaHomes.getJdks(versions)
        Assume.assumeTrue(versions.length == jdks.size())
        executer.beforeExecute {
            withArgument("-Porg.gradle.java.installations.paths=" + jdks.collect { it.javaHome.absolutePath }.join(","))
        }
    }

import spock.lang.Specification

class InvalidInstallationWarningReporterTest extends Specification {

    def mockLogger = Mock(Logger)

    def 'reporter logs only invalid installations'() {
        given:
        def reporter = new InvalidInstallationWarningReporter(mockLogger)
        def location = InstallationLocation.userDefined(new File("_"), "_")
        def metadata = Mock(JvmInstallationMetadata) {

import java.util.Set;

/**
 * A BuildSession-scoped service that reports JVM installation problems.
 *
 * <p>
 * This cannot be merged in to {@link DefaultJavaInstallationRegistry} as we must rediscover JVM installations on each build invocation,
 * as e.g. the {@code GradleBuild} task could be used to change the system properties and environment variables that affect the JVM installation.
 * </p>
 */
@NonNullApi
@ServiceScope(Scope.BuildSession.class)

    private static List<String> toolchainParameters() {
        return [
            "-Porg.gradle.java.installations.paths=${AvailableJavaHomes.getAvailableJvms().collect { it.javaHome.absolutePath }.join(",")}" as String,
            '-Porg.gradle.java.installations.auto-detect=false',
            '-Porg.gradle.java.installations.auto-download=false',
        ]
    }

    private static List<String> kotlinDslParameters() {

    def setup() {
        def jdk7 = AvailableJavaHomes.getJdk7()
        assumeNotNull(jdk7)
        file("gradle.properties").writeProperties("org.gradle.java.installations.paths": jdk7.javaHome.canonicalPath)
        buildFile << """
            apply plugin: 'java'
            ${mavenCentralRepository()}
            dependencies {