test(NativeExecutableSpec) {
                        binaries.all { NativeBinary binary ->
                            binary."${this.pluginName}Compiler".define "NDEBUG"
                            binary."${this.pluginName}Compiler".define "LEVEL", "1"
                            binary."${this.pluginName}Compiler".args "ARG1", "ARG2"
                        }
                        sources {

            for (TestSuiteSpec testSuite : testSuites.values()) {
                for (BinarySpecInternal binary : testSuite.getBinaries().withType(BinarySpecInternal.class).values()) {
                    binaries.put(binary.getProjectScopedName(), binary);
                }
            }
        }

        @Finalize

    private final CppExecutable binary;

    public CppApplicationVisualStudioTargetBinary(String projectName, String projectPath, CppComponent component, CppExecutable binary, ProjectLayout projectLayout) {
        super(projectName, projectPath, component, projectLayout);
        this.binary = binary;
    }

    @Override
    public String getVisualStudioProjectName() {

[short] skip
[compiler:gccgo] skip # gccgo has no cover tool

go test -short -cover encoding/binary errors -coverprofile=$WORK/cover.out
! stderr '[^0-9]0\.0%'
! stdout '[^0-9]0\.0%'

grep -count=1 '^mode: set$' $WORK/cover.out
grep 'errors\.go' $WORK/cover.out
grep 'binary\.go' $WORK/cover.out

[!race] stop

go test -short -race -cover encoding/binary errors -coverprofile=$WORK/cover.out
! stderr '[^0-9]0\.0%'
! stdout '[^0-9]0\.0%'

            // Prefer the host architecture, if present, else use the first architecture specified
            return application.getBinaries().get().stream()
                    .filter(CppExecutable.class::isInstance)
                    .map(CppExecutable.class::cast)

        static String returnValue(ModelMap<Task> builder, SomeBinarySpec binary) {
        }

        @BinaryTasks
        static void noParams() {
        }

        @BinaryTasks
        static void wrongSubject(BinarySpec binary, String input) {
        }

        @BinaryTasks
        static void rawModelMap(ModelMap tasks, SomeBinarySpec binary) {
        }

        @BinaryTasks

        (repository == publishing.repositories["external"] &&
            publication == publishing.publications["binary"]) ||
        (repository == publishing.repositories["internal"] &&
            publication == publishing.publications["binaryAndSources"])
    }
    onlyIf("publishing binary to the external repository, or binary and sources to the internal one") {
        predicate.get()
    }
}

/**
 * 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);

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();

    /**

    @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 ->