}

    @Override
    public boolean test(JvmInstallationMetadata metadata) {
        Predicate<JvmInstallationMetadata> predicate = languagePredicate().and(vendorPredicate()).and(this::implementationTest);
        return predicate.test(metadata);
    }

    private Predicate<JvmInstallationMetadata> languagePredicate() {
        return metadata -> {

import org.gradle.api.tasks.diagnostics.internal.TextReportRenderer;
import org.gradle.internal.jvm.inspection.JvmInstallationMetadata;
import org.gradle.internal.jvm.inspection.JvmToolchainMetadata;
import org.gradle.internal.logging.text.StyledTextOutput;

import java.util.List;

import static org.gradle.internal.jvm.inspection.JvmInstallationMetadata.JavaInstallationCapability.JAVA_COMPILER;

    }

    private int getVersionFromJavaHome(File javaHome) {
        JvmInstallationMetadata metadata = validate(detector.getMetadata(InstallationLocation.autoDetected(javaHome, "specific path")));
        return JavaVersionParser.parseMajorVersion(metadata.getJavaVersion());
    }

    private JvmInstallationMetadata validate(JvmInstallationMetadata metadata) {
        if(metadata.isValidInstallation()) {
            return metadata;

import org.gradle.internal.jvm.inspection.JvmInstallationMetadata

class GradleBuildJvmSpec implements Spec<JvmInstallationMetadata> {

    static boolean isAvailable() {
        return AvailableJavaHomes.getAvailableJdk(new GradleBuildJvmSpec()) != null
    }

    @Override
    boolean isSatisfiedBy(JvmInstallationMetadata jvm) {
        return jvm.languageVersion == JavaVersion.VERSION_11
    }

package org.gradle.internal.jvm.inspection;

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

public class JvmToolchainMetadata {

    public JvmInstallationMetadata metadata;

    public InstallationLocation location;

    public JvmToolchainMetadata(JvmInstallationMetadata metadata, InstallationLocation location) {
        this.metadata = metadata;
        this.location = location;
    }

import org.gradle.internal.jvm.inspection.JvmInstallationMetadata;
import org.gradle.internal.os.OperatingSystem;
import org.gradle.jvm.toolchain.JavaInstallationMetadata;
import org.gradle.jvm.toolchain.JavaLanguageVersion;

public class JavaToolchain implements Describable, JavaInstallationMetadata {

    static JavaLanguageVersion getJavaLanguageVersion(JvmInstallationMetadata metadata) {

                    ConditionalInvalidation<JvmInstallationMetadata> checkedInvalidationFromDetector =
                        predicate -> ((ConditionalInvalidation<?>) globalJvmMetadataDetector).invalidateItemsMatching(item ->
                            item instanceof JvmInstallationMetadata && predicate.test((JvmInstallationMetadata) item)
                        );
                    serviceRegistration.add(

import java.util.HashMap;
import java.util.Map;
import java.util.function.Predicate;

public class CachingJvmMetadataDetector implements JvmMetadataDetector, ConditionalInvalidation<JvmInstallationMetadata> {

    private final Map<File, JvmInstallationMetadata> javaMetadata = Collections.synchronizedMap(new HashMap<>());
    private final JvmMetadataDetector delegate;

    public CachingJvmMetadataDetector(JvmMetadataDetector delegate) {

public class DefaultJavaToolchainUsageProgressDetails implements JavaToolchainUsageProgressDetails {

    private final JavaTool toolName;

    private final JvmInstallationMetadata toolchainMetadata;

    public DefaultJavaToolchainUsageProgressDetails(JavaTool toolName, JvmInstallationMetadata toolchainMetadata) {
        this.toolName = toolName;
        this.toolchainMetadata = toolchainMetadata;
    }

    @Override

    }

    def "emits toolchain usages for a custom task that uses two different toolchains"() {
        def task = ":myToolchainTask"

        JvmInstallationMetadata jdkMetadata1 = AvailableJavaHomes.getJvmInstallationMetadata(Jvm.current())
        JvmInstallationMetadata jdkMetadata2 = AvailableJavaHomes.getJvmInstallationMetadata(AvailableJavaHomes.differentVersion)

        buildFile << """