linkTask.getTargetPlatform().set(binary.getTargetPlatform());
                    linkTask.getLinkedFile().set(binary.getSharedLibraryFile());
                    linkTask.getInstallName().set(binary.getSharedLibraryFile().getName());
                    linkTask.getLinkerArgs().set(binary.getLinker().getArgs());
                    linkTask.getImportLibrary().set(binary.getSharedLibraryLinkFile());

    private final CppSharedLibrary binary;

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

    @Override
    CppBinary getBinary() {
        return binary;
    }

    @Override

            final Names names = binary.getNames();
            TaskProvider<SwiftCompile> compile = tasks.register(names.getCompileTaskName("swift"), SwiftCompile.class, task -> {
                task.getModules().from(binary.getCompileModules());
                task.getSource().from(binary.getSwiftSource());
                task.getDebuggable().set(binary.isDebuggable());

    private final VisualStudioTargetBinary binary;

    public VisualStudioProjectConfiguration(DefaultVisualStudioProject vsProject, String configurationName, VisualStudioTargetBinary binary) {
        this.vsProject = vsProject;
        this.configurationName = configurationName;
        this.name = configurationName + "|" + platformName;
        this.binary = binary;
    }

    @Input
    public String getName() {

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