{{ disallow_privilege_escalation}}
      {{ capabilities }}
        {{ drop_capabilities }}
    image: registry.k8s.io/kas-network-proxy/proxy-server:v0.30.3
    resources:
      requests:
        cpu: 25m
    command: [ "/proxy-server"{{ konnectivity_args }} ]
    livenessProbe:
      httpGet:
        scheme: HTTP
        host: 127.0.0.1
        port: {{ health_port }}
        path: /healthz

# panic with unsorted main modules.
cp go.work.backwards go.work
go work use # update go version
go run example.com/d

# Test that command-line-arguments work inside and outside modules.
# This exercises the code that determines which module command-line-arguments
# belongs to.
go list ./b/main.go
env GOWORK=off
go build -n -o foo foo.go
env GOWORK=
go build -n -o foo foo.go

-- go.work.dup --

	End   uint64   // virtual address of last byte in sym (Start+size-1)
}

// A UI manages user interactions.
type UI interface {
	// ReadLine returns a line of text (a command) read from the user.
	// prompt is printed before reading the command.
	ReadLine(prompt string) (string, error)

	// Print shows a message to the user.
	// It formats the text as fmt.Print would and adds a final \n if not already present.

        because("This is the Gradle daemon implementation, which transitively depends on all other core projects.")
    }
    runtime(project(":gradle-cli-main")) {
        because("This is the entry point of the `gradle` command.")
    }
    runtime(project(":daemon-main")) {
        because("This is the entry point of the Gradle daemon.")
    }
    runtime(project(":tooling-api-provider")) {

            }
        """
    }

    @Override
    String logStatement() {
        "Compiling with Java command line compiler"
    }

	}
	fmt.Fprintf(f, `
package main

import "fmt"

func main() {
        n, err := fmt.Println(1)
}
`)
	f.Close()
	defer os.RemoveAll(f.Name())

	// compile and test output
	cmd := exec.Command("go", "tool", "compile", "-p=main", "-importcfg="+os.Getenv("STDLIB_IMPORTCFG"), f.Name())
	out, err := cmd.CombinedOutput()
	if err == nil {
		log.Fatalf("expected cmd/compile to fail")
	}
	wantErrs := []string{

            }
        """
    }

    @Override
    String logStatement() {
        "Compiling with Java command line compiler"
    }

func TestPanicNilRace(t *testing.T) {
	if !race.Enabled {
		t.Skip("Skipping test intended for use with -race.")
	}
	if os.Getenv("GODEBUG") != "panicnil=1" {
		cmd := testenv.CleanCmdEnv(testenv.Command(t, os.Args[0], "-test.run=^TestPanicNilRace$", "-test.v", "-test.parallel=2", "-test.count=1"))
		cmd.Env = append(cmd.Env, "GODEBUG=panicnil=1")
		out, err := cmd.CombinedOutput()
		t.Logf("output:\n%s", out)

    srcs = glob(
        [
            "**/importer_test_min_max.cc.mlir",
            "**/reshape.mlir",
        ],
    ),
)

# A binary to inject min/max to a tflite model.
# A file check command is used to verify the imported result from this
# binary format.
tf_native_cc_binary(
    name = "importer_test_min_max",
    srcs = [
        "importer_test_min_max.cc",
    ],
    deps = [

	"cmd/go/internal/modload"
	"cmd/internal/telemetry"
)

func Increment() {
	incrementConfig()
	incrementVersionCounters()
}

// incrementConfig increments counters for the configuration
// the command is running in.
func incrementConfig() {
	if !modload.WillBeEnabled() {
		telemetry.Inc("go/mode:gopath")
	} else if workfile := modload.FindGoWork(base.Cwd()); workfile != "" {
		telemetry.Inc("go/mode:workspace")