given:
        buildFile << """
            task noActions
            task notUpToDate {
                doLast { }
            }
            task upToDate {
                outputs.file "file"
                doLast { }
            }
            task all { dependsOn noActions, notUpToDate, upToDate }
        """

        when:
        succeeds('all')

        then:

     */

    def "does not throw exception when build fails expectantly"() {
        given:
        buildScript """
            task helloWorld {
                doLast {
                    throw new GradleException('Expected exception')
                }
            }
        """

        when:
        runner('helloWorld').buildAndFail()

        then:

repositories { flatDir { dir 'repo' } }
configurations { compile }
dependencies {
    compile 'group:a:1.4'
    compile 'group:b:2.0'
    compile 'group:c:'
}

task check {
    def files = configurations.compile
    doLast {
        assert files.collect { it.name } == ['a-1.4.jar', 'b.jar', 'c.jar']
    }
}
"""

        expect:
        succeeds "check"
    }

        builtBy 'compile'
    }
}

tasks.register('compile') {
    doLast {
        println 'compiling classes'
    }
}

tasks.register('list') {
    FileCollection compileClasspath = configurations.compileClasspath
    dependsOn compileClasspath
    doLast {
        println "classpath = ${compileClasspath.collect { File file -> file.name }}"
    }
}

                }

                @Mutate
                void addPersonTask(ModelMap<Task> tasks, Person person) {
                    tasks.create("echo") {
                        it.doLast {
                            println "name: $person.name"
                        }
                    }
                }
            }

            apply type: RulePlugin
        '''

        then:

def compile = tasks.register('compile') {
    doLast {
        println 'We are doing the compile.'
    }
}

compile.configure {
    doFirst {
        // Here you would put arbitrary conditions in real life.
        if (true) {
            throw new StopExecutionException()
        }
    }
}
tasks.register('myTask') {
    dependsOn('compile')
    doLast {
        println 'I am not affected'
    }

        buildFile << '''
            model {
                tasks {
                    create("printSourceNames") {
                        def sources = $.testSuites.main.sources
                        doLast {
                            println "names: ${sources.values()*.name}"
                        }
                    }
                }
            }
        '''

        when:

                  tasks.create("fromPlugin") {
                    doLast { println "fromPlugin: $os.name" }
                  }
                }
            }

            apply type: RulePlugin

            model {
                tasks {
                  create("fromScript") {
                    it.doLast { println "fromScript: " + $("platform.operatingSystem").name }
                  }

            task broken {
                doLast {
                    ${server.callFromBuild('buildA')}
                    throw new RuntimeException("broken")
                }
            }
            processResources.dependsOn(broken)
        """
        dependency("org.test:buildB:1.0")
        buildB.buildFile << """
            task broken {
                doLast {

        try {
            return doHash(inputStream, ByteStreams.nullOutputStream());
        } catch (IOException e) {
            throw new UncheckedIOException("Failed to create MD5 hash for file content.", e);
        }
    }

    @Override
    public HashCode hashCopy(InputStream inputStream, OutputStream outputStream) throws IOException {
        return doHash(inputStream, outputStream);
    }