}
                }
            }
        """

        expect:
        succeeds "verifyBinariesPlatformType"
    }

    def "binaries have the right tool chain type"() {
        given:
        makeSingleProject()
        buildFile << """
            task verifyBinariesToolChainType {
                doLast {
                    ${componentUnderTestDsl}.binaries.get().each {

/*
Buildid displays or updates the build ID stored in a Go package or binary.

Usage:

	go tool buildid [-w] file

By default, buildid prints the build ID found in the named file.
If the -w option is given, buildid rewrites the build ID found in
the file to accurately record a content hash of the file.

This tool is only intended for use by the go command or
other build systems.
*/

[short] skip
[compiler:gccgo] skip # gccgo has no cover tool

# Test cover for a package that has an assembly function.

go test -outputdir=$WORK -coverprofile=cover.out coverasm
go tool cover -func=$WORK/cover.out
stdout '\tg\t*100.0%' # Check g is 100% covered.
! stdout '\tf\t*[0-9]' # Check for no coverage on the assembly function

-- go.mod --
module coverasm

go 1.16
-- p.go --
package p

func f()

func g() {

! stdout .
! stderr .
! exists obj_


# The cgo tool should only accept the source file if the working directory
# is not written in line directives in the resulting files.

[cgo] ! go tool cgo main.go
[cgo] stderr 'cgo: input path contains newline character: .*uh-oh'
[cgo] ! exists _obj

[cgo] go tool cgo -trimpath=$PWD main.go
[cgo] grep '//line main\.go:1:1' _obj/main.cgo1.go

/**
 * Details about the Java tool being used and the toolchain it belongs to.
 *
 * @since 7.6
 */
public interface JavaToolchainUsageProgressDetails {

    /**
     * Name of the tool from Java distribution such as {@code javac}, {@code java} or {@code javadoc}.
     */
    String getToolName();

    /**
     * Toolchain to which the tool belongs.
     */
    JavaToolchain getToolchain();

	goBin := testenv.GoToolPath(t)
	run(goBin, "tool", "compile", "-importcfg="+importcfgfile, "-p=large", "large.go")
	run(packPath(t), "grc", "large.a", "large.o")
	testenv.WriteImportcfg(t, importcfgfile, map[string]string{"large": filepath.Join(dir, "large.o")}, "runtime")
	run(goBin, "tool", "compile", "-importcfg="+importcfgfile, "-p=main", "main.go")
	run(goBin, "tool", "link", "-importcfg="+importcfgfile, "-L", ".", "-o", "a.out", "main.o")

        crossinline getDeclarationsByProvider: (LLFirResolveExtensionToolDeclarationProvider) -> Sequence<D>,
    ): Sequence<S> = sequence {
        for (tool in tools) {
            for (declaration in getDeclarationsByProvider(tool.declarationProvider)) {
                val declarationName = declaration.nameAsName ?: continue
                if (!nameFilter(declarationName)) continue
                with(analysisSession) {

	// In x/tools built with Go <= 1.21, we do not have Info.FileVersions
	// available. We use a go version derived from the toolchain used to
	// compile the tool by default.
	// This will be <= go1.21. We take this as the maximum version that
	// this tool can support.
	//
	// There are no features currently in x/tools that need to tell fine grained
	// differences for versions <1.22.
	return toolchain
}

! go list
! go run
! go test
! go vet

# clean succeeds, even with -modcache
go clean -modcache

# doc succeeds for standard library
go doc unsafe

# env succeeds
go env

# tool succeeds
go tool -n test2json

# version succeeds
go version

-- x.mod --
module m

-- x.go --
package main

        "unconfigured"                              | false           | false
    }

    def "identify whether #tool toolchain corresponds to the #current JVM"() {
        def jdkMetadata = AvailableJavaHomes.getJvmInstallationMetadata(jvm as Jvm)

        buildScript """
            apply plugin: "java"

            def tool = javaToolchains.${toolMethod} {