*  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);

	}

	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 {

        }
    }

    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"() {

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

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

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:

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

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

            "(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) {