def "can build current architecture when other, non-buildable architectures are specified"() {
        given:
        makeSingleProject()
        componentUnderTest.writeToProject(testDirectory)

        and:
        buildFile << configureTargetMachines("machines.${currentHostOperatingSystemFamilyDsl}.architecture('foo')", "machines.${currentHostOperatingSystemFamilyDsl}")
        buildFile << configureToolChainSupport('foo')

        buildFile << """
            tasks.register("b") {
                dependsOn files(file('123'))
            }
        """

        when:
        run("b")

        then:
        result.assertTasksExecuted(":b")
    }

    def "produces reasonable error message when task dependency closure throws exception"() {
        buildFile << """
    task a
    a.dependsOn {

        failure.assertHasDescription("Could not compile build file '${buildFile}'.")
                .assertThatCause(containsString("build file '$buildFile': 3: unable to resolve class org.gradle.unknown.Unknown"))
                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(3)
    }

    def "produces reasonable error message when buildFile evaluation fails with exception"() {
        when:

class ComponentMetadataRulesErrorHandlingIntegrationTest extends AbstractHttpDependencyResolutionTest {
    final resolve = new ResolveFailureTestFixture(buildFile)

    def setup() {
        ivyRepo.module('org.test', 'projectA', '1.0').publish()
        buildFile << """
            repositories {
                ivy {
                    url "$ivyRepo.uri"
                }
            }

    def setup() {
        new ResolveTestFixture(buildA.buildFile).prepare()

        buildA.buildFile << """
            task resolve(type: Copy) {
                from configurations.runtimeClasspath
                into 'libs'
            }
"""

        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {
                    apply plugin: 'java'

public class BuildFileProjectSpec extends AbstractProjectSpec {
    private final File buildFile;

    public BuildFileProjectSpec(File buildFile) {
        this.buildFile = buildFile;
    }

    @Override
    protected String formatNoMatchesMessage(String settings) {
        return String.format("Build file '%s' is not part of the build defined by %s.", buildFile, settings);
    }

    @Override

    def "creates visual studio solution and project for cunit test suite"() {
        given:
        useStandardConfig()
        useConventionalSourceLocations()
        buildFile.text = "apply plugin: 'visual-studio'\n" + buildFile.text

        when:
        succeeds "visualStudio"

        then:
        final mainSolution = new SolutionFile(file("test.sln"))

 */
trait TasksWithInputsAndOutputs {
    abstract TestFile getBuildFile()

    abstract TestFile getBuildKotlinFile()

    def taskTypeWithOutputFileProperty(TestFile buildFile = getBuildFile()) {
        buildFile << """
            class FileProducer extends DefaultTask {
                @OutputFile
                final RegularFileProperty output = project.objects.fileProperty()
                @Input

        file("run.sh") << '''#!/bin/sh
# convert paths into absolute Unix-like paths
BUILD_FILE=$(cygpath --absolute --unix build.gradle)
SRC_DIR=$(cygpath --absolute --unix src)
# pass them to the generated start script
build/install/sample/bin/sample "$BUILD_FILE" "$SRC_DIR"
'''
        buildFile << """
task execStartScript(type: Exec) {
    commandLine 'cmd.exe', '/d', '/c', 'sh', 'run.sh'
}
"""

                .assertHasCause("afterEvaluate failure")
                .assertHasFileName("Build file '${buildFile.path}'")
                .assertHasLineNumber(3)
    }

    def "produces reasonable error message when Project.afterEvaluate action fails"() {
        when:
        buildFile """
    def action = {
        throw new RuntimeException("afterEvaluate failure")
    } as Action