if (buildType == buildTypes.debug) {
                                buildable = false
                            }
                        }
                    }
                    staticOnly(NativeLibrarySpec) {
                        binaries.withType(SharedLibraryBinarySpec) {
                            buildable = false
                        }
                    }

 * limitations under the License.
 */
package org.gradle.api.tasks;

import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import org.gradle.api.Buildable;
import org.gradle.api.GradleException;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.file.FileCollection;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.file;

import groovy.lang.Closure;
import org.gradle.api.Buildable;
import org.gradle.api.InvalidUserDataException;
import org.gradle.api.Task;
import org.gradle.api.file.Directory;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.DirectoryTree;

    def "can build current architecture when other, non-buildable architectures are specified"() {
        given:
        makeSingleProject()
        componentUnderTest.writeToProject(testDirectory)

        and:
        buildFile << configureTargetMachines("machines.${currentHostOperatingSystemFamilyDsl}.architecture('foo')", "machines.${currentHostOperatingSystemFamilyDsl}")
        buildFile << configureToolChainSupport('foo')

        buildFile << """
            tasks.register("b") {
                dependsOn files(file('123'))
            }
        """

        when:
        run("b")

        then:
        result.assertTasksExecuted(":b")
    }

    def "produces reasonable error message when task dependency closure throws exception"() {
        buildFile << """
    task a
    a.dependsOn {

 * limitations under the License.
 */

package org.gradle.api.publish.tasks;

import com.google.common.collect.ImmutableSet;
import org.gradle.api.Action;
import org.gradle.api.Buildable;
import org.gradle.api.DefaultTask;
import org.gradle.api.Project;
import org.gradle.api.UncheckedIOException;
import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.component.SoftwareComponentVariant;

            projectFile.addHeaderFile(headerFile);
        }

        if (vsProject.getConfigurations().stream().noneMatch(it -> it.isBuildable())) {
            getLogger().warn("'" + vsProject.getComponentName() + "' component in project '" + getProject().getPath() + "' is not buildable.");
        }
        for (VisualStudioProjectConfiguration configuration : vsProject.getConfigurations()) {

                } else {
                    result.add("${configurationName}.ActiveCfg = ${configuration.name}")
                    if (configuration.buildable) {
                        result.add("${configurationName}.Build.0 = ${configuration.name}")
                    }
                }
                return result
            }

  ]]></description>
  <defaults>
    <default>
      <key>package</key>
      <value>extension descriptor XML documentation (no java generation)</value><!-- intentionally non-buildable value -->
    </default>
  </defaults>
  <classes>
    <class rootElement="true" xml.tagName="extension">
      <name>ExtensionDescriptor</name>
      <version>1.0.0</version>

            metadata = m
        }
        metadata.name == "mainExe"
        metadata.configurations*.name == ["vsConfig|Win32"]
        metadata.configurations*.buildable == [true]
    }

    def "returns same visual studio project configuration for native binaries that share project name"() {
        def executableBinary1 = targetBinary("vsConfig1")