parent files("parent.txt")
                things files("thing.txt")
            }

            task resolveIt(type: Sync) {
                from configurations.things
                into buildDir
            }
        """

        when:
        run "resolveIt"

        then:
        output.count("before :things") == 1
        output.count("after :things") == 1
    }

                dependencies {
                    implementation project(':b')
                }
                task prepare {
                    inputs.files configurations.resolver
                    doFirst {
                        configurations.resolver.files.name
                    }
                }
            }
            def files = project(':a').tasks.resolveArtifacts.collection.artifactFiles

import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
import org.apache.maven.artifact.repository.metadata.Versioning;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.repository.legacy.WagonManager;
import org.codehaus.plexus.logging.AbstractLogEnabled;

/**

    @Override
    AbstractFileCollection containing(File... files) {
        def resolver = Stub(FileResolver)
        _ * resolver.resolve(_) >> { File f -> f }
            return new DefaultConfigurableFileCollection("<display>", resolver, taskDependencyFactory, patternSetFactory, host).from(files)
    }

    def "resolves specified files using file resolver"() {
        given:
        def file1 = new File("1")

 * limitations under the License.
 */

package org.gradle.internal.resolve.resolver;

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.
 */

    private final List<Resolver> resolvers;
    private final Map<String, Set<NodeState>> capabilityWithoutVersionToNodes = new HashMap<>();
    private final Deque<CapabilityConflict> conflicts = new ArrayDeque<>();

    public DefaultCapabilitiesConflictHandler(List<Resolver> resolvers) {
        this.resolvers = resolvers;
    }

    @Override

import org.gradle.internal.model.CalculatedValueFactory;
import org.gradle.internal.resolve.resolver.ArtifactResolver;
import org.gradle.internal.resolve.result.BuildableArtifactFileResolveResult;
import org.gradle.internal.resolve.result.BuildableArtifactResolveResult;
import org.gradle.internal.resolve.result.BuildableArtifactSetResolveResult;
import org.gradle.internal.resolve.result.DefaultBuildableArtifactFileResolveResult;

import java.io.File;

        then:
        with (resolver.resolveComponent(ModuleVersionIdentifier, project.identityPath)) {
            group == "pub-group"
            name == "pub-name"
            version == "pub-version"
        }
    }

    def "resolve fails when target project has no publications with coordinate of requested type and no default available"() {
        when:
        resolver.resolveComponent(String, project.identityPath)

     * when:
     * <ul>
     *     <li>The {@link Configuration} itself is resolved</li>
     *     <li>Another {@link Configuration} that extends this one is resolved</li>
     *     <li>Another {@link Configuration} that references this one as a project dependency is resolved</li>
     * </ul>
     *
     * This method is useful for specifying default dependencies for a configuration:

		defer func() {
			visited.Delete(ref)
		}()
		// replace the whole schema with the referred one.
		resolved, ok := schemaOf(ref)
		if !ok {
			return nil, fmt.Errorf("internal error: cannot resolve Ref %q: %w", ref, ErrSchemaNotFound)
		}
		result = *resolved
		changed = true
	}
	// schema is an object, populate its properties and additionalProperties