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

        //           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)
        }

        then:
        deps == [dep1, dep2, dep3, dep4] as Set

        and:
        //does not contain unresolved dep, contains root
        modules == [root, dep1.selected, dep2.selected, dep3.selected] as Set
    }

    def "provides hooks for iterating each module or dependency exactly once"() {
        given:
        //root -> dep1,dep2; dep1 -> dep3
        def dep = newDependency('dep1')

# by matching 3 occurrences of "compile dep.go", among which
# 2 of them have -pgoprofile (therefore one without).
stderr -count=3 'compile.*dep(/|\\\\)dep.go'
stderr -count=2 'compile.*-pgoprofile=.*dep(/|\\\\)dep\.go'

stderr -count=3 'compile.*dep2(/|\\\\)dep2.go'
stderr -count=2 'compile.*-pgoprofile=.*dep2(/|\\\\)dep2\.go'

stderr -count=3 'compile.*dep3(/|\\\\)dep3.go'

        dep2.setArtifactId( "test-artifact2" );
        dep2.setVersion( "1" );
        dep2.setType( "jar" );

        List<Dependency> deps = new ArrayList<>();
        deps.add( dep1 );
        deps.add( dep2 );

        ArtifactFactory factory = container.lookup( ArtifactFactory.class );

        ArtifactFilter dependencyFilter = new ScopeArtifactFilter( Artifact.SCOPE_COMPILE );

package dep2

import "testshared/depBase"

func init() {
	if !depBase.Initialized {
		panic("depBase not initialized")
	}
}

var W int = 1

var hasProg depBase.HasProg

type Dep2 struct {
	depBase.Dep
}

func G() int {
	return depBase.F() + 1

        ]
        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
    }