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')
        """

specified in the workspace (with use directives).

The syncing is done by sequentially upgrading each of the dependency
modules specified in a workspace module to the version in the build list
if the dependency module's version is not already the same as the build
list's version. Note that Minimal Version Selection guarantees that the
build list's version of each module is always the same or higher than

  into 'libs'
}
"""
        ivyRepo.module('org', 'projectA', '1.2')
            .dependsOn(organisation: 'org', module: 'projectB', revision: '1.5', revConstraint: '1.6')
            .dependsOn(organisation: 'org', module: 'projectC', revision: 'alpha-12')
            .publish()

        ivyRepo.module('org', 'projectB', '1.5')
            .publish()

        ivyRepo.module('org', 'projectB', '1.6')
            .publish()

	sha256SchemePrefix = "sha256:"
)

// Cache models a Wasm module cache.
type Cache interface {
	Get(url string, opts GetOptions) (string, error)
	Cleanup()
}

// LocalFileCache for downloaded Wasm modules. Currently it stores the Wasm module as local file.
type LocalFileCache struct {
	// Map from Wasm module checksum to cache entry.
	modules map[moduleKey]*cacheEntry
	// Map from tagged URL to checksum

stderr '^go: example.net/testonly tested by\n\texample.net/testonly\.test imports\n\texample.net/missing: cannot find module providing package example.net/missing$'


# 'go get' should succeed for a module path that does not contain a package,
# but fail for a non-package subdirectory of a module.

! go get example.net/missing/subdir@v0.1.0

        def moduleA = sysPropRepo.module('group', 'projectA', '1.2').publish()

        when:
        run 'retrieve'

        then:
        hasArtifact(moduleA)
    }

    def "can resolve artifacts from local m2 with custom local repository defined by system-property"() {
        given:
        def artifactRepo = mavenLocal("artifactrepo")
        def moduleA = artifactRepo.module('group', 'projectA', '1.2').publish()

                }
            }
        """
        when:
        succeeds 'publish'

        then:
        def module = ivyRepo.module('org.gradle.test', 'root', '1.0')
        module.assertPublished()
        def module2 = ivyRepo2.module('org.gradle.test', 'root', '1.0')
        module2.assertPublished()
    }

    def "can publish custom PublishArtifact"() {
        given:

        <artifactId>maven-test-a</artifactId>
        <version>1.0</version>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <modules>
    <module>p1</module>
    <module>p2</module>
    <module>p3</module>
    <module>p4</module>
  </modules>

cd subdir
! go list
! stderr 'cannot find module providing package'
stderr '^no Go files in '$WORK'[/\\]gopath[/\\]src[/\\]dir[/\\]subdir$'
cd ..

# golang.org/issue/30590: if a package is found in the filesystem
# but is not in the main module, the error message should not say
# "cannot find module providing package", and we shouldn't try
# to find a module providing the package.
! go list ./othermodule

	// requirements of those root modules, and the transitive requirements of only
	// the root modules that do not support pruning.
	//
	// If workspace, the graph includes only the workspace modules, the explicit
	// requirements of the workspace modules, and the transitive requirements of
	// the workspace modules that do not support pruning.
	pruning modPruning

	// rootModules is the set of root modules of the graph, sorted and capped to