def setup() {
        buildFile << """
repositories {
    flatDir { dir 'repo' }
}
"""
        fixture = new JvmLibraryArtifactResolveTestFixture(buildFile)
    }

    def "resolves and does not cache source and javadoc artifacts"() {
        publishModule()
        fixture.expectSourceArtifact("sources")
                .expectJavadocArtifact("javadoc")
                .prepare()

        when:

    String artifactVersion = "1.45-SNAPSHOT"
    MavenGcsModule module

    def setup() {
        module = getMavenGcsRepo().module("org.gradle", "test", artifactVersion)
    }

    def "resolves a maven snapshot module stored in Gcs"() {
        setup:
        module.publish()

        buildFile << mavenGcsRepoDsl()
        buildFile << """
configurations { compile }

dependencies{

import org.gradle.internal.service.scopes.ServiceScope;

import java.util.Collection;

@ServiceScope(Scope.Build.class)
public interface PluginResolverContributor {
    void collectResolversInto(Collection<PluginResolver> resolvers);

package org.gradle.api.internal.provider;

import org.gradle.api.provider.MapProperty;
import org.gradle.api.provider.Provider;

public class MapPropertyExtensions {

    /**
     * Returns a provider that resolves to the value of the mapping of the given key. It will have no value
     * if the property has no value, or if it does not contain a mapping for the key.
     *

 * changed or deleted without prior notice.
 *
 * @since 3.0
 */
public interface PluginDependenciesResolver {

    /**
     * Resolves the main artifact of the specified plugin.
     *
     * @param plugin The plugin for which to resolve the main artifact, must not be {@code null}.

	// resource instance is suitable. The language is as defined in
	// https://kubernetes.io/docs/reference/using-api/cel/
	//
	// In addition, for each type NamedResourcesin AttributeValue there is a map that
	// resolves to the corresponding value of the instance under evaluation.
	// For example:
	//
	//    attributes.quantity["a"].isGreaterThan(quantity("0")) &&
	//    attributes.stringslice["b"].isSorted()
	Selector string
}

                        new File("$userHomeDir/caches/$it").deleteDir()
                    }
                }
            }
        }
    }

    def "resolves dependencies from external repository"() {
        startServer()

        given:
        runner.tasksToRun = ['resolveDependencies']

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);

        _ * 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)

        }
    }
}

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 {