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

    /**

                .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', " +

import org.gradle.integtests.resolve.AbstractModuleDependencyResolveTest
import spock.lang.Issue

class ArtifactAndClassifierCompatibilityIntegrationTest extends AbstractModuleDependencyResolveTest {

    def "resolves a dependency with classifier targeting module without GMM"() {
        given:
        repository {
            'org:foo:1.0' {
                dependsOn(group: 'org', artifact:'bar', version:'1.0', classifier:'classy')

*/

package unstructured

import (
	"strings"

	"k8s.io/apiserver/pkg/cel/mutation/common"
)

const object = common.RootTypeReferenceName

type TypeResolver struct {
}

// Resolve resolves the TypeRef for the given type name
// that starts with "Object".
// This is the unstructured version, which means the
// returned TypeRef does not refer to the schema.

 * 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:

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvableArtifact;
import org.gradle.internal.component.model.ComponentArtifactMetadata;

import java.util.List;
import java.util.Set;

/**
 * Resolves artifact metadata into concrete files in the context
 * of a component.
 */
public interface ComponentArtifactResolver {
    Set<ResolvableArtifact> resolveArtifacts(List<? extends ComponentArtifactMetadata> artifacts);

            this.workingDirResolver = workingDirResolver;
        }

        @Override
        public void create(Collection<ComponentResolvers> resolvers, LocalComponentRegistry localComponentRegistry) {
            if (vcsResolver.hasRules()) {
                resolvers.add(new VcsDependencyResolver(
                    localComponentRegistry, vcsResolver, versionControlSystemFactory,

    ModelRegistry getRegistry();

    /**
     * Contextualizes the given action.
     *
     * - Resolved subject and input paths relative to the target element.
     * - Resolves subject type references relative to the target element.
     * - Adds implicit inputs.
     *
     * The returned action invokes the provided action with a {@link ModelRuleInvoker} contextualized with implicit inputs.
     */

class SnapshotWatchedDirectoryFinderTest extends Specification implements TestSnapshotFixture {

    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    def "resolves directory to watch from snapshot"() {
        def parent = temporaryFolder.createDir("parent")
        def dir = parent.createDir("dir")
        def file = parent.createFile("file.txt")