// compile -N

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 25966: liveness code complains autotmp live on
// function entry.

package p

var F = []func(){
	func() func() { return (func())(nil) }(),
}

var A = []int{}

type ss struct {
	string
	float64
	i int
}

		t.Error(err)
	}

	// Adding a pod with probes.
	m.AddPod(&probePod)
	probePaths := []probeKey{
		{"probe_pod", "readiness", readiness},
		{"probe_pod", "liveness", liveness},
		{"probe_pod", "startup", startup},
	}
	if err := expectProbes(m, probePaths); err != nil {
		t.Error(err)
	}

	// Removing un-probed pod.
	m.RemovePod(&noProbePod)

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check that we don't crash due to "lost track of variable in
// liveness" errors against unused variables.

package p

import "strings"

// Minimized test case from github.com/mvdan/sh/syntax.
func F() {
	var _ = []string{
		strings.Repeat("\n\n\t\t        \n", 10) +

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

// issue 8761
// used to confuse code generator into using temporary before initialization.
// caused 'variable live at entry' error in liveness analysis.

package p

func f1() {
	type C chan int
	_ = [1][]C{[]C{make(chan int)}}
}

func f2() {
	type C interface{}
	_ = [1][]C{[]C{recover()}}
}

func f3() {
	type C *int

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

// Issue 15747: If an ODCL is dropped, for example when inlining,
// then it's easy to end up not initializing the '&x' pseudo-variable
// to point to an actual allocation. The liveness analysis will detect
// this and abort the computation, so this test just checks that the
// compilation succeeds.

package p

type R [100]byte

func (x R) New() *R {
	return &x

//go:build !goexperiment.cgocheck2

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 20250: liveness differed with concurrent compilation
// due to propagation of addrtaken to outer variables for
// closure variables.

package p

type T struct {
	s [2]string
}

	}
}

func TestDumpAppGRPCProbers(t *testing.T) {
	svc := "foo"
	for _, tc := range []struct {
		name     string
		pod      *corev1.Pod
		expected string
	}{
		{
			name: "simple gRPC liveness probe",
			pod: &corev1.Pod{Spec: corev1.PodSpec{
				Containers: []corev1.Container{
					{
						Name: "foo",
						LivenessProbe: &corev1.Probe{
							ProbeHandler: corev1.ProbeHandler{

// run

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// A test for partial liveness / partial spilling / compiler-induced GC failure

package main

import "runtime"
import "unsafe"

//go:registerparams
func F(s []int) {
	for i, x := range s {
		G(i, x)
	}
	GC()
	G(len(s), cap(s))
	GC()
}

		return true
	}

	w.resultsManager.Set(w.containerID, result, w.pod)

	if (w.probeType == liveness || w.probeType == startup) && result == results.Failure {
		// The container fails a liveness/startup check, it will need to be restarted.
		// Stop probing until we see a new container ID. This is to reduce the
		// chance of hitting #21751, where running `docker exec` when a

See the License for the specific language governing permissions and
limitations under the License.
*/

package probe

// Result is a string used to handle the results for probing container readiness/liveness
type Result string

const (
	// Success Result
	Success Result = "success"
	// Warning Result. Logically success, but with additional debugging information attached.
	Warning Result = "warning"
	// Failure Result