* @param <S> type of the binary to return
     * @return a binary from the collection in a finalized state
     */
    <S> BinaryProvider<S> get(Class<S> type, Spec<? super S> spec);

    /**

	const numfileOff = 16
	result.NumFile = binary.LittleEndian.Uint32(b[numfileOff:])
	result.FileOff = numfileOff + 4

	numinltreeOff := result.FileOff + 4*result.NumFile
	result.NumInlTree = binary.LittleEndian.Uint32(b[numinltreeOff:])
	result.InlTreeOff = numinltreeOff + 4

	result.Initialized = true

	return result
}

func (*FuncInfo) ReadArgs(b []byte) uint32 { return binary.LittleEndian.Uint32(b) }

	var tests = []struct {
		fileName, pkgName string
	}{
		{"", ""},
		{"///", ""},
		{"fmt", ""}, // No Go file, improper form.
		{"fmt/foo.go", "fmt"},
		{"encoding/binary/foo.go", "binary"},
		{"encoding/binary/////foo.go", "binary"},
	}
	var tf templateFile
	for _, test := range tests {
		tf.Name = test.fileName
		td := templateData{
			Files: []*templateFile{&tf},
		}
		got := td.PackageName()

        given:
        def binary = new TestBinary("binary", project.objects, implementation)

        expect:
        binary.implementationDependencies == project.configurations.binaryImplementation
        binary.implementationDependencies.extendsFrom == [implementation] as Set
    }

    def "can add implementation dependency"() {
        given:
        def binary = new TestBinary("binary", project.objects, implementation)

        null       | "binary"   | "compile" | "java" | "compileBinaryJava"
        "test"     | "binary"   | null      | null   | "testBinary"
        "test"     | "binary"   | "compile" | null   | "compileTestBinary"
        "test"     | "binary"   | "compile" | "java" | "compileTestBinaryJava"
    }

    def "generates binary name from type and dimension attributes"() {

// license that can be found in the LICENSE file.

package pprof

import (
	"encoding/binary"
	"errors"
	"fmt"
	"os"
)

var (
	errBadELF    = errors.New("malformed ELF binary")
	errNoBuildID = errors.New("no NT_GNU_BUILD_ID found in ELF binary")
)

// elfBuildID returns the GNU build ID of the named ELF binary,
// without introducing a dependency on debug/elf and its dependencies.

		"":                        {Binary: true},
		"binary.k8s.io":           {Binary: true},
		"base64.binary.k8s.io":    {Binary: false},
		"v1.binary.k8s.io":        {Binary: true},
		"v1.base64.binary.k8s.io": {Binary: false},
		"v2.binary.k8s.io":        {Binary: true},
		"v2.base64.binary.k8s.io": {Binary: false},
	})
	data, err := readWebSocket(r, t, nil, "v2.base64.binary.k8s.io")

	state[3] = 0x6b206574

	state[4] = binary.LittleEndian.Uint32(key[0:4])
	state[5] = binary.LittleEndian.Uint32(key[4:8])
	state[6] = binary.LittleEndian.Uint32(key[8:12])
	state[7] = binary.LittleEndian.Uint32(key[12:16])
	state[8] = binary.LittleEndian.Uint32(key[16:20])
	state[9] = binary.LittleEndian.Uint32(key[20:24])
	state[10] = binary.LittleEndian.Uint32(key[24:28])
	state[11] = binary.LittleEndian.Uint32(key[28:32])

# Checks that an identical binary is built with -trimpath from the same
# source files, with GOROOT in two different locations.
# Verifies golang.org/issue/38989

[short] skip
[!symlink] skip

# Symlink the compiler to a local path
env GOROOT=$WORK/goroot1
symlink $GOROOT -> $TESTGO_GOROOT

# Set up fresh GOCACHE
env GOCACHE=$WORK/gocache1
mkdir $GOCACHE

# Build a simple binary
go build -o binary1 -trimpath -x main.go

import java.util.List;

/**
 * Represents the linkage details for a binary.
 *
 * @since 4.10
 */
public interface LinkageDetails {
    /**
     * Returns details of the link task for the binary. This is the task that should be run to produce the binary output, but may not necessarily be the task that links the binary. For example, the task may do some post processing of the binary.
     */
    Task getLinkTask();

    /**