# GOARCH: The target architecture for installed packages and tools.
#
# GOOS: The target operating system for installed packages and tools.
#
# GO_GCFLAGS: Additional go tool compile arguments to use when
# building the packages and commands.
#
# GO_LDFLAGS: Additional go tool link arguments to use when
# building the commands.
#
# CGO_ENABLED: Controls cgo usage during the build. Set it to 1

    String id();

    /**
     * Returns the name of the tool option for this path. For example, if this path type
     * is {@link JavaPathType#MODULES}, then this method returns {@code "--module-path"}.
     * The option does not include the {@linkplain JavaPathType.Modular#moduleName() module name}
     * on which it applies.
     *
     * @return the name of the tool option for this path type
     */
    @Nonnull

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.function.Consumer;

/**
 * <p>
 * A context tracking tool for calls to dynamic methods.
 * Notifies the {@code onEnter} and {@code onLeave} listeners upon entering and leaving calls,
 * which is triggered by {@code enterDynamicCall} and {@code leaveDynamicCall}.
 * <p>

        "assigned tool"  | "when configured"                    | "other"  | null           | null              | "other"
        "executable"     | "over java extension"                | null     | "other"        | "current"         | "other"
        "assigned tool"  | "over java extension"                | "other"  | null           | "current"         | "other"
    }

var ToolchainVersion = runtime.Version()

// The Go toolchain.

type gcToolchain struct{}

func (gcToolchain) compiler() string {
	return base.Tool("compile")
}

func (gcToolchain) linker() string {
	return base.Tool("link")
}

func pkgPath(a *Action) string {
	p := a.Package
	ppath := p.ImportPath
	if cfg.BuildBuildmode == "plugin" {
		ppath = pluginPath(a)

		base.Exit()
	}
	// Increment a subcommand counter for the subcommand we're running.
	// Don't increment the counter for the tool subcommand here: we'll
	// increment in the tool subcommand's Run function because we need
	// to do the flag processing in invoke first.
	if cfg.CmdName != "tool" {
		telemetry.Inc("go/subcommand:" + strings.ReplaceAll(cfg.CmdName, " ", "-"))
	}
	telemetrystats.Increment()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test2json converts go test output to a machine-readable JSON stream.
//
// Usage:
//
//	go tool test2json [-p pkg] [-t] [./pkg.test -test.v=test2json]
//
// Test2json runs the given test command and converts its output to JSON;
// with no command specified, test2json expects test output on standard input.

env GOROOT=

# Relocated Executable
exec $WORK/bin/check$GOEXE $WORK/new/bin/go$GOEXE $TESTGOROOT

# Relocated Tree:
# If the binary is sitting in a bin dir next to ../pkg/tool, that counts as a GOROOT,
# so it should find the new tree.
mkdir $WORK/new/pkg/tool
exec $WORK/bin/check$GOEXE $WORK/new/bin/go$GOEXE $WORK/new

[!symlink] stop 'The rest of the test cases require symlinks'

# Symlinked Executable:

plugins {
    id("gradlebuild.internal.java")
    id("gradlebuild.performance-test")
    id("gradlebuild.performance-templates")
}

description = "Performance tests for the Gradle build tool"

dependencies {
    performanceTestImplementation(project(":base-services"))
    performanceTestImplementation(project(":core"))
    performanceTestImplementation(project(":internal-testing"))
    performanceTestImplementation(project(":stdlib-java-extensions"))

        }
    }

    static void assertToolchainUsages(List<BuildOperationRecord.Progress> events, JvmInstallationMetadata jdkMetadata, String tool) {
        assert events.size() > 0
        events.each { usageEvent ->
            assertToolchainUsage(tool, jdkMetadata, usageEvent)
        }
    }