buildType(SanityCheck)
    buildType(PublishNightlySnapshot(branch))
    buildType(PublishNightlySnapshotFromQuickFeedback(branch))
    buildType(PublishNightlySnapshotFromQuickFeedbackStepCheckReady(branch))
    buildType(PublishNightlySnapshotFromQuickFeedbackStepUpload(branch))
    buildType(PublishNightlySnapshotFromQuickFeedbackStepPromote(branch))
    buildType(PublishBranchSnapshotFromQuickFeedback)

            for (BuildType buildType : allBuildTypes) {
                for (Flavor flavor : allFlavors) {
                    createNativeBinaries(prebuiltLibrary, platform, buildType, flavor, fileCollectionFactory);
                }
            }
        }
    }

    def 'compilation can be cached (#buildType)'() {
        setupProject()

        when:
        withBuildCache().run tasks.withBuildType(buildType).compile

        then:
        compileIsNotCached(buildType)

        when:
        withBuildCache().run 'clean', tasks.withBuildType(buildType).install

        then:
        compileIsCached(buildType)

        def buildType = ModelReportOutput.from(output).modelNode.buildType

        buildType.inputs.@type[0] == 'CustomSourceSet'
        buildType.inputs.@nodeValue[0] == 'null'
        buildType.inputs.@creator[0] == 'Rules#buildType(BuildType)'

        buildType.sources.@type[0] == 'CustomSourceSet'
        buildType.sources.@nodeValue[0] == "Custom source 'sources'"

    // 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._
    }

            return this;
        }

        public LibraryResolution withBuildType(BuildType buildType) {
            this.buildType = buildType;
            return this;
        }

        public NativeDependencySet resolve(DomainObjectSet<NativeLibraryBinary> allBinaries) {
            NativeLibraryBinary resolve = resolveLibrary(allBinaries);
            return new DefaultNativeDependencySet(resolve);

    private void assertTasksExecutedFor(String buildType) {
        def tasks = [":hello:compile${buildType}Cpp", ":hello:link${buildType}", ":log:compile${buildType}Cpp", ":log:link${buildType}", ":app:compile${buildType}Cpp", ":app:link${buildType}", ":app:install${buildType}"]
        if (buildType == "Release" && !toolChain.visualCpp) {
            tasks << [ ":log:stripSymbols${buildType}", ":hello:stripSymbols${buildType}", ":app:stripSymbols${buildType}"]

            }
        }
    }

    private static class Attributes implements BuildScanConfig.Attributes {
        private final BuildType buildType;

        public Attributes(BuildType buildType) {
            this.buildType = buildType;
        }

        @Override
        public boolean isRootProjectHasVcsMappings() {
            return false;
        }

        @Override

package configurations

import jetbrains.buildServer.configs.kotlin.BuildType
import model.Stage

open class BaseGradleBuildType(
    val stage: Stage? = null,
    val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {}
) : BuildType() {
    init {
        this.init()
    }