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

     * This method does not handle the patch-module paths, because the patches
     * depend on which modules have been previously added on the module-paths.
     *
     * <p>If the dependency can be a constituent of both the class-path and the module-path,
     * then the path type is determined by checking if the dependency is modular.</p>
     *
     * @param types types of path where a dependency can be placed

if _tf_uses_legacy_keras:
  _module_dir = _module_util.get_parent_dir_for_name("tf_keras.api._v2.keras")
else:
  _module_dir = _module_util.get_parent_dir_for_name("keras.api._v2.keras")
_current_module.__path__ = [_module_dir] + _current_module.__path__


# Enable TF2 behaviors
from tensorflow.python.compat import v2_compat as _compat
_compat.enable_v2_behavior()
_major_api_version = 2

     * Returns the unique name of this path type, including the module to patch if any.
     * For example, if this type is {@link JavaPathType#MODULES}, then this method returns {@code "MODULES"}.
     * But if this type was created by {@code JavaPathType.patchModule("foo.bar")}, then this method returns
     * {@code "PATCH_MODULE:foo.bar"}.
     *
     * @return the programmatic name together with the module name on which it applies
     * @see #toString()

          <configuration>
            <modules>
              <module>
                <test>test</test>
              </module>
              <jarModule>
                <groupId>artifactGroupId</groupId>
                <artifactId>artifactId</artifactId>
                <uri>APP-INF/lib/anotherName-1.2.3.jar</uri>
              </jarModule>
            </modules>
          </configuration>
        </plugin>

     */
    private static final String MODULE_INFO = "module-info.class";

    /**
     * The attribute for automatic module name in {@code META-INF/MANIFEST.MF} files.
     */
    private static final Attributes.Name AUTO_MODULE_NAME = new Attributes.Name("Automatic-Module-Name");

    /**
     * Module information for the path specified at construction time.

     * depending on whether {@link #CLASSES} or {@link #MODULES} is present.
     * </p>
     *
     * @param moduleName name of the module on which to apply the path
     * @return an identification of the patch-module path for the given module.
     *
     * @see Modular#moduleName()
     */
    @Nonnull
    public static Modular patchModule(@Nonnull String moduleName) {

## Decision

Organize the Gradle code base into a set of coarse-grained "architecture modules".
An architecture module is responsible for providing a 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".

  <groupId>lifecycle-participant-reactor-dependency-injection</groupId>
  <artifactId>parent</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <modules>
    <module>module-a</module>
    <module>module-b</module>
  </modules>

  <version>1.0</version>
  <packaging>pom</packaging>
  <modules>
    <module>module-2</module>
    <module>module-1</module>
    <module>module-3</module>
  </modules>
  <profiles>
    <profile>
      <id>a</id>
      <properties>
        <b>test-prop</b>
      </properties>
      <modules>
        <module>module-1</module>
        <module>module-4</module>
      </modules>
    </profile>
  </profiles>