// tag::module-when-merged[]
import org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry
// end::module-when-merged[]
// tag::module-before-merged[]
// tag::module-when-merged[]
import org.gradle.plugins.ide.eclipse.model.Classpath
// end::module-when-merged[]
// end::module-before-merged[]
// tag::project-before-merged[]
import org.gradle.plugins.ide.eclipse.model.Project
// end::project-before-merged[]
// tag::wtp-with-xml[]

    String artifactVersion = "1.45-SNAPSHOT"
    MavenS3Module module

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

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

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

        then:
        mavenRepo.module('com.example.foo.new', 'foo-new', '1.2.3').assertPublished()

        def module = mavenRepo.module('com.example.foo', 'com.example.foo' + PLUGIN_MARKER_SUFFIX, '1.0')
        module.assertPublished()
        module.getPomFile().text.contains('foo-new')
        module.getPomFile().text.contains('com.example.foo.new')
        module.getPomFile().text.contains('1.2.3')
    }

        def module = ideaProject.modules.find {it. name == 'root'}

        then:
        module.dependencies.size() == 11
        hasDependency(module, "a", "PROVIDED")
        hasDependency(module, "a", "RUNTIME")
        hasDependency(module, "a", "TEST")
        hasDependency(module, "f", "TEST")
        hasDependency(module, "b", "PROVIDED")
        hasDependency(module, "b", "RUNTIME")

        0 * pluginModuleRegistry.getApiModules()
    }

    def module(String name, Module... requiredModules) {
        Module module = Mock()
        _ * module.classpath >> DefaultClassPath.of(new File("$name-runtime"))
        _ * module.implementationClasspath >> DefaultClassPath.of(new File("$name-runtime"))

// the graph and ending at a module version m for which f(m) returns true, or
// nil if no such path exists.
func (g *Graph) FindPath(f func(module.Version) bool) []module.Version {
	// firstRequires[a] = b means that in a breadth-first traversal of the
	// requirement graph, the module version a was first required by b.
	firstRequires := make(map[module.Version]module.Version)

	queue := g.roots

 differently than if it were the main module. The module must not require
 a higher version of itself.

 - Vendor directories are not used in any module. (Vendor directories are not
 included in the module zip files downloaded by 'go install'.)

If the arguments don't have version suffixes, "go install" may run in
module-aware mode or GOPATH mode, depending on the GO111MODULE environment

                edge("org:foo:1.0","org:foo:1.1").byConflictResolution()
                module("org:bar:1.0") {
                    module("org:foo:1.1")
                }
                // BUG: This module should not be included, but it is
                module("org:baz:1.0") {
                    module("org:baz-transitive:1.0")
                }
            }
        }
         */
    }

    def "a bom dependencyManagement entry can declare excludes which are applied unconditionally to module"() {
        given:
        moduleA.dependsOn(mavenHttpRepo.module("group", "moduleC", "1.0").allowAll().publish()).publish()
        bomDependency('moduleA', [[group: 'group', module: 'moduleC']])
        bomDependency('moduleB', [[group: 'group', module: 'moduleC']]).publish()

        buildFile << """
            dependencies {

        ex.message == "Cannot declare module replacement o:c->o:a because it introduces a cycle: o:c->o:a->o:b->o:c"
    }

    def "provides module metadata information"() {
        def module = replacements.module("com.google.collections:google-collections")

        expect:
        module.id == newId("com.google.collections", "google-collections")
        module.replacedBy == null

        when: module.replacedBy("a:b")