Java Modules are a feature of Java itself, available since Java 9, that allows for better encapsulation.

In Gradle, each _source set_ containing Java sources can be turned into a module by adding a `module-info.java` file.
Typically, in a project with Java Modules like this one, the _main_ source set of a subproject represents a module.

```
src
└── main
    └── java

var HelpModules = &base.Command{
	UsageLine: "modules",
	Short:     "modules, module versions, and more",
	Long: `
Modules are how Go manages dependencies.

A module is a collection of packages that are released, versioned, and
distributed together. Modules may be downloaded directly from version control
repositories or from module proxy servers.

For a series of tutorials on modules, see
https://golang.org/doc/tutorial/create-module.

stderr 'directory a[\\/]c is contained in a module that is not one of the workspace modules listed in go.work. You can add the module to the workspace using:\n\tgo work use a'

cd a/c
! go run .
stderr 'current directory is contained in a module that is not one of the workspace modules listed in go.work. You can add the module to the workspace using:\n\tgo work use \.\.'

cd ../..
! go run .

# 'go clean' should skip the current directory if it isn't in a module.
go clean -n
! stdout .
! stderr .

# 'go mod graph' should fail, since there's no module graph.
! go mod graph
stderr '^go: go.mod file not found in current directory or any parent directory; see ''go help modules''$'

# 'go mod why' should fail, since there is no main module to depend on anything.

}

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

# main modules from the build list incorrectly, leading to the workspace
# modules being checked for correct sums. Specifically this would happen when
# the module name sorted after the virtual 'go' version module name because
# it could not get chopped off when we removed the MainModules.Len() modules
# at the beginning of the build list and we would remove the go module instead.

go mod verify

-- go.work --

go work vendor
cmp modules.txt.want vendor/modules.txt
go list example.com/a example.com/b

# Module required in go.mod but not marked explicit in modules.txt
cp modules.txt.required_but_not_explicit vendor/modules.txt
! go list example.com/a example.com/b
cmpenv stderr required_but_not_explicit_error.txt

# Replacement in go.mod but no replacement in modules.txt
cp modules.txt.missing_replacement vendor/modules.txt
! go list example.com/a example.com/b

        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()
        }
    }

        Preconditions.checkNotNull(moduleManager);
        Node modules = findFirstChildNamed(moduleManager, "modules");
        if (modules == null) {
            modules = moduleManager.appendNode("modules");
        }
        return modules;
    }

    private Node findCompilerConfiguration() {

import org.gradle.integtests.fixtures.AbstractHttpDependencyResolutionTest

class LazyDownloadsIntegrationTest extends AbstractHttpDependencyResolutionTest {
    def module = mavenHttpRepo.module("test", "test", "1.0").publish()
    def module2 = mavenHttpRepo.module("test", "test2", "1.0").publish()

    def setup() {
        createDirs("child")
        settingsFile << "include 'child'"
        buildFile << """