*/
    String getName();

    /**
     * All binaries buildable for this component. These will implement {@link CppExecutable}, {@link CppSharedLibrary} or {@link CppStaticLibrary}.
     */
    DomainObjectSet<? extends CppBinary> getBinaries();

    /**

@Incubating @HasInternalProtocol
public interface BinarySpec extends BuildableComponentSpec, CheckableComponentSpec, Binary {

    /**
     * Can this binary be built in the current environment?
     */
    boolean isBuildable();

    /**
     * The sources owned by this binary.
     *
     * @return the sources owned by the binary.
     */
    ModelMap<LanguageSourceSet> getSources();

    /**

import (
	"internal/platform"
	"testing"
)

// TestSupported tests that dist and the main tools agree on
// which build modes are supported for a given target. We do things
// this way because the dist tool needs to be buildable directly by
// the bootstrap compiler, and as such can't import internal packages.
func TestSupported(t *testing.T) {
	defer func(a, o string) {
		goarch = a
		goos = o
	}(goarch, goos)

	var modes = []string{

     * Returns a name for this binary that is unique for all binaries in the current project.
     */
    String getProjectScopedName();

    Class<? extends BinarySpec> getPublicType();

    void setBuildable(boolean buildable);

    BinaryBuildAbility getBuildAbility();

    boolean isLegacyBinary();

    BinaryNamingScheme getNamingScheme();

    void setNamingScheme(BinaryNamingScheme namingScheme);

     *
     * <li>{@link org.gradle.api.tasks.TaskDependency}</li>
     *
     * <li>{@link org.gradle.api.internal.tasks.TaskDependencyContainer}</li>
     *
     * <li>{@link org.gradle.api.Buildable}</li>
     *
     * <li>{@link TransformNodeDependency}</li>
     *
     * <li>{@link WorkNodeAction}</li>
     *
     * </ul>
     */
    void add(Object dependency);

    /**

        List<DependentBinariesResolvedResult> allChildren = new ArrayList<>();
        for (DependentBinariesResolvedResult result : results) {
            if (!result.isBuildable()) {
                hasNotBuildables = true;
            }
            if (result.isTestSuite()) {
                hasTestSuites = true;
            }
            allChildren.addAll(result.getChildren());

			testCase.serverAddrs,
			TCPOptions{},
		)
		for _, err := range errs {
			if err != nil {
				if strings.Contains(err.Error(), "The requested address is not valid in its context") {
					// Ignore if IP is unbindable.
					continue nextTest
				}
				if strings.Contains(err.Error(), "bind: address already in use") {
					continue nextTest
				}
				t.Fatalf("Test %d: error: expected = <nil>, got = %v", i+1, err)
			}

import javax.annotation.concurrent.ThreadSafe;
import java.util.Collection;

/**
 * A build scoped service that collects information on the local "publications" of each project within a build. A "publication" here means some buildable thing that the project produces that can be consumed outside of the project.
 *
 * The information is gathered from multiple sources ({@code publishing.publications} container, etc.).
 */
@ThreadSafe

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.plugins.signing;

import groovy.lang.Closure;
import org.gradle.api.Buildable;
import org.gradle.api.Incubating;
import org.gradle.api.InvalidUserDataException;
import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.internal.artifacts.publish.AbstractPublishArtifact;

            for (NativeBinarySpec binary : binaries.withType(NativeBinarySpec.class)) {
                if (binary.isBuildable()) {
                    visualStudioExtension.getProjectRegistry().addProjectConfiguration(new NativeSpecVisualStudioTargetBinary(binary));
                }
            }
        }

        @Mutate