given:
        mavenRepo.module("org", "leaf1").publish()
        mavenRepo.module("org", "leaf2").publish()
        mavenRepo.module("org", "leaf2", "1.5").publish()
        mavenRepo.module("org", "leaf2", "2.5").publish()
        mavenRepo.module("org", "leaf3").publish()
        mavenRepo.module("org", "leaf4").publish()

        mavenRepo.module("org", "middle1").dependsOnModules('leaf1', 'leaf2').publish()

        module.pom.expectMetadataRetrieve()
        module.pom.sha1.expectDownload()
        module.artifact.expectMetadataRetrieve()
        module.artifact.sha1.expectDownload()

        when:
        using m2

        then:
        succeeds 'retrieve'

        and:
        localModule.artifactFile.assertIsCopyOf(module.artifactFile)
        localModule.pomFile.assertIsCopyOf(module.pomFile)

	}

	if e.newMissingVersion != "" {
		return fmt.Sprintf("package %s provided by %s at latest version %s but not at required version %s", e.Path, e.Module.Path, e.Module.Version, e.newMissingVersion)
	}

	return fmt.Sprintf("missing module for import: %s@%s provides %s", e.Module.Path, e.Module.Version, e.Path)
}

func (e *ImportMissingError) Unwrap() error {
	return e.QueryErr
}

func (e *ImportMissingError) ImportPath() string {

    String artifactVersion = "1.45-SNAPSHOT"
    MavenGcsModule module

    def setup() {
        module = getMavenGcsRepo().module("org.gradle", "test", artifactVersion)
    }

    def "resolves a maven snapshot module stored in Gcs"() {
        setup:
        module.publish()

        buildFile << mavenGcsRepoDsl()
        buildFile << """
configurations { compile }

        failure.assertHasCause("Could not write to resource '${module.jar.uri}'")
    }

    def expectPublication() {
        module.jar.expectPut()
        module.jar.sha1.expectPut()
        module.jar.sha256.expectPut()
        module.jar.sha512.expectPut()
        module.ivy.expectPut()
        module.ivy.sha1.expectPut()
        module.ivy.sha256.expectPut()
        module.ivy.sha512.expectPut()

	"golang.org/x/mod/module"
)

// cmpVersion implements the comparison for versions in the module loader.
//
// It is consistent with gover.ModCompare except that as a special case,
// the version "" is considered higher than all other versions.
// The main module (also known as the target) has no version and must be chosen
// over other versions of the same module in the module dependency graph.

	return &BuildListError{
		Err:   err,
		stack: stack,
	}
}

// Module returns the module where the error occurred. If the module stack
// is empty, this returns a zero value.
func (e *BuildListError) Module() module.Version {
	if len(e.stack) == 0 {
		return module.Version{}
	}
	return e.stack[len(e.stack)-1].m
}

func (e *BuildListError) Error() string {

     *  organisation
     *  module
     *  revision
     *  revConstraint
     *  conf
     *  exclusions - list of maps: [[group: ?, module: ?], ...]
     */
    IvyModule dependsOn(Map<String, ?> attributes);

    IvyModule dependsOn(Module target);

    IvyModule dependsOn(Map<String, ?> attributes, Module target);

    IvyModule dependencyConstraint(Module module);

! go build -x -mod=readonly my-module/vendor/example.com/another-module/foo/bar/baz_with_outside_dep.go
stderr 'no required module provides package rsc.io/quote'
! go build -x -mod=vendor my-module/vendor/example.com/another-module/foo/bar/baz_with_outside_dep.go
stderr 'no required module provides package rsc.io/quote'

-- my-module/go.mod --
module example.com/my-module

go 1.20
-- my-module/vendor/example.com/another-module/foo/bar/baz.go --

    void "forces multiple modules by rule"() {
        mavenRepo.module("org.utils", "impl", '1.3').dependsOn('org.utils', 'api', '1.3').publish()
        mavenRepo.module("org.utils", "impl", '1.5').dependsOn('org.utils', 'api', '1.5').publish()

        mavenRepo.module("org.utils", "api", '1.3').publish()
        mavenRepo.module("org.utils", "api", '1.5').publish()