func _[X Unsigned, T Unsigned](x X) T { return T(x) }
func _[X Float, T Unsigned](x X) T    { return T(x) }

func _[X Integer, T Float](x X) T  { return T(x) }
func _[X Unsigned, T Float](x X) T { return T(x) }
func _[X Float, T Float](x X) T    { return T(x) }

func _[X, T Integer | Unsigned | Float](x X) T { return T(x) }
func _[X, T Integer | ~string](x X) T {

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 }

    `,
		f: func(t *T) {
			ranSeq := false
			ranPar := false
			t.Run("", func(t *T) {
				t.Run("par", func(t *T) {
					t.Parallel()
					ranPar = true
				})
				t.Run("seq", func(t *T) {
					ranSeq = true
				})
				t.FailNow()
				t.Run("seq", func(t *T) {
					realTest.Error("test must be skipped")
				})
				t.Run("par", func(t *T) {
					t.Parallel()

	}

	x := X[int]{func(v int) error { fmt.Println(v); return nil }}
	x.fn(0)
}

func caller1a(val int) {
	type X struct {
		fn func(float64) error
	}

	x := X{func(v float64) error { fmt.Println(v); return nil }}
	x.fn(float64(3.2))
}

func caller1b(val int) {
	type Y struct {
		fn func(float64) error
	}

	X := Y{func(v float64) error { fmt.Println(v); return nil }}
	X.fn(float64(3.2))
}

			}
		})
	}
}

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: 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>

// test stablehlo roundtrip

// Identity function to make the exporter happy
func.func @main(%arg0: tensor<4xi8>) -> tensor<4xi8> {
  func.return %arg0 : tensor<4xi8>
}

//CHECK:func.func @main(%arg0: tensor<4xi8>) -> tensor<4xi8> attributes {tf.entry_function = {inputs = "arg0", outputs = "arg0"}} {
//CHECK: return %arg0 : tensor<4xi8>
//CHECK:}

func.func @logistic(%arg0: tensor<1x1x1x96xf32>) -> tensor<1x1x1x96xf32> {

func (sb *SymbolBuilder) Type() sym.SymKind      { return sb.kind }
func (sb *SymbolBuilder) Size() int64            { return sb.size }
func (sb *SymbolBuilder) Data() []byte           { return sb.data }
func (sb *SymbolBuilder) Value() int64           { return sb.l.SymValue(sb.symIdx) }
func (sb *SymbolBuilder) Align() int32           { return sb.l.SymAlign(sb.symIdx) }

  func.return %1 : tensor<3xcomplex<f32>>
}

// -----

// CHECK-LABEL: func @imag
func.func @imag(%arg0: tensor<3xcomplex<f32>>) -> tensor<3xf32> {
  // CHECK: mhlo.imag
  %1 = "tf.Imag"(%arg0) : (tensor<3xcomplex<f32>>) -> tensor<3xf32>
  func.return %1 : tensor<3xf32>
}

// -----

// CHECK-LABEL: func @real

  func.func @convert(%arg0: tensor<2xi32>) -> tensor<2xf32> {
    // CHECK: mhlo.convert %arg0 : (tensor<2xi32>) -> tensor<2xf32>
    %0 = "tf.Cast"(%arg0) {Truncate = false} : (tensor<2xi32>) -> tensor<2xf32>
    func.return %0 : tensor<2xf32>
  }

  // CHECK-LABEL: func @constant
  func.func @constant(%arg0: tensor<f32>) -> tensor<f32> {
    // CHECK: %[[ONE:.*]] = mhlo.constant dense<1.000000e+00> : tensor<f32>