{
        "name": "ETCDCTL_API",
        "value": "3"
      }
        ],
    "livenessProbe": {
      "exec": {
        "command": [
          "/bin/sh",
          "-c",
          "set -x; exec /usr/local/bin/etcdctl --endpoints=127.0.0.1:{{ port }} {{ etcdctl_certs }} --command-timeout=15s endpoint health"
        ]
      },
      "initialDelaySeconds": {{ liveness_probe_initial_delay }},
      "timeoutSeconds": 15,

package tls

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[PKCS1WithSHA256-1025]
	_ = x[PKCS1WithSHA384-1281]
	_ = x[PKCS1WithSHA512-1537]
	_ = x[PSSWithSHA256-2052]
	_ = x[PSSWithSHA384-2053]
	_ = x[PSSWithSHA512-2054]

import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import spock.lang.Issue

class BuildSrcTaskExecutionIntegrationTest extends AbstractIntegrationSpec {
    def "can execute a task from buildSrc from the command line"() {
        file("buildSrc/build.gradle") << """
            task something {
                doLast { }
            }
        """

        expect:
        2.times {

class MultipleTaskOptionsIntegrationTest extends AbstractIntegrationSpec {

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "can configure tasks from command line in multiple projects"() {
        given:
        createDirs("project2")
        settingsFile << "include 'project2'"
        buildFile << """
            allprojects {
                task someTask(type: SomeTask)

stdout 'on'

go env
stdout 'GOTELEMETRY=''?on''?'
stdout 'GOTELEMETRYDIR=''?'$userconfig'[\\/]go[\\/]telemetry''?'
! go env -w GOTELEMETRY=off
stderr '^go: unknown go command variable GOTELEMETRY$'
! go env -w GOTELEMETRYDIR=foo

	dir, err := os.MkdirTemp("", filepath.Base(t.Name()))
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)

	dst := filepath.Join(dir, strings.TrimSuffix(file, ".go"))
	cmd := exec.Command("go", "build", "-gcflags=-L -e", "-o="+dst, path(file)) // TODO(gri) no need for -gcflags=-L if go tool is adjusted
	out, err := cmd.CombinedOutput()
	if err == nil {
		t.Errorf("expected cgo to fail but it succeeded")
	}

//go:build ignore

package main

import (
	"bytes"
	"fmt"
	"internal/trace/raw"
	"internal/trace/version"
	"io"
	"log"
	"os"
	"os/exec"
)

func main() {
	// Create command.
	var trace, stderr bytes.Buffer
	cmd := exec.Command("go", "run", "./testprog/main.go")
	cmd.Stdout = &trace
	cmd.Stderr = &stderr

	// Run trace program; the trace will appear in stdout.
	fmt.Fprintln(os.Stderr, "running trace program...")

import java.util.Map;

/**
 * An immutable view of all properties available for build options, calculated from command-line options, the environment and the various
 * properties files.
 */
public interface AllProperties {
    /**
     * Returns the system properties defined as command-line options.
     */
    Map<String, String> getRequestedSystemProperties();

    /**

            // All good
            return;
        }

        for (BuiltInCommand command : builtInCommands) {
            if (command.commandLineMatches(startParameter.getTaskNames())) {
                // Allow missing settings and build scripts when running a built-in command
                return;
            }
        }

        StringBuilder message = new StringBuilder("Directory '");

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

// Package telemetrycmd implements the "go telemetry" command.
package telemetrycmd

import (
	"context"
	"fmt"
	"os"

	"cmd/go/internal/base"
	"cmd/internal/telemetry"
)

var CmdTelemetry = &base.Command{
	UsageLine: "go telemetry [off|local|on]",
	Short:     "manage telemetry data and settings",