*/
@Incubating
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class WindowsResourceCompile extends DefaultTask {

    private final Property<NativePlatform> targetPlatform;
    private final Property<NativeToolChain> toolChain;
    private File outputDir;
    private ConfigurableFileCollection includes;
    private ConfigurableFileCollection source;

                    ${testedComponentDsl}.binaries.get().each {
                        assert it.targetPlatform.sourceCompatibility == SwiftVersion.${componentSourceCompatibility.name()}
                    }
                    ${componentUnderTestDsl}.binaries.get().each {
                        assert it.targetPlatform.sourceCompatibility == SwiftVersion.${xctestSourceCompatibility.name()}
                    }
                }

        when:
        def result = selector.select(CppPlatform, requestPlatform)

        then:
        result.toolChain == toolChain
        result.targetPlatform instanceof CppPlatform
        result.targetPlatform.targetMachine.operatingSystemFamily == osFamily
        result.targetPlatform.targetMachine.architecture == machineArchitecture
        result.platformToolProvider == toolProvider

        and:

        SwiftExecutable result = objectFactory.newInstance(DefaultSwiftExecutable.class, getNames().append(identity.getName()), getModule(), testable, getSwiftSource(), getImplementationDependencies(), targetPlatform, toolChain, platformToolProvider, identity);
        getBinaries().add(result);

    private File sharedLibraryLinkFile;

    public DefaultPrebuiltSharedLibraryBinary(String name, PrebuiltLibrary library, BuildType buildType, NativePlatform targetPlatform, Flavor flavor, FileCollectionFactory fileCollectionFactory) {
        super(name, library, buildType, targetPlatform, flavor, fileCollectionFactory);
    }

    @Override
    public String getDisplayName() {

        super(names, objectFactory, taskDependencyFactory, module, testable, source, configurations, implementation, targetPlatform, toolChain, platformToolProvider, identity);
        linkTask = objectFactory.property(LinkMachOBundle.class);

                    def linkDebug = linkTask.get()
                    extract.toolChain = linkDebug.toolChain
                    extract.targetPlatform = linkDebug.targetPlatform
                    extract.binaryFile.set linkDebug.linkedFile
                }
                symbolFile.set file("build/symbols")
            }
        """
    }

                project.application.binaries.get { !it.optimized }.configure {
                    def linkDebug = linkTask.get()
                    strip.toolChain = linkDebug.toolChain
                    strip.targetPlatform = linkDebug.targetPlatform
                    strip.binaryFile.set linkDebug.linkedFile
                }
                outputFile.set file("build/stripped")
            }
        """
    }

    }
}
// end::executables[]

// tag::all-binaries[]
model {
    binaries {
        all {
            //on macOS we need different linker settings than on Linux or Windows
            if (targetPlatform.operatingSystem.macOsX) {
                linker.args "-framework", "Foundation"
            } else {

    internal val useSiteSession: FirSession get() = firResolveSession.useSiteFirSession
    internal val firSymbolProvider: FirSymbolProvider get() = useSiteSession.symbolProvider
    internal val targetPlatform: TargetPlatform get() = useSiteSession.moduleData.platform

    val extensionTools: List<LLFirResolveExtensionTool>

    val useSiteAnalysisScope: GlobalSearchScope