</tr>
            <tr>
                <td>compilerArgs</td>
            </tr>
            <tr>
                <td>toolChain</td>
            </tr>
            <tr>
                <td>targetPlatform</td>
            </tr>
            <tr>
                <td>source</td>
            </tr>
            <tr>
                <td>includes</td>
            </tr>
            <tr>

        @Override
        protected String getLanguage() {
            return "assembler";
        }

        @Override
        protected boolean needsStandardIncludes(NativePlatform targetPlatform) {
            return true;
        }
    }

public interface NativeBinarySpecInternal extends NativeBinarySpec, BinarySpecInternal {

    void setFlavor(Flavor flavor);

    void setToolChain(NativeToolChain toolChain);

    void setTargetPlatform(NativePlatform targetPlatform);

    void setBuildType(BuildType buildType);

    Tool getToolByName(String name);

    PlatformToolProvider getPlatformToolProvider();

    void setPlatformToolProvider(PlatformToolProvider toolProvider);

import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageFragment
import org.jetbrains.kotlin.load.kotlin.*
import org.jetbrains.kotlin.platform.TargetPlatform
import org.jetbrains.kotlin.platform.has
import org.jetbrains.kotlin.platform.jvm.JvmPlatform
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils

@TargetClass(Jdk8WithJettyBootPlatform::class)
@Delete
class TargetJdk8WithJettyBootPlatform

@TargetClass(OpenJSSEPlatform::class)
@Delete
class TargetOpenJSSEPlatform

@TargetClass(Platform.Companion::class)
class TargetPlatform {
  @Substitute
  fun findPlatform(): Platform {
    return Jdk9Platform.buildIfSupported()!!
  }

        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")