BinaryNamingScheme namingScheme,
        Set<? extends BuildType> allBuildTypes,
        Set<? extends Flavor> allFlavors,
        NativeDependencyResolver nativeDependencyResolver,
        FileCollectionFactory fileCollectionFactory
    ) {
        Set<BuildType> targetBuildTypes = projectNativeComponent.chooseBuildTypes(allBuildTypes);
        for (BuildType buildType : targetBuildTypes) {

plugins {
    id 'cpp'
}
model {
    buildTypes {
        debug
        release
    }
    components {
        util(NativeLibrarySpec) {
            binaries.all {
                if (buildType == buildTypes.debug) {
                    cppCompiler.define 'DEBUG'
                    if (toolChain in VisualCpp) {
                        cppCompiler.args '/Zi'
                        linker.args '/DEBUG'
                    } else {

            .mutate(BuildTypeContainer) { it.add named(BuildType, "bt") }
            .mutate(FlavorContainer) { it.add named(Flavor, "flavor1") }

        then:
        single(toolChains).name == 'tc'
        platforms.size() == 1
        single(buildTypes).name == 'bt'
        single(flavors).name == 'flavor1'
    }

    def "creates binaries for executable"() {

            }
        }
    }

    void assertVariantsArePublished(String group, String module, String version, List<String> buildTypes, List<Map<String, String>> targetMachines, List<String> dependencies = []) {
        VariantContext.from(dimensions("buildType", buildTypes), targetMachines).findAll { it.os.name == currentOsFamilyName }.each { variantContext ->

                    staticLibraryFile = file("3rd-party-lib/util/build/libs/util/static/${buildType.name}/${libName}")
                }
                binaries.withType(SharedLibraryBinary) {
                    def os = targetPlatform.operatingSystem
                    def baseDir = "3rd-party-lib/util/build/libs/util/shared/${buildType.name}"
                    if (os.windows) {

                void apply(Project p) {
                        def buildType = Attribute.of('buildType', String)
                        def usage = Attribute.of('usage', String)
                        def flavor = Attribute.of('flavor', String)
                        p.dependencies.attributesSchema {
                           attribute(buildType)
                           attribute(usage)
                           attribute(flavor)

        val stagePasses = StagePasses(model, stage, prevStage, stageProject)
        buildType(stagePasses)
        subProject(stageProject)

        prevStage = stage
        previousPerformanceTestPasses.addAll(stageProject.performanceTests)
    }

    buildType(GitHubMergeQueueCheckPass(model))

    buildTypesOrder = buildTypes
    subProjectsOrder = subProjects

    cleanupRule(
        historyDays = 14,

            TypedProjectSchema(
                extensions = listOf(
                    entry<Project, SourceSetContainer>("sourceSets"),
                    entry<Project, NamedDomainObjectContainer<BuildType>>("buildTypes")
                ),
                containerElements = listOf(
                    entry<SourceSetContainer, SourceSet>("main")
                ),
                conventions = listOf(

Laura Kassovic <******@****.***> 1701107622 -0800

            #include <iostream>

            int main () {
                std::cout << message;
                return 0;
            }
"""
        buildFile << """
model {
    buildTypes {
        debug
        release
    }
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp.lib library: 'util'
            }
        }