String getExtraConfiguration(String binaryName = null) {
        return """
            model {
                binaries {
                    ${binaryName ? binaryName : "all"} {
                        if (targetPlatform.operatingSystem.macOsX) {
                            linker.args "-framework", "Foundation"
                        } else {

                if (${!OperatingSystem.current().windows}) {
                    cCompiler.withArguments { it << '-fPIC' }
                }
            }
        }
    }
    components.main {
        targetPlatform "$installOS"
    }
}
        """
        and:
        succeeds "install"

        then:
        installation("build/install/main", OperatingSystem.forName(installOS)).assertInstalled()
    }

        project.assertHasLinkedResource('linkToUriFoo', 'aFooUri', 'http://test/uri/foo')

        file('.project').text.contains('<motto>Stay happy!</motto>')

        def jdt = parseJdtFile()
        assert jdt.contains('targetPlatform=1.3')
        assert jdt.contains('source=1.4')
    }

    @ToBeFixedForConfigurationCache
    void "allows custom matcher resource filter"() {
        given:
        buildScript """
apply plugin: 'java'

                    cCompiler.withArguments { it << '-fPIC' }
                }
            }
        }
    }
    components {
        all {
            targetPlatform "custom"
        }
    }
}
"""

        when:
        run 'mainExe'

        then:
        file(OperatingSystem.WINDOWS.getStaticLibraryName("build/libs/hello/static/hello")).file

    def "executes using the C Compiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)

        when:
        cCompile.toolChain = toolChain
        cCompile.targetPlatform = platform
        cCompile.compilerArgs = ["arg"]
        cCompile.macros = [def: "value"]
        cCompile.objectFileDir = temporaryFolder.file("outputFile")
        cCompile.source sourceFile

            properties.put("org.eclipse.jdt.core.compiler.problem.enumIdentifier", "error");
        }

        properties.put("org.eclipse.jdt.core.compiler.codegen.targetPlatform", targetVersion);
    }

        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        objCPCHCompile.toolChain = toolChain
        objCPCHCompile.targetPlatform = platform
        objCPCHCompile.compilerArgs = ["arg"]
        objCPCHCompile.macros = [def: "value"]
        objCPCHCompile.objectFileDir = temporaryFolder.file("outputFile")
        objCPCHCompile.source sourceFile

        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        objCCompile.toolChain = toolChain
        objCCompile.targetPlatform = platform
        objCCompile.compilerArgs = ["arg"]
        objCCompile.macros = [def: "value"]
        objCCompile.objectFileDir = temporaryFolder.file("outputFile")
        objCCompile.source sourceFile

                platforms {
                    x86 {
                        architecture "i386"
                    }
                }
                components {
                    all { it.targetPlatform "x86" }
                }
            }
"""
    }

    SourceFile getMainSource() {
        return new SourceFile("cpp", "main.cpp", """
            #include <iostream>
            extern "C" {

    def "executes using the Assembler"() {
        def inputDir = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        assembleTask.toolChain = toolChain
        assembleTask.targetPlatform = platform
        assembleTask.assemblerArgs = ["arg"]
        assembleTask.objectFileDir = temporaryFolder.file("outputFile")
        assembleTask.source inputDir
        execute(assembleTask)

        then: