}
}

func visit(visitor func(m module, via []module), main module, references map[module][]module, effectiveVersions map[string]module) {
	doVisit(visitor, main, nil, map[module]bool{}, references, effectiveVersions)
}

func doVisit(visitor func(m module, via []module), from module, via []module, visited map[module]bool, references map[module][]module, effectiveVersions map[string]module) {
	visitor(from, via)
	via = append(via, from)

}

// findModule searches for the module that contains the package at path.
// If the package was loaded, its containing module and true are returned.
// Otherwise, module.Version{} and false are returned.
func findModule(ld *loader, path string) (module.Version, bool) {
	if pkg, ok := ld.pkgCache.Get(path); ok {
		return pkg.mod, pkg.mod != module.Version{}
	}
	return module.Version{}, false
}

        }

        void addChecksum(HttpModule module, String algo, String type = "jar", String ext = "jar", String origin = null, String reason = null) {
            def checksum = getChecksum(module, algo, type)
            doAddChecksum(module.group, module.module, module.version, type, ext, algo, checksum, origin, reason)
        }

        when:
        targetedRule("group", "module") { ComponentSelection cs -> closuresCalled << 0 }
        targetedRule("group", "module") { ComponentSelection cs, ComponentMetadata cm -> closuresCalled << 1 }
        targetedRule("group", "module") { ComponentSelection cs, IvyModuleDescriptor imd -> closuresCalled << 2 }

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

    private Node findCompilerConfiguration() {

                    artifact(name: 'file4', version: '', legacyName: 'child/file4')
                }
            }
        }
    }

    def "module with module metadata can depend on another module with module metadata"() {
        def c = mavenRepo.module("test", "c", "preview")
            .withModuleMetadata()
        c.artifact(classifier: 'debug')
        c.publish()
        c.moduleMetadata.file.text = """
{

            root(":", ":test:") {
                module('org:foo:1.1') {
                    byConflictResolution('between versions 1.1 and 1.0')
                    module('org:bar:1.0')
                }
                edge('org:foo:[1.0,1.1]', 'org:foo:1.1')
                edge('org:foo:1.0', 'org:foo:1.1')
            }
        }
    }

    def "clashing client modules fail the build"() {
        given:

        then:
        def appXml = new XmlSlurper().parse(
            file('unzipped/META-INF/application.xml'))
        def modules = appXml.module
        modules[0].ejb.text() == 'moduleA.jar'
        modules[1].web.'web-uri'.text() == 'moduleB.war'
    }

    void "uses content from application xml located #location"() {

                // This is a performance optimization. Most modules do not declare capabilities. So, instead of systematically registering
                // an implicit capability for each module that we see, we only consider modules which _declare_ capabilities. If they do,
                // then we try to find a module which provides the same capability. It that module has been found, then we register it.

	// matches the query pattern.
	//
	// We track this module separately from pkgMods because, all else equal, we
	// prefer to match a query to a package rather than just a module. Also,
	// unlike the modules in pkgMods, this module does not inherently exclude
	// any other module in pkgMods.
	mod module.Version

	err error
}

// errSet returns a pathSet containing the given error.