failure.assertHasDescription("Execution failed for task ':compileMainExecutableMainC'.")
        failure.assertHasCause("A build operation failed.")
        failure.assertThatCause(containsText("C compiler failed while compiling broken.c"))
    }

    @ToBeFixedForConfigurationCache
    def "build fails when multiple compilations fail"() {
        given:
        def brokenFileCount = 5
        buildFile << """
            model {

			})
			if len(tc.expectedError) > 0 && (err == nil || !strings.Contains(err.Error(), tc.expectedError)) {
				t.Fatalf("expected error: %s compiling expression %s, got: %v", tc.expectedError, tc.expression, err)
			}
			if len(tc.expectedError) == 0 && err != nil {
				t.Fatalf("unexpected error %v compiling expression %s", err, tc.expression)
			}
		})
	}
}

func TestBuildRequestType(t *testing.T) {

import org.gradle.nativeplatform.toolchain.internal.NativeCompileSpec;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Maps common options for C/C++ compiling with GCC
 */
abstract class GccCompilerArgsTransformer<T extends NativeCompileSpec> implements ArgsTransformer<T> {
    @Override
    public List<String> transform(T spec) {
        List<String> args = new ArrayList<>();

        }

        String executable = ((CommandLineJavaCompileSpec) spec).getExecutable().toString();
        LOGGER.info("Compiling with Java command line compiler '{}'.", executable);

        ExecHandle handle = createCompilerHandle(executable, spec);
        executeCompiler(handle);

        return WorkResults.didWork(true);
    }

        then:
        noExceptionThrown()
    }

    // This is named funny to keep the path to the project
    // under Windows's limits.  This checks that we can use
    // ServletCategory as an extension class when compiling
    // Groovy code.
    @Issue("GRADLE-3235")
    def gradle3235() {
        if (versionLowerThan('2.0.5')) {
            return
        }

        when:
        run("test")

        then:

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Plugins, tasks and compiler infrastructure for compiling/linking code"

errorprone {
    disabledChecks.addAll(
        "DefaultCharset", // 2 occurrences
        "EqualsUnsafeCast", // 1 occurrences
        "GetClassOnClass", // 1 occurrences
        "HidingField", // 1 occurrences
        "ImmutableEnumChecker", // 2 occurrences
        "ReferenceEquality", // 2 occurrences

            }
        """

        when:
        withInstallations(earlierJdk).run(":compileJava", "--info")

        then:
        executedAndNotSkipped(":compileJava")
        outputContains("Compiling with toolchain '${earlierJdk.javaHome.absolutePath}'")
        outputContains("sourceCompatibility: '${earlierJdk.javaVersion}'")
        outputContains("targetCompatibility: '${earlierJdk.javaVersion}'")

        failure.assertHasCause("A build operation failed.")
        failure.assertThatCause(Matchers.containsText("C++ compiler failed while compiling broken.cpp"))
    }

    protected abstract String getDevelopmentBinaryCompileTask()

    @Override
    protected String getTaskNameToAssembleDevelopmentBinary() {
        return 'assemble'
    }

};
"""))

    final SourceFileElement source = ofFile(new SourceFile("cpp", "greeter.cpp", """
#include <iostream>
#include "greeter.h"

void Greeter::sayHello() {
#ifdef WITH_FEATURE
#pragma message("compiling with feature enabled")
    std::cout << "${HelloWorldApp.HELLO_WORLD_FRENCH}" << std::endl;
#else
    std::cout << "${HelloWorldApp.HELLO_WORLD}" << std::endl;
#endif
}
"""))

        notExecuted ':b:generateFiles'

        when:
        run 'a:run'

        then:
        executedAndNotSkipped ':b:generateFiles'
    }

    def "can avoid building a jar when compiling against another project"() {
        given:
        file('settings.gradle') << "include 'a', 'b'"
        file('a/build.gradle') << '''

        apply plugin: 'java'

        dependencies {