.map(variant -> dependencyCoordinateResolverFactory
                .createCoordinateResolvers(variant, versionMappingStrategy)
                .map(resolvers -> getDependenciesForVariant(variant, resolvers, coordinates))
            ).collect(Collectors.toList());

        return new MergeProvider<>(parsedVariants).map(variants -> {
            List<MavenDependency> dependencies = new ArrayList<>();

					}
				}
			})
		}
	}
}

// Baseline:
//   - ~150us via agent if cached for A/AAAA
//   - ~300us via agent when doing the cname redirect
//   - 5-6ms to upstream resolver directly
//   - 6-7ms via agent to upstream resolver (cache miss)
//
// Also useful for load testing is using dnsperf. This can be run with:
//

    }

    @Override
    public boolean isDynamicResolveMode() {
        return false;
    }

    @Override
    public void setComponentResolvers(ComponentResolvers resolver) {
        this.componentResolvers = resolver;
    }

    protected ExternalResourceRepository getRepository() {
        return repository;
    }

    @Override
    public boolean isLocal() {
        return local;

                            attribute(Attribute.of('other', String), 'foobar')
                        }
                    }.files)
                }
                
                tasks.register('resolveAll', Resolve) {
                    artifacts.from(configurations.producerArtifacts)
                    artifacts.from(configurations.producerArtifacts.incoming.artifactView {
                        withVariantReselection()

[source,kotlin]
----
plugins {
    id("org.gradle.toolchains.foojay-resolver-convention") version "0.7.0"
}

rootProject.name = "authoring-tutorial"

include("app")
include("lib") // Add lib to the build
----
=====
[.multi-language-sample]
=====
.settings.gradle
[source, groovy]
----
plugins {
    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'
}

import org.apache.maven.internal.impl.*;
import org.apache.maven.internal.impl.model.*;
import org.apache.maven.internal.impl.resolver.DefaultVersionRangeResolver;
import org.apache.maven.internal.impl.resolver.DefaultVersionResolver;
import org.apache.maven.internal.impl.resolver.MavenVersionScheme;
import org.apache.maven.internal.impl.resolver.type.DefaultTypeProvider;
import org.eclipse.aether.DefaultRepositorySystemSession;

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.resolver

import com.nhaarman.mockito_kotlin.doReturn
import com.nhaarman.mockito_kotlin.mock
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.kotlin.dsl.fixtures.AbstractKotlinIntegrationTest

import org.gradle.util.AttributeTestUtil
import org.gradle.util.TestUtil
import spock.lang.Specification

class DefaultConfigurationContainerTest extends Specification {

    private ConfigurationResolver resolver = Mock(ConfigurationResolver)
    private ListenerManager listenerManager = Stub(ListenerManager.class)
    private DependencyMetaDataProvider metaDataProvider = Mock(DependencyMetaDataProvider.class)

    /**
     * @since 3.1
     * @deprecated Since 3.9 there is no direct Maven2 interop offered at LRM level. See
     * <a href="https://maven.apache.org/resolver/configuration.html">Resolver Configuration</a> page option
     * {@code aether.artifactResolver.simpleLrmInterop} that provides similar semantics. This method should
     * be never invoked, and always returns {@code false}.
     */

[source, kotlin]
----
plugins {
    // Apply the foojay-resolver plugin to allow automatic download of JDKs
    id("org.gradle.toolchains.foojay-resolver-convention") version "0.7.0"
}

rootProject.name = "tutorial"
include("app")
----
=====
[.multi-language-sample]
=====
.settings.gradle
[source, groovy]
----
plugins {
    // Apply the foojay-resolver plugin to allow automatic download of JDKs