//           D3
        // S2 ------/
        //    \ D4

        graph[source1] = [dep1, dep2]
        graph[source2] = [dep3, dep4]
        graph[dep1] = [dep3]
        graph[dep2] = []
        graph[dep3] = []
        graph[dep4] = []
    }

    def initialFiles() {
        graph.keySet().each { TestFile sourceFile ->
            parse(sourceFile)
        }

            }.publish()
        def depB = mavenHttpRepo.module('org.test', 'depB', '1.0').dependsOn([exclusions: [[module: 'excluded']]], depC).publish()
        def depF = mavenHttpRepo.module('org.test', 'depF', '1.0').dependsOn(depC).publish()
        def depE = mavenHttpRepo.module('org.test', 'depE', '1.0').dependsOn(depF).publish()
        def depD = mavenHttpRepo.module('org.test', 'depD', '1.0').dependsOn(depE).publish()

        ]
        def dep2 = node(3, "org", "dep2", "2.0")
        def selector3 = selector(12, "org", "dep1", "5.0")
        dep2.outgoingEdges >> [dep(selector3, 3, new RuntimeException())]

        builder.start(root)

        builder.visitNode(root)
        builder.visitNode(node(2, "org", "dep1", "2.0"))

        builder.visitNode(dep2)

        builder.visitSelector(selector1)

        then:
        file('libs').assertHasDescendants('dep1-1.0.jar', 'dep2-1.0.jar', 'dep3-1.0.jar')
    }

    @Issue("gradle/gradle#2480")
    def "can use beforeResolve hook to modify dependency excludes"() {
        def module1 = mavenRepo.module('org.test', 'excluded-dep', '1.0').publish()
        mavenRepo.module('org.test', 'direct-dep', '1.0').dependsOn(module1).publish()

        buildFile << """

        }

        where:
        metadataType | metadataImplementation
        "maven"      | mavenComponentMetadata("dep1", "dep2")
        "ivy"        | ivyComponentMetadata("dep1", "dep2")
        "gradle"     | gradleComponentMetadata("dep1", "dep2")
    }

    def "dependencies of selected variant are modifiable in dependency metadata rule for #metadataType metadata"() {
        given:

        then:
        def depA = metadata.dependencies.find { it.selector.group == 'group-a'}
        depA.selector == moduleId('group-a', 'module-a', '1.0')
        !depA.optional
        depA.transitive
        def depB = metadata.dependencies.find { it.selector.group == 'group-b'}
        depB.selector == moduleId('group-b', 'module-b', '2.0')
        depB.constraint
        !depB.transitive
    }

maven-deps.svg...

        dep2.attributesFactory = AttributeTestUtil.attributesFactory()

        when:
        dependencyHandler.platform(dep1)

        then:
        1 * dependencyFactory.createDependency(dep1) >> dep1
        dep1.attributes.getAttribute(Category.CATEGORY_ATTRIBUTE).name == 'platform'
        dep1.isEndorsingStrictVersions()

        when:
        dependencyHandler.platform(dep2) { }

        then:

        dep1 != dep2

    }

    void "refuses artifact when attributes present"() {
        given:
        def dep = createDependency("group", "name", "1.0")
        dep.attributes {
            it.attribute(Attribute.of("attribute", String), 'foo')
        }

        when:
        dep.artifact {
            println("Not reached")
        }

        repoModule.parsedPom.scope("runtime") {
            def deps = dependencies.values()
            assert deps.size() == 1
            def dep = deps[0]
            assert dep.groupId == "org"
            assert dep.artifactId == "notfoo"
            assert dep.version == "1.0"
            assert dep.classifier == null
            assert dep.type == null
        }
    }