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 {

        swift3Component | SwiftVersion.SWIFT3
        swift4Component | SwiftVersion.SWIFT4
        swift5Component | SwiftVersion.SWIFT5
    }

    @ToBeFixedForConfigurationCache
    def "can create xcode project for unbuildable swift component with #sourceCompatibility source compatibility"() {
        given:
        makeSingleProject()
        buildFile << configureTargetMachines("machines.os('os-family')")
        buildFile << """

                }
            }
        """

        expect:
        succeeds "verifyTargetMachineCount"
    }

    @ToBeFixedForConfigurationCache
    def "can specify unbuildable architecture as a component target machine"() {
        given:
        makeSingleProject()
        componentUnderTest.writeToProject(testDirectory)

        and:

    }

    @Nested
    public List<VisualStudioProjectConfiguration> getConfigurations() {
        if (configurations.isEmpty()) {
            return ImmutableList.of(new VisualStudioProjectConfiguration(this, "unbuildable", null));
        }
        return CollectionUtils.toList(configurations.values());
    }

    public void addConfiguration(VisualStudioTargetBinary nativeBinary, VisualStudioProjectConfiguration configuration) {

package org.gradle.api;

import org.gradle.api.tasks.TaskDependency;

/**
 * A {@code Buildable} represents an artifact or set of artifacts which are built by one or more {@link Task}
 * instances.
 */
public interface Buildable {
    /**
     * Returns a dependency which contains the tasks which build this artifact. All {@code Buildable} implementations

        boolean buildable = true;
        if (componentSpec instanceof VariantComponentSpec) {
            // Consider variant aware components with no buildable binaries as non-buildables
            VariantComponentSpec variantComponentSpec = (VariantComponentSpec) componentSpec;
            buildable = variantComponentSpec.getBinaries().values().stream().anyMatch(BinarySpec::isBuildable);
        }

    private final boolean buildable;

    public FixedBuildAbility(boolean buildable) {
        this.buildable = buildable;
    }

    @Override
    public boolean isBuildable() {
        return buildable;
    }

    @Override
    public void explain(DiagnosticsVisitor visitor) {
        if (!buildable) {
            visitor.node("Disabled by user");
        }
    }

    private final String name;
    private final boolean buildable;

    public VisualStudioProjectConfigurationMetadata(String name, boolean buildable) {
        this.name = name;
        this.buildable = buildable;
    }

    public String getName() {
        return name;
    }

    public boolean isBuildable() {
        return buildable;
    }

    def "is buildable when tool search is successful" () {
        when:
        result.isAvailable() >> true

        then:
        ability.isBuildable()
    }

    def "is not buildable when tool search is not successful" () {
        when:
        result.isAvailable() >> false

        then:
        !ability.isBuildable()
    }

    }

    @Override
    public String getProjectScopedName() {
        return projectScopeName;
    }

    @Override
    public boolean isBuildable() {
        return buildable;
    }

    @Override
    public boolean isTestSuite() {
        return testSuite;
    }

    @Override
    public List<DependentBinariesResolvedResult> getChildren() {
        return children;
    }