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

        buildFile << """
apply plugin: 'cpp'
model {
    buildTypes {
        debug
        release
    }
    components {
        main(NativeExecutableSpec) {
            targetBuildTypes "release"
            binaries.all { binary ->
                if (buildType == buildTypes.release) {
                    cppCompiler.define "FRENCH"
                }
            }

            "platform2StaticLibrary",
        ] as SortedSet)
    }

    def "includes buildType in name for when multiple buildTypes"() {
        final BuildType buildType2 = createStub(BuildType, "buildType2")

        when:
        NativeComponentRules.createBinariesImpl(component, platforms, [buildType, buildType2].toSet(), [flavor].toSet(), nativePlatforms, nativeDependencyResolver, TestFiles.fileCollectionFactory())

    // Grab all build types and product flavors
    def buildTypes = android.buildTypes.collect { type ->
        type.name
    }
    def productFlavors = android.productFlavors.collect { flavor ->
        flavor.name
    }
    // When no product flavors defined, use empty
    if (!productFlavors) productFlavors.add('')
    productFlavors.each { productFlavorName ->
        buildTypes.each { buildTypeName ->

class CreateDefaultBuildTypesTest extends Specification {
    def buildTypes = Mock(BuildTypeContainer)
    def rule = new NativeComponentModelPlugin.Rules()

    def "adds a default build type when none configured"() {
        when:
        rule.createDefaultBuildTypes(buildTypes)

        then:
        1 * buildTypes.empty >> true
        1 * buildTypes.create("debug")
        0 * buildTypes._
    }

// tag::build-type-config[]
model {
    binaries {
        all {
            if (toolChain in Gcc && buildType == buildTypes.debug) {
                cppCompiler.args "-g"
            }
            if (toolChain in VisualCpp && buildType == buildTypes.debug) {
                cppCompiler.args '/Zi'
                cppCompiler.define 'DEBUG'
                linker.args '/DEBUG'
            }

fun <T : BaseGradleBuildType> Dependencies.snapshotDependencies(buildTypes: Iterable<T>, snapshotConfig: SnapshotDependency.(T) -> Unit = {}) {
    buildTypes.forEach { buildType ->
        dependency(buildType.id!!) {
            snapshot {
                if (!buildType.failStage) {
                    onDependencyFailure = FailureAction.IGNORE

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 {

                                       Action<NativeVariantIdentity> action) {
        Collection<BuildType> buildTypes = BuildType.DEFAULT_BUILD_TYPES;
        Collection<TargetMachine> targetMachines = extractAndValidate("target machine", "application", declaredTargetMachines);
        variants(baseName, buildTypes, targetMachines, objectFactory, attributesFactory, group, version, action);
    }

        Collections.addAll(buildTypes, buildTypeSelectors);
    }

    @Override
    public Set<Flavor> chooseFlavors(Set<? extends Flavor> candidates) {
        return chooseElements(Flavor.class, candidates, flavors);
    }

    @Override
    public Set<BuildType> chooseBuildTypes(Set<? extends BuildType> candidates) {
        return chooseElements(BuildType.class, candidates, buildTypes);
    }