expect:
        // have to run twice to trigger the failure, to parse the descriptor from the cache
        succeeds ":checkDeps"
        resolve.expectGraph {
            root(":", ":test:") {
                module("group:artifact:1.0")
            }
        }

        succeeds ":checkDeps"
        resolve.expectGraph {
            root(":", ":test:") {
                module("group:artifact:1.0")
            }

    lockedConf('org:foo') {
        version { strictly '1.1' }
    }
}
"""

        lockfileFixture.createLockfile('lockedConf',['org:foo:1.0'], unique)

        when:
        fails 'checkDeps'

        then:
        failure.assertHasCause """Cannot find a version of 'org:foo' that satisfies the version constraints:
   Dependency path ':depLock:unspecified' --> 'org:foo:1.+'

          "version": {
            "requires": "${jsr305.version}"
          }
        },
        {
          "group": "org.checkerframework",
          "module": "checker-qual",
          "version": {
            "requires": "${checker.version}"
          }
        },
        {
          "group": "com.google.errorprone",
          "module": "error_prone_annotations",
          "version": {

		t.Fatalf("typechecking runtime failed: %v", err)
	}

	// Analyze all atomic.*64 callsites.
	v := Visitor{t: t, fset: fset, types: info.Types, checked: checked}
	ast.Walk(&v, pkg)
}

type Visitor struct {
	fset    *token.FileSet
	types   map[ast.Expr]types.TypeAndValue
	checked map[string]bool
	t       *testing.T
}

func (v *Visitor) Visit(n ast.Node) ast.Visitor {
	c, ok := n.(*ast.CallExpr)
	if !ok {

configurations.conf.defaultDependencies { deps ->
    deps.add project.dependencies.create("org:default-dependency:1.0")
}
"""
        resolve.prepare {
            config("conf", "checkDeps")
            config("child", "checkChild")
        }

        when:
        run "checkDeps"

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("org:default-dependency:1.0")
            }
        }

                }
            }
        }

        then:
        if (fixApplied) {
            run ':checkDeps'
            resolve.expectGraph {
                root(":", ":test:") {
                    module('org.test:module:1.0')
                }
            }
        } else {
            fails ':checkDeps'
            if (useIvy() && !isGradleMetadataPublished()) {

                    }
                }
                failOnVersionConflict()
            }
"""
        resolve.prepare("conf")

        expect:
        succeeds("checkDeps")
        resolve.expectGraph {
            root(":", ":test:") {
                 module("org.stuff:foo:2.0") {
                    module("org.utils:api:1.5") {
                        selectedByRule()

}

configurations { compile }

dependencies {
    compile 'org:external:1.2'
    compile 'org:dep:2.2'
}

task checkDeps {
    def files = configurations.compile
    doLast {
        files.files
    }
}
"""

        expect:
        runAndFail("checkDeps")
        failure.assertHasCause("Could not find org:external:1.4.")
    }

                }
            }
            configurations.conf.resolutionStrategy {
                force 'org:foo:1.0'
            }
        """

        when:
        run 'checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                constraint("org:foo:1.1","org:foo:1.0")
                module("org:bar:1.0") {

                implementation libs.my.great.lib
            }
        """

        when:
        lib.pom.expectGet()
        lib.artifact.expectGet()

        then:
        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module('org.gradle.test:lib:1.0')
            }
        }