then:
        resolve.expectGraph {
            root(":", ":test:") {
                project(":other", "test:other:unspecified") {
                    configuration('default')
                    noArtifacts()
                }
                module('org:test:1.0')
            }
        }
    }

    def "fails to resolve a direct dependency using a dynamic version"() {
        buildFile << """

                        'org.gradle.category': expectedCategory,
                        'org.gradle.usage': 'java-runtime'
                    ])
                    selectedByRule()
                    noArtifacts()
                }
            }
        }

        where:

        resolve.expectGraph {
            root(':', ':test:') {
                module('org:platform:1.0') {
                    noArtifacts()
                    configuration(platformConfiguration)
                }
                edge('org:first:1.0', 'org:first:2.0') {
                    byConflictResolution("between versions 2.0 and 1.0")

                    edge('org:foo:2.0', ':foo', 'org:foo:1.0') {}.byAncestor()
                }
                project(':foo', 'org:foo:1.0') {
                    configuration = 'default'
                    noArtifacts()
                }
            }
        }
    }

    def "incompatible strict constraint and local project fail to resolve"() {
        given:

        createDirs("foo")

                        forced()
                        byConstraint()
                        byConstraint("belongs to platform org:platform:1.0")
                    }
                    noArtifacts()
                }
                module("root:root:1.0") {
                    module('org:webapp:1.0') {
                        forced()
                        byConstraint("belongs to platform org:platform:1.0")

                module('org.test:platform:1.0') {
                    if (plainMaven) {
                        configuration("platform-runtime")
                    }
                    noArtifacts()
                    constraint('org.test:depA:1.0')
                }
                module('org.test:depD:1.0') {
                    module('org.test:depC:1.0') {

                        attribute('org.gradle.category', 'platform')
                        members.each { member ->
                            constraint(member)
                        }
                        noArtifacts = true
                    }
                    // this is used only in BOMs
                    members.each { member ->
                        constraint(member)
                    }

                        notRequested()
                        byAncestor()
                        byReason("didn't match versions 18, 17")
                    }
                    noArtifacts()
                }
            }
        }

    }

    def "should fail and include path to unresolvable strict version range"() {
        given:
        repository {

                    byConflictResolution("between versions 2.0 and 1.2")
                    module("test:projectB:2.1.5")
                }
                project(":subproject", "test:subproject:") {
                    noArtifacts()
                    module("test:projectA:2.0")
                }
            }
        }
    }

    void canHaveCycleInDependencyGraph() {
        given:
        resolve.prepare("compile")

            deps << edge
            return edge
        }

        /**
         * Specifies that this node has no artifacts associated with it.
         */
        NodeBuilder noArtifacts() {
            implicitArtifact = false
            return this
        }

        /**
         * Specifies an artifact for this node. A default is assumed when none specified
         */