realizeRepositories();
    }

    private void realizeRepositories() {
        realizedRepositories.clear();

        Set<Class<?>> resolvers = new HashSet<>();
        for (JavaToolchainRepository repository : repositoryHandler.getAsList()) {
            if (!resolvers.add(repository.getResolverClass().get())) {

import org.gradle.internal.reflect.annotations.AnnotationCategory;

import javax.annotation.Nullable;
import java.lang.annotation.Annotation;
import java.util.Map;

/**
 * Resolves the type of the property, denoted by an annotation.
 */
public interface PropertyTypeResolver {
    @Nullable
    Class<? extends Annotation> resolveAnnotationType(Map<AnnotationCategory, Annotation> propertyAnnotations);

        }
    }
}

data class DefaultVersion(val version: String, val because: String)

fun findDefaultVersionInCatalog(group: String, name: String): DefaultVersion {
    //some custom logic that resolves the default version into a specific version
    return DefaultVersion(version = "1.0", because = "tested by QA")
}
// end::custom-versioning-scheme[]

// tag::denying_version[]
configurations.all {

        _ * projectRegistry.stateFor(_) >> projectState
        _ * projectState.applyToMutableState(_) >> { Consumer consumer -> consumer.accept(Stub(ProjectInternal)) }
    }

    def "resolves project dependency"() {
        setup:
        def selector = TestComponentIdentifiers.newSelector(":project")
        def componentState = Mock(LocalComponentGraphResolveState)

 * taking into account whether dependency mapping or version mapping is enabled.
 */
public interface DependencyCoordinateResolverFactory {

    /**
     * Create coordinate resolvers for the given variant.
     */
    Provider<DependencyResolvers> createCoordinateResolvers(SoftwareComponentVariant variant, VersionMappingStrategyInternal versionMappingStrategy);

    /**

        /**
         * Called when an expression resolves to a quoted path.
         */
        void visitQuoted(Expression value);

        /**
         * Called when an expression resolves to a system path.
         */
        void visitSystem(Expression value);

        /**
         * Called when an expression resolves to a single identifier that could not be macro expanded.
         */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.file;

/**
 * Resolves a path object relative to some base directory.
 */
public interface RelativeFilePathResolver {
    /**
     * Converts the given path to a relative path.
     */
    String resolveAsRelativePath(Object path);

    }

    @Override
    boolean defaultAllowInsecureProtocol() {
        return true
    }

    void beforeServerStart() {
        // No-op
    }

    def "fails to resolves module artifacts via HTTP redirect"() {
        given:
        buildFile << configurationWithIvyDependencyAndExpectedArtifact('group:projectA:1.0', 'projectA-1.0.jar', false)

        when:

        e.message == "Cannot locate tasks that match ':pr:task' as project 'pr' is ambiguous in <root project>. Candidates are: 'proj', 'proj1', 'proj2', 'proj3'."
    }

    def "lazily resolves an exclude name to tasks in the target build"() {
        when:
        def filter = selector.resolveExcludedTaskName(target, "task")

        then:
        filter.build == target

        and:

                .assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +
                    "Some toolchain resolvers had provisioning failures: custom (Unable to download toolchain matching the requirements " +
                    "({languageVersion=99, vendor=matching('exotic'), implementation=vendor-specific}) from '$archiveUri', " +