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.
     *
     * @param to the preferred module
     */
    private

  <groupId>test</groupId>
  <artifactId>test</artifactId>
  <version>0.1-SNAPSHOT</version>
  <packaging>pom</packaging>

  <modules>
    <module>lib</module> <!-- the library -->
    <module>app</module> <!-- the application -->
  </modules>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>

        assertEquals(project1.getScm().getUrl(), project0.getScm().getUrl() + "/modules/p1");
        assertEquals(project1.getScm().getConnection(), project0.getScm().getConnection() + "/modules/p1");
        assertEquals(
                project1.getScm().getDeveloperConnection(), project0.getScm().getDeveloperConnection() + "/modules/p1");
    }

    @Test

## Decision

Organize the Gradle code base into a set of coarse-grained "architecture modules".
An architecture module is responsible for providing some coherent set of features and:

- Provides a set of APIs and services for use from outside the module.
- Has a private implementation.
- Is owned by a single team. A team may own multiple architecture modules.

The modules are arranged into several different "Gradle platforms".

        override fun afterInvalidation(modules: Set<KtModule>) {
            modules.forEach { analysisSessionProvider.cache.remove(it) }
        }

        override fun afterGlobalInvalidation() {
            // Session invalidation events currently don't report whether library modules were included in the global invalidation. This is

!**/testData/**/*.iml
.idea/artifacts
.idea/remote-targets.xml
.idea/libraries/Gradle*.xml
.idea/libraries/Maven*.xml
.idea/modules
.idea/runConfigurations/JPS_*.xml
.idea/runConfigurations/_JPS_*.xml
.idea/runConfigurations/PILL_*.xml
.idea/runConfigurations/_FP_*.xml
.idea/runConfigurations/_MT_*.xml
.idea/libraries
.idea/modules.xml
.idea/gradle.xml
.idea/compiler.xml
.idea/inspectionProfiles/profiles_settings.xml
.idea/.name

  <scm>
    <connection>scm:svn:http://host/p0</connection>
    <developerConnection>scm:svn:https://host/p0</developerConnection>
    <url>http://host/viewer?path=/p0</url>
  </scm>

  <modules>
    <module>modules/p1</module>
  </modules>

  <name>Maven Integration Test :: MNG-4129</name>
  <description>
    Verify that plugin executions defined in the parent with inherited=false are not executed in child modules.
  </description>

  <modules>
    <module>child-1</module>
    <module>child-2</module>
  </modules>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.its.plugins</groupId>
        <artifactId>maven-it-plugin-log-file</artifactId>

        boolean classes = false;
        boolean modules = false;
        boolean unknown = false;
        for (PathType type : types) {
            if (filter.test(type)) {
                if (JavaPathType.CLASSES.equals(type)) {
                    classes = true;
                } else if (JavaPathType.MODULES.equals(type)) {
                    modules = true;
                } else {

             * If the test output directory provides some modules of its own, add them.
             * Except for this unusual case, tests should never be added to the module-path.
             */
            for (Map.Entry<Path, String> entry : testModules.getModuleNames().entrySet()) {
                if (!outputModules.containsModule(entry.getValue())) {
                    addPathElement(JavaPathType.MODULES, entry.getKey());