when:
        def projectBModuleRepo1 = mavenRepo1.module('org.name', 'projectB', '1.0').publish()
        projectBModuleRepo1.pom.expectGet()
        projectBModuleRepo1.artifact.expectGet()

        then:
        succeedsWith 'mavenRepository1'

        when:

        assertTaskNotExecuted(":buildB", ":succeeds")
        assertTaskNotExecuted(":", ":delegate")
    }

    def "attempts all dependencies when run with --continue when one delegated task dependency fails"() {
        when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':fails')
        dependsOn gradle.includedBuild('buildC').task(':succeeds')

    def "caches result of actual #compiler metadata provider"() {
        def binary = new File("any")
        when:
        def metadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        interaction compilerShouldBeExecuted

        when:
        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:

        when:
        withBuildCache().run ':compileJava', compilationTask

        then:
        compiledJavaClass.exists()
        compiledScalaClass.exists()

        when:
        withBuildCache().run ':clean', ':compileJava'

        then:
        skipped ':compileJava'

        when:
        // This line is crucial to expose the bug

    }

    def "does not fail when calling get() after producer task has completed"() {
        given:
        def property = propertyWithCompletedProducer()
        def provider = property.filter { it.contains("1") }

        when:
        provider.get()

        then:
        noExceptionThrown()
    }

    def "fails when calling getOrNull() before producer task has completed"() {

        def sourceFile = sourcesDir.file("source.txt").createFile()
        def outputFile = file("build/output/output.txt")

        when:
        withWatchFs().run ":consumer"
        then:
        executedAndNotSkipped(":sourceTask", ":consumer")
        outputFile.assertExists()

        when:
        sourceFile.delete()
        waitForChangesToBePickedUp()
        withWatchFs().run ":consumer"
        then:

        given:
        model.wtp = TestUtil.newInstance(EclipseWtp)
        //for example when wtp+java applied but project is not a dependency to any war/ear.
        assert model.wtp.component == null

        when:
        model.pathVariables(one: new File('.'))

        then:
        model.classpath.pathVariables == [one: new File('.')]
    }

    def "creates with gradle.properties when using #scriptDsl build scripts with --incubating"() {
        when:
        run('init', '--type', 'kotlin-application', '--dsl', scriptDsl.id, '--incubating', '--java-version', JavaVersion.current().majorVersion)

        then:
        gradlePropertiesGenerated()

        when:
        run("build")

        then:

        given:
        1 * resolver.resolveTask("other") >> otherTask

        when:
        dependency.add(input)

        then:
        dependency.getDependencies(task) == toSet(otherTask)
    }

    def "can depend on a task instance"() {
        when:
        dependency.add(otherTask)

        then:
        dependency.getDependencies(task) == toSet(otherTask)
    }

        textFile << "content"

        when:
        fails("tasks")

        then:
        testDirectory.assertHasDescendants(".gradle/thing.txt")
        textFile.assertIsFile()
        textFile.text == "content"
    }

    def "does not treat build as undefined when root #fileName is present but settings file is not"() {
        when:
        file(fileName) << """