buildFile << """
    apply plugin: 'cpp'
    apply plugin: 'visual-studio'

    model {
        platforms {
            win32 {
                architecture "i386"
            }
        }
        buildTypes {
            debug
            release
        }
        components {
            main(NativeExecutableSpec)
        }
    }
"""
    }

    @Requires(IntegTestPreconditions.IsEmbeddedExecutor)

            allprojects {
                apply plugin: 'visual-studio'
            }
            subprojects {
                apply plugin: 'cpp'

                model {
                    buildTypes {
                        debug
                        release
                    }
                }
            }
        """
    }

    @ToBeFixedForConfigurationCache

        main(NativeExecutableSpec)
    }
}
task installDeveloperImage {
    description = "Install all debug executables"
    binaries.withType(NativeExecutableBinary) {
        if (it.buildable && buildType == buildTypes.debug) {
            dependsOn it.tasks.install
        }
    }
}
'''
        and:
        helloWorldApp.writeSources(file("src/main"))

        expect:
        succeeds "tasks"

        """
        buildFile << """
            model {
                components {
                    both(NativeLibrarySpec) {
                        binaries.all {
                            if (buildType == buildTypes.debug) {
                                buildable = false
                            }
                        }
                    }
                    staticOnly(NativeLibrarySpec) {

                }
                compileOptions {
                    sourceCompatibility JavaVersion.VERSION_1_8
                    targetCompatibility JavaVersion.VERSION_1_8
                }
                buildTypes {
                    release {
                        minifyEnabled false
                    }
                }
            }
        """.stripIndent()
    }

    @Override

import org.gradle.api.Named;

import java.util.Arrays;
import java.util.Collection;

public final class BuildType implements Named {
    public static final BuildType DEBUG = new BuildType("debug", true, false);
    public static final BuildType RELEASE = new BuildType("release", true, true);
    public static final Collection<BuildType> DEFAULT_BUILD_TYPES = Arrays.asList(DEBUG, RELEASE);

    private final boolean debuggable;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal;

public enum BuildType {
    TASKS,
    MODEL

import org.gradle.api.Incubating;
import org.gradle.api.Named;

/**
 * Specifies a build-type for a native binary. Common build types are 'debug' and 'release', but others may be defined.
 */
@Incubating
public interface BuildType extends Named {
    /**
     * Returns a human-consumable name for this build type.
     */
    String getDisplayName();

For example, both `configurations` and `tasks` are container objects that contain `Configuration` and `Task` objects respectively.
Community plugins also contribute containers, like the `android.buildTypes` container contributed by the Android Plugin.

The Kotlin DSL provides several ways for build authors to interact with containers.
We look at each of those ways next, using the `tasks` container as an example.

    def platform1 = Stub(NativePlatform) {
        getArchitecture() >> Architectures.forInput("i386")
    }
    def buildType1 = Stub(BuildType) {
        getName() >> "BuildType1"
    }
    def resolver = Mock(NativeDependencyResolver)

    def "uses resolver to resolve lib to dependency"() {
        def binary = testBinary(component, flavor1)