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

    /**
     * Same as {@link #select(NativeLanguage, NativePlatformInternal)} with language {@link NativeLanguage#ANY}.
     */
    @Override
    PlatformToolProvider select(NativePlatformInternal targetPlatform);

    /**
     * Locates the tools that can build binaries from the given source language that can run on the given target machine.
     */

    override fun getPackageSymbols(nameFilter: KaScopeNameFilter): Sequence<KaPackageSymbol> = withValidityAssertion {
        sequence {
            analysisSession.useSitePackageProvider.getSubPackageFqNames(fqName, analysisSession.targetPlatform, nameFilter).forEach {
                yield(analysisSession.firSymbolBuilder.createPackageSymbol(fqName.child(it)))
            }
        }
    }

            void sayFoo2();
           """)
        ]
    }

    public String getExtraConfiguration() {
        return """
            binaries {
                all {
                    if (targetPlatform.operatingSystem.macOsX) {
                        linker.args "-framework", "Foundation"
                    } else {

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

    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