assert.Len(t, data, binary.Size(p16), "data size")
			assert.Equal(t, p16, binary.LittleEndian.Uint16(data), "data")

			channel, data, err = wsRead(ws)
			assert.NoError(t, err, "read")
			assert.Equal(t, errorChannel, int(channel), "channel")
			assert.Len(t, data, binary.Size(p16), "data size")
			assert.Equal(t, p16, binary.LittleEndian.Uint16(data), "data")

			if test.clientData != "" {

            return application.getBinaries().get().stream()
                    .filter(SwiftExecutable.class::isInstance)
                    .map(SwiftExecutable.class::cast)
                    .filter(binary -> !binary.isOptimized() && Architectures.forInput(binary.getTargetMachine().getArchitecture().getName()).equals(DefaultNativePlatform.host().getArchitecture()))
                    .findFirst()

import org.gradle.platform.base.BinaryTasksCollection;

import java.io.File;

/**
 * A static library binary built by Gradle for a native library.
 */
@Incubating
public interface StaticLibraryBinarySpec extends NativeLibraryBinarySpec {
    /**
     * Provides access to key tasks used for building the binary.
     */
    interface TasksCollection extends BinaryTasksCollection {
        /**

    def "adds compile task for binary"() {
        def binary = Stub(DefaultCppBinary)
        binary.name >> name
        binary.names >> Names.of(name)
        binary.targetMachine >> Stub(CppPlatform)

        when:
        project.pluginManager.apply(CppBasePlugin)
        project.components.add(binary)

        then:
        def compileCpp = project.tasks[taskName]

	}
	w.Flush()
	return nil
}

func encodedSize(e *raw.Event) int {
	size := 1
	var buf [binary.MaxVarintLen64]byte
	for _, arg := range e.Args {
		size += binary.PutUvarint(buf[:], arg)
	}
	spec := e.Version.Specs()[e.Ev]
	if spec.HasData {
		size += binary.PutUvarint(buf[:], uint64(len(e.Data)))
		size += len(e.Data)
	}
	return size
}

type countingReader struct {

    ])
    def "reassembles binary with target platform change"() {
        when:
        buildFile.text = buildFile.text.replace("i386", "x86-64")

        run "installMainExecutable"

        then:
        executedAndNotSkipped ":assembleHelloSharedLibraryHelloAsm"

        // Need to have valid x86-64 sources, so that we can verify the output: currently we're producing a binary that won't work on x86-64
    }

		Entries:      uint64(len(blobs)),
		MetaFileHash: finalHash,
		StrTabOffset: uint32(stOffset),
		StrTabLength: stSize,
		CMode:        mode,
		CGranularity: granularity,
	}
	var err error
	if err = binary.Write(m.w, binary.LittleEndian, mh); err != nil {
		return fmt.Errorf("error writing %s: %v", m.mfname, err)
	}

	if m.debug {
		fmt.Fprintf(os.Stderr, "=+= len(blobs) is %d\n", mh.Entries)
	}

        reportOutput.hasNodeStructure {
            components {
                sampleLib {
                    binaries {
                        binary(type: 'SampleBinary', creator: 'MyComponentBinariesPlugin.Rules#createBinariesForSampleLibrary(ModelMap<SampleBinary>, SampleLibrary) > create(binary)') {
                            tasks()
                            sources()
                        }

 * as '\n' while calculating the hash.  If a file is detected to be binary (i.e. if the file contains ASCII control characters) then the hashing
 * returns an empty {@link Optional} object.  Non-ASCII encodings (e.g. UTF-16) are treated as binary files.
 */
public class LineEndingNormalizingInputStreamHasher {

package foo

import (
	"encoding/binary"
)

type DbBuilder struct {
	arr []int
}

func (bld *DbBuilder) Finish() error {
	defer bld.Finish()

	var hash []byte
	for _, ixw := range bld.arr {
		for {
			if ixw != 0 {
				panic("ixw != 0")
			}
			ixw--
		insertOne:
			for {
				for i := 0; i < 1; i++ {
					if binary.LittleEndian.Uint16(hash[i:]) == 0 {
						break insertOne