@Override
    protected void configureCompileTask(AbstractNativeCompileTask abstractTask, final NativeBinarySpecInternal binary, final LanguageSourceSetInternal sourceSet) {
        AbstractNativeSourceCompileTask task = (AbstractNativeSourceCompileTask) abstractTask;

        task.setDescription("Compiles the " + sourceSet + " of " + binary);

        task.source(sourceSet.getSource());

        final Project project = task.getProject();

		// netlink attributes are in LTV(length, type and value) format.

		// STEP 1. parse length [2 bytes]
		if err := binary.Read(reader, binary.NativeEndian, &length); err != nil {
			return nil, err
		}

		// STEP 2. parse type   [2 bytes]
		if err := binary.Read(reader, binary.NativeEndian, &attrType); err != nil {
			return nil, err
		}

		// STEP 3. adjust the length

		return fmt.Errorf("error seeking in patchSegmentHeader: %v", err)
	}
	if cfw.debug {
		fmt.Fprintf(os.Stderr, "=-= writing counter segment header: %+v", cfw.csh)
	}
	if err := binary.Write(ws, binary.LittleEndian, cfw.csh); err != nil {
		return err
	}
	// ... and finally return to the original offset.
	if _, err := ws.Seek(off, io.SeekStart); err != nil {

            Set<File> allSourcesFromBinaries = new LinkedHashSet<>();
            for (VisualStudioTargetBinary binary : configurations.keySet()) {
                allSourcesFromBinaries.addAll(binary.getSourceFiles().getFiles());
            }
            return allSourcesFromBinaries;
        }), providerFactory.provider(() -> additionalFiles));

    }

    @Override
    protected void renderTasks(NativeExecutableBinarySpec binary, TextReportBuilder builder) {
        builder.item("install using task", binary.getTasks().getInstall().getPath());
    }

    @Override
    protected void renderOutputs(NativeExecutableBinarySpec binary, TextReportBuilder builder) {
        builder.item("executable file", binary.getExecutable().getFile());
    }

        """
    }

    @ToBeFixedForConfigurationCache
    def "strips symbols from binary"() {
        when:
        succeeds ":stripSymbolsDebug"

        then:
        executedAndNotSkipped":stripSymbolsDebug"
        executable("build/exe/main/debug/app").assertHasDebugSymbolsFor(withoutHeaders(app.original))
        binary("build/stripped").assertDoesNotHaveDebugSymbolsFor(withoutHeaders(app.original))
    }

import org.gradle.api.Incubating;
import org.gradle.platform.base.BinarySpec;

/**
 * A binary which runs a suite of tests.
 */
@Incubating
public interface TestSuiteBinarySpec extends BinarySpec {

    /**
     * Returns the test suite that this binary belongs to.
     */
    TestSuiteSpec getTestSuite();

    /**
     * Returns the binary tested by this test suite.
     */
    BinarySpec getTestedBinary();

	spec := w.specs[e.Ev]
	for _, arg := range e.Args[:len(spec.Args)] {
		w.buf = binary.AppendUvarint(w.buf, arg)
	}
	if spec.IsStack {
		frameArgs := e.Args[len(spec.Args):]
		for i := 0; i < len(frameArgs); i++ {
			w.buf = binary.AppendUvarint(w.buf, frameArgs[i])
		}
	}

	// Write out the length of the data.
	if spec.HasData {
		w.buf = binary.AppendUvarint(w.buf, uint64(len(e.Data)))
	}

	// Write out varint events.

    private static final ModelType<BinarySpec> BINARY_SPEC_MODEL_TYPE = ModelType.of(BinarySpec.class);
    private static final ModelType<Binary> BINARY_MODEL_TYPE = ModelType.of(Binary.class);
    private static final ModelType<LanguageSourceSet> LANGUAGE_SOURCE_SET_MODEL_TYPE = ModelType.of(LanguageSourceSet.class);
    private final MutableModelNode binaries;

	// for the batch.
	gen, err := binary.ReadUvarint(r)
	if err != nil {
		return batch{}, gen, fmt.Errorf("error reading batch gen: %w", err)
	}
	m, err := binary.ReadUvarint(r)
	if err != nil {
		return batch{}, gen, fmt.Errorf("error reading batch M ID: %w", err)
	}
	ts, err := binary.ReadUvarint(r)
	if err != nil {