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(

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

        return RuntimeFunctionResolver.Resolution.Unresolved
    }
}


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

import org.apache.maven.api.annotations.Nonnull;

/**
 * Resolves artifact meta/pseudo versions.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface VersionResolver extends Service {

    /**
     * Resolves an artifact's meta version (if any) to a concrete version. For example, resolves "1.0-SNAPSHOT"
     * to "1.0-20090208.132618-23" or "RELEASE"/"LATEST" to "2.0".
     *

     * platform-specific file separator if a base directory is given. Otherwise, the input path will be returned
     * unaltered.
     *
     * @param path The path to resolve, may be {@code null}.
     * @param basedir The base directory to resolve relative paths against, may be {@code null}.

import org.gradle.internal.resolve.ModuleVersionResolveException;
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;

 * under the License.
 */
package org.apache.maven.api.services.model;

import java.nio.file.Path;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
public interface PathTranslator {

    /**
     * Resolves the specified path against the given base directory. The resolved path will be absolute and uses the

 * The only purpose of this class is to expose the resolution [trace] to the consumers.
 */
class TracingResolver(
    private val resolver: Resolver,
    val trace: ResolutionTrace
) : Resolver {
    override fun resolve(schema: AnalysisSchema, imports: List<Import>, topLevelBlock: Block): ResolutionResult = resolver.resolve(schema, imports, topLevelBlock)

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

/**
 * Resolves relative paths of a model against a specific base directory.
 *
 */
public interface ModelPathTranslator {

    /**
     * Resolves the well-known paths of the specified model against the given base directory. Paths within plugin
     * configuration are not processed.
     *
     * @param model The model whose paths should be resolved, may be {@code null}.

        JavaToolchainResolver resolver = Mock(JavaToolchainResolver)
        resolver.resolve(_ as JavaToolchainRequest) >> download
        resolver
    }

    private JavaToolchainResolver mockResolver(Throwable resolveFailure) {
        JavaToolchainResolver resolver = Mock(JavaToolchainResolver)
        resolver.resolve(_ as JavaToolchainRequest) >> { throw resolveFailure }
        resolver