"""
        buildFile << """
            apply plugin: 'cpp-library'

            library {
                binaries.configureEach {
                    compileTask.get().compilerArgs.add("-Wall")
                    compileTask.get().compilerArgs.add("-Werror")
                }
            }
         """

        expect:
        succeeds "assemble"

    }

    def "can disable incremental compilation after failure and forces full recompilation"() {
        given:
        def compileTask = language == CompiledLanguage.GROOVY ? "GroovyCompile" : "JavaCompile"
        buildFile << """
        tasks.withType($compileTask) {
            options.incremental = true
            options.incrementalAfterFailure = false
        }
        """

        and:
        buildFile << """
            apply plugin: 'swift-library'
            library.binaries.getByName('mainDebug').configure {
                compileTask.get().objectFileDir = layout.buildDirectory.dir("object-files")
                compileTask.get().moduleFile = layout.buildDirectory.file("some-lib.swiftmodule")
                linkTask.get().linkedFile = layout.buildDirectory.file("some-lib/main.bin")
            }

            initScript << """
                allprojects { p ->
                    p.plugins.withId("cpp-library") {
                        p.library.binaries.configureEach(CppStaticLibrary) {
                            compileTask.get().configure {
                                compilerArgs.add("-fPIC")
                            }
                        }
                    }
                }
            """
        }

                application.binaries.get { it.optimized }.configure {
                    compileTask.get().macros(WITH_FEATURE: "true")
                }
            }
            project(':hello') {
                apply plugin: 'cpp-library'
                library.binaries.get { it.optimized }.configure {
                    compileTask.get().macros(WITH_FEATURE: "true")
                }
            }
        """

        def pchCompileTask = getPCHCompileTaskName(lib, linkage)
        def compileTask = getLibraryCompileTaskName(lib, linkage, sourceSet)
        def generateTask = getGeneratePrefixHeaderTaskName(lib, sourceSet)
        executedAndNotSkipped ":${compileTask}"
        skipped ":${pchCompileTask}", ":${generateTask}"
        assert output.count(getUniquePragmaOutput(DEFAULT_PCH_MESSAGE)) == 0

        setupProjectWithToolchain(someJdk.javaVersion)

        when:
        project.sourceSets.create('custom')

        then:
        def compileTask = project.tasks.named("compileCustomJava", JavaCompile).get()
        def configuredToolchain = compileTask.javaCompiler.get().javaToolchain
        configuredToolchain.javaVersion.toString().contains(someJdk.javaVersion.getMajorVersion())
    }

                apply plugin: 'cpp-library'
                library {
                    linkage = [Linkage.${linkage}]
                    binaries.configureEach {
                        compileTask.get().positionIndependentCode = true
                    }
                }
            }
        """
        swiftGreeter.writeToProject(file("greeter"))
        app.writeToProject(file("app"))

        executedAndNotSkipped getComponentTasks("app")

        when:
        buildFile << """
            application {
                binaries.configureEach { binary ->
                    binary.compileTask.get().macros["FOO"] = null
                }
            }
        """
        run "visualStudio"

        then:
        skipped ":appVisualStudioSolution"

            version = '1.2'
            publishing {
                repositories { maven { url '${repoDir.toURI()}' } }
            }

            library.binaries.get { it.optimized }.configure {
                compileTask.get().macros(WITH_FEATURE: "true")
            }

        """
        app.greeterLib.writeToProject(file(producer))

        executer.inDirectory(producer)
        run('publish')