}

    def 'producer task doLast action does not execute after verification failure is thrown; consumer task does not execute even with --continue'() {
        given:
        buildFile << '''
            tasks.named('producerTask', ProducerTask).configure {
                doLast {
                    throw new RuntimeException('intentional failure in doLast action')
                }
            }
        '''

    public HashCode md5(File file) {
        return doHash(file, md5);
    }

    @Override
    public HashCode sha1(File file) {
        return doHash(file, sha1);
    }

    @Override
    public HashCode sha256(File file) {
        return doHash(file, sha256);
    }

    @Override
    public HashCode sha512(File file) {
        return doHash(file, sha512);
    }

    @Override

                task guard {
                    doLast {
                        Thread.sleep(500)
                    }
                }
                task consumer {
                    inputs.files configurations.default
                    outputs.file file("out")
                    dependsOn guard
                    doLast {
                        ${blockingServer.callFromBuild("consumer")}

                        doLast {
                            println "plugin name: $name"
                        }
                    }
                }
            }

            apply type: RulePlugin

            model {
                tasks {
                    fromScript(Task) {
                        doLast {

                classpath(sourceSets.main.output.classesDirs)
                mainClass = 'org.gradle.TestMain'
                args projectDir, testFile
                doLast {
                    assert testFile.exists()
                }
                assert delegate instanceof ExtensionAware
            }

            task javaexecProjectMethod() {

tasks.register('conventions') {
    def objects = objects
    doLast {
        // tag::conventions[]
        def files = objects.fileCollection().convention("src")
        files.from("src2")
        def dirNames = files*.name
        println("Source dirs: ${dirNames}") // [src, src2]
        // end::conventions[]
    }
}

tasks.register('usage') {
    ProjectLayout projectLayout = layout
    doLast {

        return super.doFirst(actionName, action);
    }

    @Override
    public Task doLast(Action<? super Task> action) {
        return super.doLast(action);
    }

    @Override
    public Task doLast(String actionName, Action<? super Task> action) {
        return super.doLast(actionName, action);
    }

    @Override
    public int compareTo(Task otherTask) {

                }
            }

            apply type: MyPlugin

            model {
              tasks {
                create("printStrings") {
                  doLast {
                    // Being in doLast is significant here.
                    // This is not going to execute until much later, so we are testing that we can still access the input
                    println "strings: " + $.strings

        buildFile << """
            plugins {
                id 'java'
            }

            ${mavenCentralRepository()}

            tasks.test {
                doLast {
                    assert testFramework instanceof ${JUnitTestFramework.canonicalName}
                    assert classpath.empty
                }
            }
        """

        expect:

    a "group1:module1:1.0"
    b "group1:module2:0.99"
}

task a {
    doLast {
        configurations.a.files
    }
}

task block1 {
    dependsOn tasks.a
    onlyIf { project.hasProperty("enable-block1") }
    doLast {
        ${blockingServer.callFromBuild("block1")}
    }
}

task b {
    dependsOn tasks.block1
    doLast {
        configurations.b.files
    }
}

task block2 {