fun ComponentMetadataHandler.declareCapabilityPreference(module: String) {
        withModule<CapabilityRule>(module) {
            params(name)
            params("${providedBy.size + 1}")
        }
    }

    /**
     * For all modules providing a capability, always use the preferred module, even if there's no conflict.
     * In other words, will forcefully upgrade all modules providing a capability to a selected module.
     *

        // However, it appears that IDEA 2017 depends on this behaviour, and iterates over the included builds to get all modules
        allProjects.rootIdeaProject.name == 'buildA'
        allProjects.rootIdeaProject.modules.collect { it.name } == ['buildA']

        def moduleA = allProjects.rootIdeaProject.modules[0]
        moduleA.dependencies.each {

 */
package org.gradle.test.fixtures

import org.gradle.test.fixtures.gradle.VariantMetadataSpec

/**
 * Represents a module in a repository.
 */
interface Module {
    Module publish()
    Module publishWithChangedContent()
    Module withModuleMetadata()
    Module withSignature(@DelegatesTo(value = File, strategy = Closure.DELEGATE_FIRST) Closure<?> signer)

    String getGroup()
    String getModule()

          return registry;
        }()) {
    context_.loadAllAvailableDialects();

    mlir::OpBuilder builder(&context_);
    module_ = builder.create<mlir::ModuleOp>(builder.getUnknownLoc());

    builder.setInsertionPointToStart(module_->getBody());
    auto func = builder.create<mlir::func::FuncOp>(  //
        builder.getUnknownLoc(), "main", builder.getFunctionType({}, {}));

            }
        """

        when:
        def ideaProject = withConnection {
            action(new FetchIdeaProject()).run()
        }

        then:
        def moduleA = ideaProject.modules.find { it.name == 'a'}
        moduleA.dependencies[0].targetModuleName == 'b'
    }

    def "Applies gradle project identifier mapping"() {
        given:
        settingsFile << """
            include 'a'

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package module defines the module.Version type along with support code.
//
// The [module.Version] type is a simple Path, Version pair:
//
//	type Version struct {
//		Path string
//		Version string
//	}
//
// There are no restrictions imposed directly by use of this structure,

# Module gradle

# Kotlin DSL Reference for Gradle

Gradle’s Kotlin DSL provides an enhanced editing experience in supported IDEs, with superior content assistance, refactoring, documentation, and more.
For an introduction see the <a href="../userguide/kotlin_dsl.html">Kotlin DSL Primer</a>.

The Kotlin DSL is implemented on top of Gradle’s Java API.

        given:
        root {
            module1 {
                'module1.gradle'(this.taskThrowingError())
            }
            module2 {
                'module2.gradle'(this.taskThrowingError())
            }
            'settings.gradle'(this.settingsWithBuildScriptsUseProjectName('module1', 'module2'))
        }

        when:
        fails 'module1:someTask'

        then:

Such modules, that only have a name as module description, are called _automatic module_ that export **all** their packages and can read **all** modules on the module path.

A third case are traditional libraries that provide no module information at all -- for example `commons-cli:commons-cli:1.4`.
Gradle puts such libraries on the classpath instead of the module path.
The classpath is then treated as one module (the so called _unnamed_ module) by Java.

}

private inline fun buildDependentsMap(
    modules: List<KtModule>,
    getDependencies: (KtModule) -> Sequence<KtModule>,
): Map<KtModule, MutableSet<KtModule>> = buildMap<KtModule, MutableSet<KtModule>> {
    for (module in modules) {
        for (dependency in getDependencies(module)) {
            // `module` should not be part of its own dependents, per the contract of `KotlinModuleDependentsProvider`.