}
    }

    def "no dependencies test"() {
        applyPluginToProjects()
        project.apply(plugin: 'java')

        def module = project.ideaModule.module // Mock(IdeaModule)
        module.offline = true

        when:
        def result = dependenciesProvider.provide(module)

        then:
        result.isEmpty()
    }

    def "dependencies are added to each required scope"() {

        given:
        def module = ivyRepo.module("org", "child")
        module.configuration('first', extendsFrom: ['second'])
        module.configuration('second')
        module.publish()

        module = ivyRepo.module("org", "parent").dependsOn('child')
        module.configuration('first', extendsFrom: ['second'])
        module.configuration('second')
        module.publish()

task retrieve(type: Sync) {
    from configurations.compile
    into 'libs'
}
"""
        and:
        module.pom.expectMetadataRetrieve()
        module.pom.sha1.expectDownload()
        module.pom.expectDownload()
        module.artifact.expectMetadataRetrieve()
        module.artifact.sha1.expectDownload()
        module.artifact.expectDownload()

        when:
        using m2

        then:

# attempt to upgrade the main module.
go get rsc.io/quote/...@v1.5.1
grep 'rsc.io/quote v1.5.1' go.mod


# The main module cannot be updated to a specific version.
! go get rsc.io@v0.1.0
stderr '^go: can''t request version "v0.1.0" of the main module \(rsc.io\)$'

# A package in the main module can't be upgraded either.
! go get rsc.io/x@v0.1.0

public abstract class GenerateIdeaModule extends XmlGeneratorTask<Module> {

    private IdeaModule module;

    public GenerateIdeaModule() {}

    @Inject
    public GenerateIdeaModule(IdeaModule module) {
        this.module = module;
    }

    @Override
    protected Module create() {
        return new Module(getXmlTransformer(), module.getPathFactory());
    }

    @Override

-- mv2/go.mod --
module m/v2

go 1.16
-- mv2/README.txt --
This module is m/v2. It doesn't actually need to exist,
but it explains how module m could plausibly exist
and still contain package p at 'latest' even when module
m/p also exists.

-- mp01/go.mod --
module m/p

go 1.16
-- mp01/README.txt --
This module is m/p.
Package m/p does not exist in this module.
-- mp02/go.mod --
module m/p

go 1.16

            "(package $packageName is declared in the unnamed module, but module $producer does not read it)"
        } else {
            "(package $packageName is declared in the unnamed module, but module $consumer does not read it)"
        }
    }

    def "a required module cannot be found if module path inference is turned off"() {
        given:
        publishJavaModule('moda')

    def expectGetDynamicRevision(IvyHttpModule module) {
        expectListVersions(module)
        module.ivy.expectGet()
        module.jar.expectGet()
    }

    def expectGetDynamicRevisionMetadata(IvyHttpModule module) {
        expectListVersions(module)
        module.ivy.expectGet()
    }

    private expectListVersions(IvyHttpModule module) {

	})
	return min, nil
}

// UpgradeAll returns a build list for the target module
// in which every module is upgraded to its latest version.
func UpgradeAll(target module.Version, reqs UpgradeReqs) ([]module.Version, error) {
	return buildList([]module.Version{target}, reqs, func(m module.Version) (module.Version, error) {
		if m.Path == target.Path {
			return target, nil
		}

		return reqs.Upgrade(m)

    void "module forced by rule has correct selection reason"()
    {
        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()