def projectConfigurations = ["unbuildable"] as Set
        projectFile.assertHasComponentSources(componentUnderTest, "src/main")
        projectFile.projectConfigurations.keySet() == projectConfigurations

        and:
        solutionFile.assertReferencesProject(projectFile, projectConfigurations)
    }

    @ToBeFixedForConfigurationCache
    def "warns about unbuildable components in generated visual studio project"() {

                .withConfiguration('unbuildable')
                .succeeds()

        then:
        resultUnbuildableSolution.size() == 1
        resultUnbuildableSolution[0].assertTasksExecuted()
        resultUnbuildableSolution[0].assertOutputContains('The project "exe" is not selected for building in solution configuration "unbuildable|Win32".')

        }
    }

    @ToBeFixedForConfigurationCache
    def "non-buildable binaries are not attached to check task"() {
        given:
        useConventionalSourceLocations()
        useStandardConfig()
        buildFile << """
model {
    components {
        unbuildable(NativeLibrarySpec)
    }
    testSuites {
        unbuildableTest(GoogleTestTestSuiteSpec) {

        for (XcodeTarget xcodeTarget : xcodeProject.getTargets()) {
            if (xcodeTarget.isBuildable()) {
                project.getTargets().add(toGradlePbxTarget(xcodeTarget));
            } else {
                getLogger().warn("'" + xcodeTarget.getName() + "' component in project '" + projectPath + "' is not buildable.");
            }
            project.getTargets().add(toIndexPbxTarget(xcodeTarget));

    def "non-buildable binaries are not attached to check task"() {
        given:
        useConventionalSourceLocations()
        useStandardConfig()
        buildFile << """
model {
    components {
        unbuildable(NativeLibrarySpec)
    }
    testSuites {
        unbuildableTest(CUnitTestSuiteSpec) {
            testing \$.components.unbuildable
        }
    }
    binaries {

    }

    def "hide non-buildable dependents by default #nonBuildables"() {
        given:
        buildScript simpleCppBuild()
        nonBuildables.each { nonBuildable ->
            buildFile << """
                model {
                    components {
                        $nonBuildable {
                            binaries.all {
                                buildable = false
                            }

        return getIdentifier().getProjectScopedName();
    }

    @Override
    public void setBuildable(boolean buildable) {
        this.disabled = !buildable;
    }

    @Override
    public final boolean isBuildable() {
        return getBuildAbility().isBuildable();
    }

    @Override
    public DomainObjectSet<LanguageSourceSet> getInputs() {
        return inputSourceSets;
    }

        }

        boolean isBuildable() { true }

        int getTime() { 0 }
    }

    def "properties are extracted from unmanaged type"() {
        when:
        def schema = extract(SimpleUnmanagedTypeWithAnnotations)

        then:
        assert schema instanceof UnmanagedImplStructSchema
        schema.properties*.name == ["buildable", "time", "unmanagedCalculatedProp", "unmanagedProp"]

                for (BinarySpecInternal binary : component.getBinaries().withType(BinarySpecInternal.class)) {
                    if (binary.isBuildable()) {
                        assemble.dependsOn(binary);
                        hasBuildableBinaries = true;
                    } else {
                        notBuildable.add(binary);
                    }

        }
        another(NativeLibrarySpec) {
            binaries.all { buildable = false }
        }
    }
}
"""
        when:
        fails "assemble"

        then:
        failureDescriptionContains("Execution failed for task ':assemble'.")
        failure.assertHasCause("""No buildable binaries found:
  - shared library 'another:sharedLibrary': Disabled by user