when:
        def conf1 = dependencyScope("conf1")
        def conf2 = dependencyScope("conf2")
        def conf3 = dependencyScope("conf3", [conf1, conf2])
        resolvable("child1", [conf3])
        resolvable("child2", [conf1])
        resolvable("other")

        conf1.getDependencies().add(dependency1)
        conf2.getDependencies().add(dependency2)
        conf3.getDependencies().add(dependency3)

            task resolve {
                def conf = configurations.create("conf")
                conf.dependencies.add(project.dependencies.create("org:foo:1.0"))
                conf.files
                configurations.remove(conf)

                def conf2 = configurations.create("conf2")
                conf2.dependencies.add(project.dependencies.create("org:foo:1.0"))
                conf2.files
            }
        """

    private DependencyReportRenderer renderer = Mock(DependencyReportRenderer)
    private Configuration conf1
    private Configuration conf2

    def setup() {
        task = TestUtil.createTask(DependencyReportTask.class, project)
        conf1 = project.configurations.create("conf1")
        conf2 = project.configurations.create("conf2")
        task.renderer = renderer
    }

    def "task is configured correctly"() {

            strictlyEqual(new DefaultProjectDependency(project, "conf1", false, TestFiles.taskDependencyFactory())))

        when:
        def base = new DefaultProjectDependency(project, "conf1", true, TestFiles.taskDependencyFactory())
        def differentConf = new DefaultProjectDependency(project, "conf2", true, TestFiles.taskDependencyFactory())

        given:
        def conf1 = new ConfigurationDetails('config1', 'description', true, null, null)
        def conf2 = new ConfigurationDetails('config2', null, false, null, null)

        when:
        renderer.prepareVisit()
        renderer.startConfiguration(conf1);
        renderer.completeConfiguration(conf1);
        renderer.startConfiguration(conf2);
        renderer.completeConfiguration(conf2);

        def results1 = new Object()
        def results2 = new Object()

        def store1 = factory.createCachedStore("conf1")
        def store1b = factory.createCachedStore("conf1")
        def store2 = factory.createCachedStore("conf2")

        expect:
        store1.load(() -> results1) == results1
        store1.load(() -> { assert false }) == results1

        }
    }
    configurations { conf1; conf2 }
    dependencies {
        conf1 'group:projectA:1.0'
        conf2 'group:projectA:1.+'
    }

    task cache {
        def conf1 = configurations.conf1
        doLast { println conf1.files }
    }
    task retrieve(type: Sync) {
        into 'libs'
        from configurations.conf2
    }
    """

        and:

        root.outgoingEdges >> [dep(selector1, 1, 2)]

        def conf1 = node(2, "org", "dep1", "1.0")
        def selector2 = selector(11, "org", "dep2", "1.0")
        conf1.outgoingEdges >> [dep(selector2, 2, 3)]

        def conf2 = node(2, "org", "dep1", "1.0")
        def selector3 = selector(12, "org", "dep3", "1.0")
        conf2.outgoingEdges >> [dep(selector3, 2, 4)]

        builder.start(root)

    }

    def "renders only classpath build script configuration"() {
        given:
        project.buildscript.configurations.create("conf1")
        project.buildscript.configurations.create("conf2")

        when:
        task.setRenderer(renderer)
        task.generate()

        then:
        task.reportModel.get().configuration.name == "classpath"
    }

            configurations {
                conf1
                conf2
            }

            dependencies {
                conf1 'org:toplevel1:1.0'
                conf2 'org:toplevel2:1.0'
            }
        """

        when:
        run "dependencies", "--configuration", "conf2"

        then:
        output.contains """
conf2
\\--- org:toplevel2:1.0
     +--- org:leaf3:1.0