* <p>
 * Plugin implementors have to provide the mapping from the Java toolchain request to a download information.
 *
 * @since 7.6
 */
@Incubating
public interface JavaToolchainResolver extends BuildService<BuildServiceParameters.None> {

    /**
     * Returns a {@link JavaToolchainDownload} if a Java toolchain matching the provided
     * specification can be provided.
     *

        Class<? extends JavaToolchainResolver> repositoryClass = getResolverClass(repository);
        Provider<? extends JavaToolchainResolver> provider = findProvider(repositoryClass);
        return new RealizedJavaToolchainRepository(provider, (JavaToolchainRepositoryInternal) repository);
    }

    private Provider<? extends JavaToolchainResolver> findProvider(Class<? extends JavaToolchainResolver> repositoryClass) {

 * to register their <code>JavaToolchainResolver</code> implementations/build services into.
 *
 * @since 7.6
 */
@Incubating
@HasInternalProtocol
public interface JavaToolchainResolverRegistry {

    /**
     * Registers a <code>JavaToolchainResolver</code> implementation. The class name should be properly

import org.gradle.api.provider.Property;

/**
 * Named configuration of {@link JavaToolchainResolver} implementations,
 * identified by their implementation class.
 * <p>
 * The implementation class is the only mandatory property (it identifies
 * the {@link JavaToolchainResolver} being configured; the name is arbitrary,
 * chosen by the build author).
 * <p>

import org.gradle.internal.authentication.AuthenticationInternal;
import org.gradle.jvm.toolchain.JavaToolchainResolver;

import javax.inject.Inject;
import java.net.URI;
import java.util.Collection;

public class RealizedJavaToolchainRepository {

    private final Provider<? extends JavaToolchainResolver> resolverProvider;

    private final JavaToolchainRepositoryInternal repository;

    @Inject

        }
    }

    private JavaToolchainResolver mockResolver(Optional<JavaToolchainDownload> download) {
        JavaToolchainResolver resolver = Mock(JavaToolchainResolver)
        resolver.resolve(_ as JavaToolchainRequest) >> download
        resolver
    }

    private JavaToolchainResolver mockResolver(Throwable resolveFailure) {
        JavaToolchainResolver resolver = Mock(JavaToolchainResolver)

import java.util.Optional;
import java.net.URI;
import org.gradle.jvm.toolchain.JavaToolchainResolver;
import org.gradle.jvm.toolchain.JavaToolchainRequest;
import org.gradle.jvm.toolchain.JavaToolchainDownload;

// tag::java-toolchain-resolver-implementation[]
public abstract class JavaToolchainResolverImplementation
        implements JavaToolchainResolver { // <1>

plugins {
    id("org.gradle.toolchains.foojay-resolver") version("0.8.0")
}

import org.gradle.api.Plugin
import org.gradle.api.initialization.Settings
import org.gradle.jvm.toolchain.JavaToolchainResolver
import org.gradle.jvm.toolchain.JavaToolchainResolverRegistry
import java.net.URI
import java.util.Optional
import javax.inject.Inject

apply<MadeUpPlugin>()

// tag::toolchain-management[]
toolchainManagement {
    jvm { // <1>

.JavaToolchainResolverImplementation.java
[source,java]
----
include::{snippetsPath}/java/toolchain-management/groovy/buildSrc/src/main/java/org/myorg/JavaToolchainResolverImplementation.java[tags=java-toolchain-resolver-implementation]
----

import org.gradle.api.provider.Property;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.authentication.Authentication;
import org.gradle.jvm.toolchain.JavaToolchainResolver;

import javax.inject.Inject;
import java.util.Collection;

public abstract class DefaultJavaToolchainRepository implements JavaToolchainRepositoryInternal {

    private final String name;