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

        binary.component >> component
        binary.platformToolProvider >> toolProvider
        binary.namingScheme >> DefaultBinaryNamingScheme.component("comp_name")
        binary.targetPlatform >> platform

        component.baseName >> "base_name"
        return binary
    }

        """

        when:
        run "eclipse"

        then:
        def properties = parseProperties('.settings/org.eclipse.jdt.core.prefs')
        properties['org.eclipse.jdt.core.compiler.codegen.targetPlatform'] == expectedVersion

        where:
        version | expectedVersion
        '1.1'   | '1.1'
        '1.2'   | '1.2'
        '1.3'   | '1.3'
        '1.4'   | '1.4'
        '1.5'   | '1.5'

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

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

    def "executes using the CppCompiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        cppCompile.toolChain = toolChain
        cppCompile.targetPlatform = platform
        cppCompile.compilerArgs = ["arg"]
        cppCompile.macros = [def: "value"]
        cppCompile.objectFileDir = temporaryFolder.file("outputFile")
        cppCompile.source sourceFile

    }

    private void useStandardConfig() {
        buildFile << """
            model {
                components {
                    hello(NativeLibrarySpec) {
                        targetPlatform "x86"
                    }
                }
                testSuites {
                    helloTest(CUnitTestSuiteSpec) {
                        testing \$.components.hello
                    }

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

                buildTypes {
                    debug
                    release
                }
                components {
                    all {
                        targetPlatform "win32"
                        targetPlatform "x64"
                    }
                }
            }
        """
    }

    @Issue("https://github.com/gradle/gradle/issues/790")
    @ToBeFixedForConfigurationCache

                                        () -> getAllTestExecutable().findFirst().orElse(null)));
            }

            private boolean isCurrentArchitecture(NativePlatform targetPlatform) {
                return targetPlatform.getArchitecture().equals(DefaultNativePlatform.getCurrentArchitecture());
            }

            private Stream<DefaultCppTestExecutable> getAllBuildableTestExecutable() {