}
			value := h.chunks[j] >> huffmanValueShift
			linktab := h.links[value]
			reverse >>= huffmanChunkBits
			for off := reverse; off < len(linktab); off += 1 << uint(n-huffmanChunkBits) {
				if sanity && linktab[off] != 0 {
					panic("impossible: overwriting existing chunk")
				}
				linktab[off] = chunk
			}
		}
	}

	if sanity {

        if (toolchain.visualCpp) {
            releaseBinary.linkageDetails.linkTask.path == ":linkRelease"
            releaseBinary.linkageDetails.linkTask.name == "linkRelease"
        } else {
            releaseBinary.linkageDetails.linkTask.path == ":stripSymbolsRelease"
            releaseBinary.linkageDetails.linkTask.name == "stripSymbolsRelease"
        }

        project.testComponent == null
    }

        if (toolchain.visualCpp) {
            releaseX86Binary.linkageDetails.linkTask.path == ":linkReleaseX86"
            releaseX86Binary.linkageDetails.linkTask.name == "linkReleaseX86"
        } else {
            releaseX86Binary.linkageDetails.linkTask.path == ":stripSymbolsReleaseX86"
            releaseX86Binary.linkageDetails.linkTask.name == "stripSymbolsReleaseX86"
        }

            @Override
            public void execute(LinkExecutable linkTask) {
                linkTask.setDescription("Links " + binary.getDisplayName());
                linkTask.getToolChain().set(binary.getToolChain());
                linkTask.getTargetPlatform().set(binary.getTargetPlatform());
                linkTask.getLinkedFile().set(executableFile);
                linkTask.getLinkerArgs().set(binary.getLinker().getArgs());

        sharedLibrary.linkTask >> linkTaskProp
        sharedLibrary.linkFileProducer >> linkFileTasKProp

        given:
        project.pluginManager.apply(NativeBasePlugin)
        project.components.add(sharedLibrary)

        expect:
        def linkTask = project.tasks['linkWindowsDebug']
        linkTask instanceof LinkSharedLibrary

    }

    void assertHasNoFailedTests() {
        def tab = findTab('Failed tests')
        assert tab.isEmpty()
    }

    void assertHasNoIgnoredTests() {
        def tab = findTab('Ignored tests')
        assert tab.isEmpty()
    }

    void assertHasNoNavLinks() {
        assert findTab('Packages').isEmpty()
    }

    void assertHasLinkTo(String target, String display = target) {

public class DefaultLinkageDetails implements Serializable {
    private final LaunchableGradleTask linkTask;
    private final File outputLocation;
    private final List<String> additionalArgs;

    public DefaultLinkageDetails(LaunchableGradleTask linkTask, File outputLocation, List<String> additionalArgs) {
        this.linkTask = linkTask;
        this.outputLocation = outputLocation;
        this.additionalArgs = additionalArgs;
    }

        linkTask = objectFactory.property(LinkMachOBundle.class);
    }

    @Override
    public Property<LinkMachOBundle> getLinkTask() {
        return linkTask;
    }

// code goes to the expense of looking for a simultaneous line number match.
func (t *LineTable) findFileLine(entry uint64, filetab, linetab uint32, filenum, line int32, cutab []byte) uint64 {
	if filetab == 0 || linetab == 0 {
		return 0
	}

	fp := t.pctab[filetab:]
	fl := t.pctab[linetab:]
	fileVal := int32(-1)
	filePC := entry
	lineVal := int32(-1)
	linePC := entry
	fileStartPC := filePC

        tasks.install == null
        tasks.run == null
    }

    def "returns link task when defined"() {
        when:
        final linkTask = testUtil.task(LinkExecutable)
        tasks.add(linkTask)

        then:
        tasks.link == linkTask
        tasks.install == null
        tasks.run == null
    }

    def "returns install task when defined"() {
        when: