}

// CHECK: func private @[[CLUSTER]]
// CHECK-SAME: (%[[CLUSTER_ARG_0:[a-z0-9]*]]: tensor<?xi32>) -> tensor<?xi32>
// CHECK: %[[B_OUTPUT:[0-9]*]] = "tf.B"(%[[CLUSTER_ARG_0]])
// CHECK: return %[[B_OUTPUT]]

// -----

// Tests that multiple `tf_device.cluster` that depend on each other are
// correctly handled.

// CHECK-LABEL: func @multiple_clusters
// CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<?xi32>)

    key: "dtype"
    value {
      type: DT_INT32
    }
  }
}
versions {
  producer: 27
}

# CHECK-LABEL: func @main
# CHECK-SAME:  (%[[ARG_0:[a-z0-9]+]]: tensor<8xi32>) -> tensor<8xi32>
# CHECK-SAME:  control_outputs = ""
# CHECK-SAME:  inputs = "input"
# CHECK-SAME:  outputs = "input"
# CHECK:         %[[GRAPH:[0-9]+]] = tf_executor.graph
# CHECK:           tf_executor.fetch %[[ARG_0]]

// PerTensor-SAME: f = @quantized_conv2d_fn_1}> : (tensor<1x2x2x3xf32>, tensor<2x3x3x2xi8>, tensor<f32>, tensor<i32>) -> tensor<*xf32>
// PerTensor: %[[out_2:.*]] = "tf.PartitionedCall"(%arg0, %[[q_w]], %[[scale]], %[[zp]]) <{config = "", config_proto = "", executor_type = "",

  func.return %1 : tensor<4x128x1xf32>
  // CHECK-NEXT: %[[CONST_WEIGHT:.*]] = arith.constant
  // CHECK-SAME: [1.000000e+00, 2.000000e+00]
  // CHECK-SAME: tensor<1x2xf32>
  // CHECK: %[[FC_RES:.*]] = "tfl.fully_connected"(%arg0, %[[CONST_WEIGHT]]
  // CHECK-SAME: <{fused_activation_function = "NONE", keep_num_dims = true, weights_format = "DEFAULT"}> : (tensor<4x128x2xf32>, tensor<1x2xf32>, none) -> tensor<4x128x1xf32>

		if hash1 != hash2 {
			t.Fatalf("hash of the same object (%q) produced different results: %d vs %d", toString(tc()), hash1, hash2)
		}
		for i := 0; i < 100; i++ {
			hasher2 := adler32.New()

			DeepHashObject(hasher1, tc())
			hash1a := hasher1.Sum32()
			DeepHashObject(hasher2, tc())
			hash2a := hasher2.Sum32()

			if hash1a != hash1 {

// CHECK-LABEL: func @resource
func.func @resource() {
  // CHECK: tf.SomeOp
  // CHECK-SAME: dtype = !corert.resource
  "tf.SomeOp"() {device = "/device:CPU:0", dtype = !tf_type.resource} : () -> ()
  func.return
}

// CHECK-LABEL: func @variant
func.func @variant(%arg: tensor<!tf_type.variant>) {
  // CHECK: tf.ZerosLike
  // CHECK-SAME: T = !corert.variant

    key: "index"
    value {
      i: 0
    }
  }
}
versions {
  producer: 27
}

# CHECK-LABEL: func @main
# CHECK-SAME:  (%[[ARG_0:[a-z0-9]+]]: tensor<8xi32> loc({{.*}})) -> tensor<8xi32>
# CHECK-SAME:  control_outputs = ""
# CHECK-SAME:  inputs = "arg"
# CHECK-SAME:  outputs = "arg"
# CHECK:         %[[GRAPH:[0-9]+]] = tf_executor.graph
# CHECK:           tf_executor.fetch %[[ARG_0]]

    key: "index"
    value {
      i: 0
    }
  }
}
versions {
  producer: 27
}

# CHECK:      func @main(%[[ARG_0:[a-z0-9]+]]: tensor<*xi32>) -> tensor<*xi32>
# CHECK-SAME: control_outputs = ""
# CHECK-SAME: inputs = "arg"
# CHECK-SAME: outputs = "ret"
# CHECK:        %[[GRAPH:[0-9]+]] = tf_executor.graph
# CHECK:          tf_executor.fetch %[[ARG_0]]

module attributes {tf.versions = {producer = 888 : i32}} {
// CHECK-LABEL: func @while_main
// CHECK: %0 = "tf.While"(%arg0)
// CHECK-SAME: body = @while_body
// CHECK-SAME: cond = @while_cond
// CHECK: "tf.While"(%arg1)
// CHECK-SAME: body = @while_body_0
// CHECK-SAME: cond = @while_cond_1

// CHECK: func @while_body(%arg0: tensor<256x256xi32>)
// CHECK: func @while_cond(%arg0: tensor<256x256xi32>)

        then:
        dep.is(same)
        !dep.is(differentFrom)
        !dep.is(differentRequested)
        !dep.is(differentConstraint)
        dep.is(differentFailure) //the same dependency edge cannot have different failures
    }

    def selector(String group = 'a', String module = 'a', String version = '1') {