import org.gradle.internal.resolve.resolver.ArtifactResolver;
import org.gradle.internal.resolve.resolver.ComponentMetaDataResolver;
import org.gradle.internal.resolve.resolver.DependencyToComponentIdResolver;
import org.gradle.internal.resolve.result.BuildableArtifactResolveResult;
import org.gradle.internal.resolve.result.BuildableArtifactSetResolveResult;
import org.gradle.internal.resolve.result.BuildableComponentIdResolveResult;

public interface VariantArtifactResolver {
    /**
     * Creates an adhoc resolved variant which resolves the provided artifacts of the component.
     */
    ResolvedVariant resolveAdhocVariant(ComponentArtifactResolveMetadata component, ImmutableList<? extends ComponentArtifactMetadata> artifacts);

    /**
     * Resolves the given variant metadata to its artifacts.
     */

executable: gradle
args: resolve
expect-failure: true
expected-output-file: resolve.out
allow-additional-output: true

                add()
            }
            """.trimIndent()
        )

        resolver.resolve(schema, emptyList(), topLevelBlock)

        val document = convertBlockToDocument(topLevelBlock)
        val resolved = resolutionContainer(schema, resolver.trace, document)
        val resolutions = resolved.collectToMap(document).values
        assertEquals(

import org.gradle.internal.model.CalculatedValueFactory;
import org.gradle.internal.resolve.ModuleVersionResolveException;
import org.gradle.internal.resolve.resolver.ComponentMetaDataResolver;
import org.gradle.internal.resolve.result.BuildableComponentResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleComponentMetaDataResolveResult;
import org.gradle.internal.resolve.result.DefaultBuildableComponentResolveResult;
import org.slf4j.Logger;

executable: gradle

        then:
        config.state == RESOLVED

        and:
        1 * resolver.resolveGraph(config) >> graphResolved()
        1 * resolver.getAllRepositories() >> []
        0 * resolver._

        when:
        config.incoming.getResolutionResult().root

        then:
        config.state == RESOLVED
        0 * resolver._
    }

                return RuntimeFunctionResolver.Resolution.Resolved(ReflectionFunction(function, configureLambdaHandler))
            }
        }

        return RuntimeFunctionResolver.Resolution.Unresolved
    }
}


class CompositeFunctionResolver(private val resolvers: List<RuntimeFunctionResolver>) : RuntimeFunctionResolver {

        1 * context.accept(_) >> { FileCollectionInternal collection ->
            collection.files == [file] as Set
        }
        0 * context._
    }

    def "resolves Path"() {
        def file = new File('some-file')
        def path = new File('path').path

        when:
        visitor.add(path)

        then:
        1 * resolver.resolve(path) >> file

        }

        @Override
        protected Directory fromFile(File dir) {
            File resolved = resolver.resolve(dir);
            FileResolver dirResolver = resolver.newResolver(resolved);
            return new FixedDirectory(resolved, dirResolver, fileCollectionFactory.withResolver(dirResolver));
        }

        @Override