}

func (d *discoveryResourceResolver) Resolve(gvk schema.GroupVersionKind) (schema.GroupVersionResource, error) {
	gv := gvk.GroupVersion()
	// TODO: refactor this into an efficient gvk --> gvr resolver that remembers hits and re-resolves group/version info on misses
	resources, err := d.client.ServerResourcesForGroupVersion(gv.String())
	if err != nil {
		return schema.GroupVersionResource{}, err
	}

        }
        def id = newProjectId(":project")

        when:
        resolver.resolve(dependencyMetaData, null, null, result)

        then:
        1 * registry.getComponent(id) >> componentState
        1 * result.resolved(componentState, _)
        0 * result._
    }

    def "resolves project component"() {
        setup:
        def componentState = Mock(LocalComponentGraphResolveState)

 */

package org.gradle.internal.file;

import java.io.File;

/**
 * Resolves some path object to a `File`. May or may not be able to resolve relative paths.
 */
public interface PathToFileResolver {
    /**
     * Resolves the given path to a file.
     */
    File resolve(Object path);

    /**
     * Returns a resolver that resolves paths relative to the given base dir.
     */

			}
		}

		// resolve identifiers
		if importErrors {
			// don't use the universe scope without correct imports
			// (objects in the universe may be shadowed by imports;
			// with missing imports, identifiers might get resolved
			// incorrectly to universe objects)
			pkgScope.Outer = nil
		}
		i := 0
		for _, ident := range file.Unresolved {
			if !resolve(fileScope, ident) {

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(

executable: gradle

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

        return RuntimeFunctionResolver.Resolution.Unresolved
    }
}


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