}

    /**
     * This test has
     *   - a BOM import which itself imports the junit BOM which manages the dep to 0.1
     *   - a BOM import to the junit BOM which manages the dep to 0.2
     *   - a direct managed dependency to the dep at 0.3 (as suggested by the warning)
     * This results in 0.3 (explicit managed wins) and no warning
     */
    @Test

        checkoutDir("dep", commits["1.0"].id.name, repo.id).assertDoesNotExist()
        checkoutDir("dep", commits["2.0"].id.name, repo.id).assertDoesNotExist()
        checkoutDir("dep", commits["3.0"].id.name, repo.id).assertDoesNotExist()
    }

    private void markUnused(String version) {
        def checkout = checkoutDir("dep", commits[version].id.name, repo.id).parentFile

        String groupId = "org.apache.maven";
        String artifactId = "maven-model";

        Dependency dep = new Dependency();

        dep.setGroupId( groupId );
        dep.setArtifactId( artifactId );
        dep.setVersion( "2.0-alpha-3" );

        Model model = new Model();

        model.addDependency( dep );

        MavenProject project = new MavenProject( model, repositorySystem );

    @Subject
    def reporter = new DependencyInsightReporter(versionSelectorScheme, versionComparator, versionParser)

    def "sorts dependencies"() {
        def dependencies = [dep("a", "x", "1.0", "2.0"), dep("a", "x", "1.5", "2.0"), dep("b", "a", "5.0"), dep("a", "z", "1.0"), dep("a", "x", "2.0")]

        when:
        def sorted = reporter.convertToRenderableItems(dependencies, false)

        then:
        sorted.size() == 8

        }
    }

    def "writes supplied dependencies"() {
        when:
        def dependency1 = new DefaultIvyDependency('dep-group', 'dep-name-1', 'dep-version', "confMappingProject", true, null, [] as Set, [] as Set)
        def dependency2 = new DefaultIvyDependency('dep-group', 'dep-name-2', 'dep-version', "confMappingProject2", true, null, [] as Set, [] as Set)
        descriptor.dependencies.set([dependency1, dependency2])

        declaredReplacements 'a->b'
        buildFile << """
            configurations.all { resolutionStrategy.eachDependency { dep ->
                if (dep.requested.name == 'c') { dep.useTarget 'org:a:1' }
                if (dep.requested.name == 'd') { dep.useTarget 'org:b:1' }
            }}
        """
        expect:
        resolvedModules 'b'
    }

}

task verify {
    doLast {
        def dep = configurations.compile.dependencies.find { it instanceof FileCollectionDependency }
        println "files: " + dep.files.files.collect { it.name }
        println "resolve: " + dep.resolve().collect { it.name }
        println "resolve-not-transitive: " + dep.resolve(false).collect { it.name }
        println "resolve-transitive: " + dep.resolve(true).collect { it.name }

            extension = 'jar'
            type = 'jar'
        }
    }
}
"""
        resolve.prepare()

        when:
        dep.ivy.expectGetMissing()
        dep.getArtifact(name: 'my-test-artifact').expectHead()
        dep.getArtifact(name: 'my-test-artifact').expectGet()

        then:
        succeeds "checkDeps"
        resolve.expectGraph {
            root(":", ":test:") {

        def classifier = dep.classifier
        def depAttrs = [org: dep.organisation, name: dep.module, rev: dep.revision, conf: conf]
        if (dep.revConstraint) {
            depAttrs.revConstraint = dep.revConstraint
        }
        builder.dependency(depAttrs) {
            if (dep.exclusions) {
                for (exc in dep.exclusions) {

        when:
        def module = DefaultModuleIdentifier.newId("org.foo", "foo")
        def dep = new DefaultUnresolvedDependency(DefaultModuleVersionSelector.newSelector(module, '1.0'), new RuntimeException("boo!"))

        then:
        dep.selector.group == 'org.foo'
        dep.selector.name == 'foo'
        dep.selector.version == '1.0'
        dep.toString() == 'org.foo:foo:1.0'
    }