import org.gradle.api.tasks.Internal;

/**
 * Metadata about a Java tool obtained from a toolchain.
 *
 * @see JavaLauncher
 * @see JavaCompiler
 * @see JavadocTool
 *
 * @since 6.7
 */
public interface JavaInstallationMetadata {
    /**
     * Returns the language version of the JVM to which this tool belongs
     *
     * @return the {@code JavaLanguageVersion}
     */
    @Input

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

// The runtime package uses //go:linkname to push a few functions into this
// package but we still need a .s file so the Go tool does not pass -complete
// to the go tool compile so the latter does not complain about Go functions

    public DefaultSwiftcPlatformToolChain(NativePlatform platform) {
        this.platform = platform;
    }

    public void add(DefaultCommandLineToolConfiguration tool) {
        tools.put(tool.getToolType(), tool);
    }

    @Override
    public CommandLineToolConfiguration getSwiftCompiler() {
        return tools.get(ToolType.SWIFT_COMPILER);
    }

    @Override

            String mvnName = jenkinsEnv.mvnFromVersion(buildOs, buildMvn)
            try {
                withEnv(["JAVA_HOME=${ tool "$jdkName" }",
                         "PATH+MAVEN=${ tool "$jdkName" }/bin:${tool "$mvnName"}/bin",
                         "MAVEN_OPTS=-Xms2g -Xmx4g -Djava.awt.headless=true"]) {                   

                }
            ''')
            src {
                main {
                    java {
                        'Tool.java'('public interface Tool { void execute(); }')
                        'ToolHelper.java'('public class ToolHelper { void execute() { new Internal().use(); } ; }')
                    }
                }
            }
        }
        subproject('c') {
            'build.gradle'('')

                    }
                }
            }
        """

        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() {

/**
 * 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();

! 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