}

type podSecurityContextWrapper struct {
	podSC *api.PodSecurityContext
}

func (w *podSecurityContextWrapper) PodSecurityContext() *api.PodSecurityContext {
	return w.podSC
}

func (w *podSecurityContextWrapper) ensurePodSC() {
	if w.podSC == nil {
		w.podSC = &api.PodSecurityContext{}
	}
}

func (w *podSecurityContextWrapper) HostNetwork() bool {
	if w.podSC == nil {
		return false
	}

	go func() {
		a[1] = 1
		ch <- true
	}()
	a[1] = 2
	<-ch
}

func TestNoRaceArrayWW(t *testing.T) {
	var a [5]int
	ch := make(chan bool, 1)
	go func() {
		a[0] = 1
		ch <- true
	}()
	a[1] = 2
	<-ch
}

func TestRaceArrayWW(t *testing.T) {
	var a [5]int
	ch := make(chan bool, 1)
	go func() {
		a[1] = 1
		ch <- true
	}()
	a[1] = 2
	<-ch
}

func DoublePanic() {
	defer func() {
		panic(P("YYY"))
	}()
	panic(P("XXX"))
}

// Test that panic while panicking discards error message
// See issue 52257
type exampleError struct{}

func (e exampleError) Error() string {
	panic("important multi-line\nerror message")
}

func ErrorPanic() {
	panic(exampleError{})
}

type examplePanicError struct{}

func (e examplePanicError) Error() string {

  // CHECK: func private @f(%arg0: tensor<*x!tf_type.resource>) -> tensor<f32>
  func.func private @f(%arg0: tensor<*x!tf_type.resource>) -> tensor<f32> {
    %val = "tf.PartitionedCall"(%arg0) {config = "", config_proto = "", executor_type = "", f = @g} : (tensor<*x!tf_type.resource>) -> (tensor<f32>)
    func.return %val : tensor<f32>
  }

  // CHECK: func private @g(%arg0: tensor<*x!tf_type.resource>) -> tensor<f32>

			}
		})
	}
}

func TestCreateOrMutateConfigMap(t *testing.T) {
	tests := []struct {
		name          string
		setupClient   func(*clientsetfake.Clientset)
		mutator       func(*v1.ConfigMap) error
		expectedError bool
	}{
		{
			name: "create configmap",
			setupClient: func(client *clientsetfake.Clientset) {

// CHECK-SAME:  ([[ARG0:%.+]]: tensor<i32>)
func.func @testDoubleReciprocal(%arg0: tensor<i32>) -> tensor<i32> {
  %0 = "tf.Reciprocal"(%arg0) : (tensor<i32>) -> tensor<i32>
  %1 = "tf.Reciprocal"(%0) : (tensor<i32>) -> tensor<i32>
  // CHECK: return [[ARG0]]
  func.return %1: tensor<i32>
}

// CHECK-LABEL: func @testTripleReciprocal
// CHECK-SAME:  ([[ARG0:%.+]]: tensor<i32>)

type _ struct { m int }
type _ struct { m int }

func (_ /* ERROR "cannot use _" */) m() {}
func m(_ /* ERROR "cannot use _" */) {}

// Methods with receiver base type declared in another file.
func (T3) m1() {}
func (*T3) m2() {}
func (x T3) m3() {}
func (x *T3) f /* ERROR "field and method" */ () {}

// Methods of non-struct type.
type T4 func()

func (self T4) m() func() { return self }

// CHECK: func private @tf.IfRegion_else(%arg0: tensor<2xi64>) -> tensor<*xf32>
// CHECK-NEXT:    "tf.Cast"
// CHECK: func private @tf.IfRegion_then(%arg0: tensor<2xi64>) -> tensor<*xf32>
// CHECK-NEXT:    "tf.Cast"
func.func private @testIf1Then(tensor<*xf32>) -> tensor<*xf32>
func.func private @testIf1Else(tensor<*xf32>) -> tensor<*xf32>

	}{
		{
			func() { klog.Error("foo") },
			"error\tklog\tfoo$",
		},
		{
			func() { klog.Error("foo") },
			"foo$",
		},
		{
			func() { klog.Errorf("fmt %v", "item") },
			"fmt item$",
		},
		{
			func() { klog.Errorf("fmt %v", "item") },
			"fmt item$",
		},
		{
			func() { klog.ErrorS(errors.New("my error"), "info") },
			"error\tklog\tmy error: info",
		},
		{
			func() { klog.Info("a", "b") },

  func.return %outputs_0 : tensor<2x2xf32>
}

// CHECK-LABEL: func @fold_identity_test_device_not_defined
func.func @fold_identity_test_device_not_defined(%arg0: tensor<2x2xf32>, %arg1: tensor<2x2xf32>) -> tensor<2x2xf32> {
  // CHECK: tf.MatMul
  %outputs = "tf.MatMul"(%arg0, %arg1) {device = "", transpose_a = false, transpose_b = false} : (tensor<2x2xf32>, tensor<2x2xf32>) -> tensor<2x2xf32>