t.Logf("found GOROOT %q from environment; checking embedded GOROOT value", envGoroot)
		testenv.MustHaveExec(t)
		exe, err := os.Executable()
		if err != nil {
			t.Fatal(err)
		}
		cmd := exec.Command(exe)
		cmd.Env = append(os.Environ(), "GOROOT=", "GO_RUNTIME_DEBUG_TEST_ENTRYPOINT=dumpgoroot")
		out, err := cmd.Output()
		if err != nil {
			t.Fatal(err)
		}
		fileGoroot = string(bytes.TrimSpace(out))
	} else {

        then:
        executedAndNotSkipped ":run"

        when:
        run "run"

        then:
        executedAndNotSkipped ":run"
    }

    def 'arguments passed via command line take precedence and is not incremental by default'() {
        when:
        run("run", "--args", "2 '3' \"4\"")

        then:
        executedAndNotSkipped ":run"
        assertOutputFileIs('''\

            int exitValue = result.getExitValue();
            if (exitValue == 0) {
                return parseExecOutput(jdkPath, out.toString());
            }
            String errorMessage = "Command returned unexpected result code: " + exitValue + "\nError output:\n" + errorOutput;
            logger.debug("Failed to get metadata from JVM installation at '{}'. {}", jdkPath, errorMessage);

 *
 * Visit the [Develocity Plugin User Manual](https://docs.gradle.com/enterprise/gradle-plugin/) for additional information.
 *
 * By default, the applied plugin version will be the same as the one used by the `--scan` command line option.
 *
 * You can also use e.g. `` `gradle-enterprise` version "3.0" `` to request a different version.
 *
 * @since 6.0
 */

package netip

import (
	"internal/testenv"
	"os/exec"
	"regexp"
	"runtime"
	"strings"
	"testing"
)

func TestInlining(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()
	out, err := exec.Command(
		testenv.GoToolPath(t),
		"build",
		"--gcflags=-m",
		"net/netip").CombinedOutput()
	if err != nil {
		t.Fatalf("go build: %v, %s", err, out)
	}
	got := map[string]bool{}

			return
		}
		cmd := path.Join(*releasedir, name)
		args := []string{"version", "-ojson"}
		if name == "istioctl" {
			args = append(args, "--remote=false")
		}

		out, err := exec.Command(cmd, args...).Output()
		if err != nil {
			t.Fatalf("--version failed with error: %v. Output: %v", err, string(out))
		}

		var resp version.Version
		if err := json.Unmarshal(out, &resp); err != nil {

	deletionGracePeriod := int64(10)
	terminationGracePeriod := int64(10)
	lifecycle := &v1.Lifecycle{
		// Left PostStart as nil
		PreStop: &v1.LifecycleHandler{
			Exec: &v1.ExecAction{
				Command: []string{"action1", "action2"},
			},
			HTTPGet: &v1.HTTPGetAction{
				Path:   "path",
				Host:   "host",
				Port:   intstr.FromInt32(8080),
				Scheme: "scheme",
			},
			TCPSocket: &v1.TCPSocketAction{

		exe, err := buildTestProg(t, "testexithooks", bmode)
		if err != nil {
			t.Fatal(err)
		}

		bt := ""
		if bmode != "" {
			bt = " bmode: " + bmode
		}
		for _, s := range scenarios {
			cmd := exec.Command(exe, []string{"-mode", s.mode}...)
			out, _ := cmd.CombinedOutput()
			outs := strings.ReplaceAll(string(out), "\n", " ")
			outs = strings.TrimSpace(outs)
			if s.expected != "" && s.expected != outs {

 */
public final class AgentUtils {
    private AgentUtils() {}

    public static final String AGENT_MODULE_NAME = "gradle-instrumentation-agent";

    /**
     * Checks if the command-line argument looks like JVM switch that applies gradle instrumentation agent.
     * If the returned value is {@code true} then the argument is definitely a java agent application.

        if(parentFolder == null || !parentFolder.exists()) {
            Exception cause = new NoSuchFileException(javaCommand);
            throw new ExecException("A problem occurred starting process 'command '" + javaCommand + "''", cause);
        }
        return getVersionFromJavaHome(parentFolder.getParentFile());
    }

    private int getVersionFromJavaHome(File javaHome) {