def artifactDir = new File(rootDir, "${groupId.replace('.', '/')}/$artifactId/$version")
        def module = new MavenModule(artifactDir, groupId, artifactId, version as String)
        module.mavenJarCreator = mavenJarCreator
        modules << module
        return module
    }

    void publish() {
        modules.each {
            it.publish()
        }
    }

  <artifactId>construct</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <profiles>
    <profile>
      <id>dist</id>
      <modules>
        <module>maven-inherit-plugin</module>
        <module>maven-pax-plugin</module>
      </modules>
    </profile>
    </profiles>

        ideaProject.modules.find { it.name == 'test-project' }.javaLanguageSettings.jdk == null
        ideaProject.modules.find { it.name == 'child1' }.javaLanguageSettings.jdk == null
        ideaProject.modules.find { it.name == 'child2' }.javaLanguageSettings.jdk == null
    }

    def "synched module bytecode level marked as inherited"() {

        when:

        """
    }

    Modules setupBuildWithArtifactDownloadDuringTaskExecution() {
        def modules = setupBuildWithDependencies()
        addResolveTask()
        modules.expectResolved()
        return modules
    }

    Modules setupBuildWithFailedArtifactDownloadDuringTaskExecution() {
        def modules = setupBuildWithDependencies()
        addResolveTask()
        modules.expectResolveFailure()

source "${KUBE_ROOT}/hack/lib/init.sh"

# These are "internal" modules.  For various reasons, we want them to be
# decoupled from their parent modules.
MODULES=()                                                                                                                                                                   
kube::util::read-array MODULES < <(
    git ls-files -cmo --exclude-standard -- ':!:vendor/*' ':(glob)*/**/go.work' \

        when: "Module meta-data is changed (new artifact)"
        module.artifact([name: 'other'])
        module.dependsOn("group", "projectB", "2.0")
        module.publish()
        def moduleB = ivyHttpRepo.module("group", "projectB", "2.0").publish()

        and: "Server handles requests"
        server.resetExpectations()
        // Server will be hit to get updated versions
        module.ivy.expectHead()

include::sample[dir="groovy",files="build.gradle"]
====

=== Removing the local module source

With module artifacts available in a repository, we can now remove the module sources from the build. Since the composite is configured to automatically load available modules, this is as easy as deleting one or more module directories.

```
rm -r modules/string-utils
gradle run
```

				<version>4.13.1</version>
				<scope>test</scope>
			</dependency>
		</dependencies>
  </dependencyManagement>

  <modules>
    <module>../webinar-api</module>
    <module>../webinar-impl</module>
    <module>../webinar-war</module>
  </modules>

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

cp correct_modules.txt vendor/modules.txt
go build ./vendor/foo.com/internal/bar/a

# For go versions < 1.23, vendored packages that are missing in modules.txt should not result in an error.
cp 122go.mod go.mod

cp incorrect_modules.txt vendor/modules.txt

# go version < 1.23 and incorrect_modules is missing foo.com/internal/bar/b so the build should not fail

## Structure

Each platform and module has its own source directory under [platforms/](../platforms).
In these source directories, you will find the Gradle projects that make up the platform or module.

The platforms and modules are defined using a DSL in [settings.gradle.kts](../settings.gradle.kts)