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 {

import java.util.stream.Collectors;

public class EnvironmentVariableListInstallationSupplier implements InstallationSupplier {

    public static final String JAVA_INSTALLATIONS_FROM_ENV_PROPERTY = "org.gradle.java.installations.fromEnv";

    private final ToolchainConfiguration buildOptions;
    private final FileResolver fileResolver;
    private final Map<String, String> environment;

    @Inject

    resources:
      - nodes
    verbs:
      - get
      - list
      - watch
  # These permissions are only required for upgrade from v2.6, and can
  # be removed after upgrade or on fresh installations.
  - apiGroups: ["crd.projectcalico.org"]
    resources:
      - bgpconfigurations
      - bgppeers
    verbs:
      - create
      - update

        then:
        1 * logger.log(LogLevel.WARN, "message")
        1 * logger.log(LogLevel.WARN, "another message")
    }

    def "reports problems with auto-detected installations at INFO"() {
        when:
        problemReporter.reportProblemIfNeeded(logger, InstallationLocation.autoDetected(location, "source"), "message")
        then:
        1 * logger.log(LogLevel.INFO, "message")
    }

import org.gradle.jvm.toolchain.internal.JavaToolchainQueryService;

import javax.inject.Inject;

/**
 * A plugin that provides JVM toolchains for projects that need to execute Java from local JVM installations or run the tools included in a JDK.
 * The plugin makes {@link JavaToolchainService} available via a project extension.
 *
 * @since 7.6
 */
@Incubating