/**
     * Returns true if this version has a method for tests display names
     */
    boolean isHasTestDisplayNames();

    /**
     * Returns true if this version supports custom toolchain resolvers.
     */
    boolean isSupportsCustomToolchainResolvers();

    /**
     * Returns true if this version uses the non-flaky toolchain provisioning mechanism introduced in 8.9.
     */

import org.gradle.internal.declarativedsl.schemaBuilder.schemaFromTypes
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals


object DomResolutionTest {

    @Test
    fun `resolves declarative document`() {
        val resolver = tracingCodeResolver()

        val topLevelBlock = parseAsTopLevelBlock(
            """
            addAndConfigure("test") {
                number = 123

        projectDependency.transitive
        projectDependency.name == project.name
        projectDependency.group == "org.gradle"
        projectDependency.version == "1.2"
    }

    void "transitive resolution resolves all dependencies"() {
        def context = Mock(org.gradle.api.internal.artifacts.CachingDependencyResolveContext)

        def superConf = project.configurations.create("superConf")

<2> *Configuration*: Gradle configures each project by executing the `build.gradle(.kts)` files. It resolves dependencies and creates a dependency graph of all the available tasks.
<3> *Execution*: Gradle executes the tasks passed on the command line and any prerequisite tasks.

     */
    private final URI testRepoUri

    ApiMavenResolver(File localRepoDir, URI testRepoUri) {
        this.localRepoDir = localRepoDir
        this.testRepoUri = testRepoUri
    }

    /**
     * Resolves the provided dependency, returning the dependency graph and resolved artifacts.
     */
    MavenResolutionResult resolveDependency(String group, String module, String version) {
        long time = System.currentTimeMillis()

                // implicit invoke call. For example,
                // ```
                // fun test(f: () -> Unit) {
                //   f() // calleeExpression `f` resolves to the local variable access, while `f()` resolves to the implicit `invoke` call.
                //       // This way `f` is also the explicit receiver of this implicit `invoke` call
                // }
                // ```

            org.eclipse.aether.graph.Dependency d = n.getDependency();
            return d == null || scopes.contains(d.getScope());
        };
    }

    /**
     * Collects, flattens and resolves the dependencies.
     *
     * @param request the request to resolve
     * @return the result of the resolution
     */
    @Override
    public DependencyResolverResult resolve(DependencyResolverRequest request)

        LinkedList<ComponentMetaDataResolveState> queue = new LinkedList<>(resolveStates);

        LinkedList<ComponentMetaDataResolveState> missing = new LinkedList<>();

        // A first pass to do local resolves only
        RepositoryChainModuleResolution best = findBestMatch(queue, failures, missing);
        if (hasCriticalFailure(failures)) {
            return null;
        }
        if (best != null) {

	// DNS search list), this option causes such errors to abort the
	// whole query instead of returning a partial result. This is
	// not enabled by default because it may affect compatibility
	// with resolvers that process AAAA queries incorrectly.
	StrictErrors bool

	// Dial optionally specifies an alternate dialer for use by
	// Go's built-in DNS resolver to make TCP and UDP connections

        assertResolvesTo("foo-1.0.jar", "bar-1.0.jar")

        repo.expectListVersions()
        assertResolvesTo("foo-1.0.jar", "bar-1.0.jar")
    }

    @ToBeFixedForConfigurationCache
    def "only resolves a single project of multi-project source dependency"() {
        mavenRepo.module("org.test", "bar", "1.0-SNAPSHOT").withNonUniqueSnapshots().publish()
        mappingFor(repo, "org.test:foo")
        buildFile << """