)

func main() {
	tool, args := os.Args[1], os.Args[2:]
	toolName := filepath.Base(tool)
	if len(args) > 0 && args[0] == "-V=full" {
		// We can't alter the version output.
	} else {
		// Print which tool we're running, and on what package.
		fmt.Fprintf(os.Stdout, "%s TOOLEXEC_IMPORTPATH=%q\n", toolName, os.Getenv("TOOLEXEC_IMPORTPATH"))
	}

	// Simply run the tool.
	cmd := exec.Command(tool, args...)

        private final File tool;

        private FoundTool(File tool) {
            this.tool = tool;
        }

        @Override
        public boolean isAvailable() {
            return true;
        }

        @Override
        public File getTool() {
            return tool;
        }

        @Override

# Also make sure we print the short help line.
! go vet -h
stderr 'usage: go vet .*'
stderr 'Run ''go help vet'' for details.'
stderr 'Run ''go tool vet help'' for a full list of flags and analyzers.'
stderr 'Run ''go tool vet -help'' for an overview.'

# Earlier versions of Go printed a large document here, instead of these two
# lines.
! go test -h
stderr 'usage: go test'

import org.gradle.nativeplatform.fixtures.AbstractInstalledToolChainIntegrationSpec
import org.gradle.nativeplatform.fixtures.app.CppCompilerDetectingTestApp

/**
 * Test that each available tool chain can be discovered and used without configuration, assuming it is in the path.
 */
class NativeToolChainDiscoveryIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {

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

! stderr ${/}compile$GOEXE.*' -D[ =]'

go tool buildid a.exe
cp stdout ../foo-buildid.txt
go version a.exe
cp stdout ../foo-version.txt
cd ..


# On the second build — in a different directory but with -trimpath — the
# compiler should not be invoked, since the cache key should be identical.
# Only the linker and buildid tool should be needed.

mkdir bar
cp foo/main.go bar/main.go
cd bar

// 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

            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"]) {                   

    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

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