}

    @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")

import org.gradle.internal.resolve.resolver.ComponentMetaDataResolver;
import org.gradle.internal.resolve.result.BuildableComponentResolveResult;

/**
 * A component metadata resolver which should be used first in chain of resolvers as it will make sure
 * that we never "find" a virtual component, by shortcutting resolution if we find the marker interface
 * for virtual components.
 */

        'project.javaexec'        | 'runWithJavaExec'
        'ExecOperations.javaexec' | 'runWithExecOperations'
        // The test does not work with the JavaExec task because the task resolves the executable prior to starting the process.
        // At the same time, all the cases test the same functionality of the ExecHandle implementation.
        // 'JavaExec task'           | 'run'
    }

 * Additional fields in this interface are not required to reconstitute the serialized graph.
 */
public interface DependencyGraphComponent extends ResolvedGraphComponent {
    /**
     * Returns the meta-data for the component. Resolves if not already resolved.
     *
     * @return null if the meta-data is not available due to some failure.
     */
    @Nullable
    ComponentGraphResolveMetadata getMetadataOrNull();

 * Responsible for resolving a {@link ComponentIdentifier} to a {@link org.gradle.internal.component.model.ComponentGraphResolveState} instance for that component.
 */
public interface ComponentMetaDataResolver {
    /**
     * Resolves the resolution state for a component instance. Failures should be attached to the returned result.
     */

package org.gradle.execution.plan;

import org.gradle.api.Action;
import org.gradle.api.Task;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Resolves dependencies to {@link TaskNode} objects. Uses the same logic as {@link #TASK_AS_TASK}.
 */
@ServiceScope(Scope.Build.class)
public class TaskNodeDependencyResolver implements DependencyResolver {