/**
 * A collection of tasks associated to a binary
 */
@Incubating
@UnmanagedStruct
public interface BinaryTasksCollection extends DomainObjectSet<Task> {
    /**
     * Generates a name for a task that performs some action on the binary.
     */
    String taskName(String verb);

    /**
     * Generates a name for a task that performs some action on the binary.
     */
    String taskName(String verb, String object);

below.

For each component, Gradle defines one or more _binaries_ as output. To build a binary, Gradle will take the source files defined for the component, compile them as appropriate for the source language, and link the result into a binary file. For an executable component, Gradle can produce executable binary files. For a library component, Gradle can produce both static and shared library binary files. For example, when you define a library called `helloworld` and build on Linux, Gradle...

    def "delegates to renderer for type"() {
        def binary = Stub(SomeBinary)
        def output = Stub(TextReportBuilder)
        def renderer = new TypeAwareBinaryRenderer()
        def binRenderer = Mock(AbstractBinaryRenderer)

        given:
        binRenderer.targetType >> binary.getClass()
        renderer.register(binRenderer)

        when:
        renderer.render(binary, output)

        then:

        private final Map<NativeBinarySpecInternal, List<NativeBinarySpecInternal>> dependents = new HashMap<>();

        void registerBinary(NativeBinarySpecInternal binary) {
            if (dependencies.get(binary) == null) {
                dependencies.put(binary, new LinkedHashSet<>());
            }
        }

        List<NativeBinarySpecInternal> getDependents(NativeBinarySpecInternal target) {

	var ident [4]byte
	if _, err := r.ReadAt(ident[0:], 0); err != nil {
		return nil, err
	}
	be := binary.BigEndian.Uint32(ident[0:])
	le := binary.LittleEndian.Uint32(ident[0:])
	switch Magic32 &^ 1 {
	case be &^ 1:
		f.ByteOrder = binary.BigEndian
		f.Magic = be
	case le &^ 1:
		f.ByteOrder = binary.LittleEndian
		f.Magic = le
	default:
		return nil, &FormatError{0, "invalid magic number", nil}
	}

	"k8s.io/apimachinery/pkg/util/runtime"
)

// The WebSocket subprotocol "binary.k8s.io" will only send messages to the
// client and ignore messages sent to the server. The received messages are
// the exact bytes written to the stream. Zero byte messages are possible.
const binaryWebSocketProtocol = "binary.k8s.io"

// The WebSocket subprotocol "base64.binary.k8s.io" will only send messages to the

    @BinaryTasks
    void processMarkdownDocumentation(ModelMap<Task> tasks, final DocumentationBinary binary) {
        binary.inputs.withType(MarkdownSourceSet) { markdownSourceSet ->
            def taskName = binary.tasks.taskName("compile", markdownSourceSet.name)
            def outputDir = new File(binary.outputDir, markdownSourceSet.name)
            tasks.create(taskName, MarkdownHtmlCompile) { compileTask ->

import org.gradle.api.Incubating;
import org.gradle.platform.base.Binary;
import org.gradle.nativeplatform.platform.NativePlatform;

/**
 * Represents a particular binary artifact.
 */
@Incubating
public interface NativeBinary extends Binary {
    /**
     * The {@link org.gradle.nativeplatform.Flavor} that this binary was built with.
     */
    Flavor getFlavor();

    /**

                        }
                        binaries.all { NativeBinary binary ->
                            binary.assembler.args "ARG1", "ARG2"
                        }
                    }
                }
            }
        }

        then:
        NativeExecutableBinarySpec binary = realizeBinaries().testExecutable

	}

	// Length in bits.
	len <<= 3
	binary.BigEndian.PutUint64(tmp[:], len)
	d.Write(tmp[0:8])

	if d.nx != 0 {
		panic("d.nx != 0")
	}

	var digest [Size]byte

	binary.BigEndian.PutUint32(digest[0:], d.h[0]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[4:], d.h[1]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[8:], d.h[2]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[12:], d.h[3]^0xFFFFFFFF)