projectFModuleMissing.missing()
        def projectF2 = getMavenHttpRepo("/repo2").module('group', 'projectF', '2.0').publish()
        projectF2.pom.expectGet()
        projectF2.artifact.expectGet()

        initSettingsFile()

        buildFile << """
            allprojects {
                apply plugin:'java-library'
            }

        url '${mavenHttpRepo.uri}'
    }
}
configurations {
    lockedConf
}

dependencies {
    lockedConf 'org:bar:[1.0,2.0)'
}
"""
        when:
        foo10.pom.expectGet()
        bar10.pom.expectGet()

        then:
        succeeds 'dependencies'
    }

    }
}
"""

        given:
        def m1 = mavenHttpRepo.module('org', 'test', '1.0').publish()
        m1.pom.expectGet()
        m1.artifact.expectGetMissing()
        def m2 = mavenHttpRepo.module('org', 'test2', '2.0').publish()
        m2.pom.expectGet()
        m2.artifact.expectGet()

        when:
        maybeExpectDeprecation(expression)
        fails 'show'

        then:

                    }
                }
            }
        """
        def file = temporaryFolder.createFile("metadata-all.json")
        file.setText(jsonFile, 'utf-8')
        server.expectGet("/repo/metadata.json", file)
        new ExternalResourceListerInteractions([:])
    }

    interface ListerAndSupplierInteractions {
        void expectGetMetadata(String group, String module)

                runtimeClasspath platform("org:foo:1.0")
            }
        """
        def resolve = new ResolveTestFixture(buildFile)
        resolve.prepare()

        when:
        mod.pom.expectGet()
        succeeds ":checkDeps"

        then:
        resolve.expectGraph {
            root(":", "org.gradle.bugs:test:1.9") {
                module("org:foo:1.0") {

            }
        """
        executer.beforeExecute { inDirectory(projectDir) }

        remoteModule.pom.expectHead()
        remoteModule.pom.sha1.expectGet()
        remoteModule.artifact.expectHead()
        remoteModule.artifact.sha1.expectGet()

        when:
        using m2
        withWatchFs().run 'retrieve', "--info"

        then:

               compile 'org:a:1.0'
               compile 'org:b:1.0'
            }
"""
        failedResolve.prepare()

        a.pom.expectGet()
        b.pom.expectGet()
        leaf1.pom.expectGet()
        leaf2.pom.expectGet()

        then:
        fails "checkDeps"

        and:
        failedResolve.assertFailurePresent(failure)

    into "libs"
}
"""

        when:
        moduleWithNoMetaData.ivy.expectGetMissing()
        moduleWithNoMetaData.jar.expectHead()
        moduleWithMetaData.ivy.expectGet()
        moduleWithMetaData.jar.expectGet()
        succeeds "retrieve"

        then:
        file("libs").assertHasDescendants("test-1.45.jar")
        file("libs/test-1.45.jar").assertIsCopyOf(moduleWithMetaData.jarFile)

                    println "evaluating:"
                    compile.${expression}
                }
            }
        """

        m1.allowAll()
        m2.pom.expectGet()
        m2.artifact.expectGetMissing()
        m3.pom.expectGet()
        m3.artifact.expectGetBroken()
        m4.allowAll()

        expect:
        //TODO: fix dependency resolution results usage in this test and remove this flag

        TestFile script = testFile('external.gradle')
        server.expectUserAgent(UserAgentMatcher.matchesNameAndVersion("Gradle", GradleVersion.current().getVersion()))
        server.expectGet('/external.gradle', script)
        server.start()

        script << """
            task doStuff
            assert buildscript.sourceFile == null