<target name="install.module">
		<get dest="${target.dir}">
			<url url="${repo.url}/${module.groupId}/${module.name.prefix}${module.name}/${module.version}/${module.name.prefix}${module.name}-${module.zip.version}.zip" />
		</get>
		<unzip dest="${modules.dir}/${module.name}" src="${target.dir}/${module.name.prefix}${module.name}-${module.zip.version}.zip">
			<patternset>
				<include name="**" />
			</patternset>
			<cutdirsmapper dirs="1" />

    /**
     * Returns the modules required by this module.
     */
    Set<Module> getRequiredModules();

    /**
     * Returns the transitive closure of all modules required by this module, including the module itself.
     */
    Set<Module> getAllRequiredModules();

    /**
     * Returns the implementation + runtime classpath of the transitive closure of all modules required by this module, including the module itself.

 * of project dependencies. This optimizes module loading during runtime, as we will only load external
 * modules that are not loaded transitively by other project modules.
 *
 * We perform this filtering, since if we simply include all external dependencies, regardless of whether
 * they are already loaded transitively, there is a measurable performance impact during module-loading.
 */

        allProjects.rootIdeaProject.name == 'module-main'
        allProjects.rootIdeaProject.modules.collect { it.name } == ['module-main', 'module-main-module-b']

        allProjects.getIdeaProject('module-main').modules.collect { it.name } == ['module-main', 'module-main-module-b']

  <modules>
    <module>maven-api-meta</module>
    <module>maven-api-di</module>
    <module>maven-api-xml</module>
    <module>maven-api-model</module>
    <module>maven-api-plugin</module>
    <module>maven-api-settings</module>
    <module>maven-api-toolchain</module>
    <module>maven-api-metadata</module>
    <module>maven-api-core</module>
    <module>maven-api-spi</module>
  </modules>

    }

    private Set<Module> allRequiredModulesOf(String... names) {
        Set<Module> modules = new HashSet<>();
        for (String name : names) {
            modules.addAll(moduleRegistry.getModule(name).getAllRequiredModules());
        }
        return modules;
    }

    private Set<Module> allRequiredModulesOfOptional(String moduleName) {
        Module optionalModule = moduleRegistry.findModule(moduleName);

    /**
     * Locates a module by name.
     *
     * @return the module. Does not return null.
     */
    Module getModule(String name) throws UnknownModuleException;

    /**
     * Tries to locate a module by name.
     *
     * @return the optional module, or {@literal null} if it cannot be found
     * @throws UnknownModuleException if the requested module is found but one of its dependencies is not
     */

    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.
     *

        def module = ideaProject.modules.find {it. name == 'root'}

        then:
        module.dependencies.size() == 11
        hasDependency(module, "a", "PROVIDED")
        hasDependency(module, "a", "RUNTIME")
        hasDependency(module, "a", "TEST")
        hasDependency(module, "f", "TEST")
        hasDependency(module, "b", "PROVIDED")
        hasDependency(module, "b", "RUNTIME")

            rootProject.name = 'module-root'
            includeBuild('module-a')
        """
        file('module-a').mkdir()
        file('module-b').mkdir()
        file('module-c').mkdir()
        file('module-a/settings.gradle') << """
            includeBuild('../module-b')
        """
        file('module-b/settings.gradle') << """
            includeBuild('../module-c')
        """