"//tensorflow/c:tf_datatype",
        "//tensorflow/cc/experimental/base/public:status",
        "//tensorflow/cc/experimental/base/public:tensor",
        "//tensorflow/core:lib",
        "//tensorflow/core:test",
        "//tensorflow/core:test_main",
    ],
)

tf_cc_test(
    name = "tensorhandle_test",
    srcs = [
        "tensorhandle_test.cc",
    ],
    deps = [
        ":tensor_types_test_util",

func.func @test(%ch: !tfrt.chain, %arg0: !corert.tensorhandle, %arg1_th: !corert.tensorhandle) {
  %cpu = corert.get_op_handler %ch "cpu"
  %0 = corert.executeop(%cpu) "tf.Relu"(%arg0) { T = f32 } : 1
  %arg1 = tfrt_fallback_async.corert_tensorhandle_to_fallback_tensor %arg1_th {_tfrt_cost = 1 : i64, device = "/CPU:0"} : (!corert.tensorhandle) -> (!tfrt_fallback.tf_tensor)
  %1 = tfrt_fallback_async.executeop key(0) cost(100) device("/CPU:0") "tf.Relu"(%arg1) { T = f32 } : 1

			pools:          pools,
			name:           "Correct",
			expectedErr:    false,
			expectedUpdate: false,
		},
		{
			meta:           meta,
			pools:          newPools,
			name:           "Correct-Update",
			expectedErr:    false,
			expectedUpdate: true,
		},
		{
			meta:           meta,
			pools:          reducedPools,
			name:           "Correct-Update",
			expectedErr:    false,

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

	listTypeResourceSchema = `
type: object
properties:
  correct-map:
    type: array
    x-kubernetes-list-type: map
    x-kubernetes-list-map-keys: ["a", "b"]
    items:
      type: object
      required: ["a", "b"]
      properties:
        a:
          type: integer
        b:
          type: integer
  correct-set:
    type: array
    x-kubernetes-list-type: set
    items:

    ],
)

tf_cc_test(
    name = "save_test",
    size = "small",
    srcs = ["save_test.cc"],
    deps = [
        ":save",
        "//tensorflow/core:lib",
        "//tensorflow/core:test",
        "//tensorflow/core:test_main",
        "//tensorflow/core/platform:path",
    ],
)

cc_library(
    name = "load",
    srcs = ["load.cc"],
    hdrs = ["load.h"],
    deps = [

std::unique_ptr<tfrt::CoreRuntime> CreateTestCoreRuntime() {
  auto corert = tfrt::CoreRuntime::Create(
      /*diag_handler=*/[](const tfrt::DecodedDiagnostic&
                              diag) { LOG(ERROR) << diag.message(); },
      tfrt::CreateMallocAllocator(),
      tfrt::CreateMultiThreadedWorkQueue(16, 16));
  CHECK(corert);
  auto fallback_op_handler = tensorflow::tfd::CreateKernelFallbackOpHandler(

                @TaskAction
                def verify() {
                    assert incomingFiles*.name == ["correct"]
                }
            }
        """
    }

    def "resolve the correct files through artifactView"() {
        expect:
        succeeds ':verifyFiles'
    }

    size = "small",
    srcs = ["ram_file_block_cache_test.cc"],
    deps = [
        ":ram_file_block_cache",
        "//tensorflow/c:tf_status_internal",
        "//tensorflow/core:lib",
        "//tensorflow/core:test",
        "//tensorflow/core:test_main",
        "//tensorflow/core/platform:blocking_counter",
        "//tensorflow/core/platform/cloud:now_seconds_env",
    ],
)

tf_cc_test(
    name = "gcs_filesystem_test",

		// interfaces and implementations are mutually exclusive,
		// devirtualization can still select the correct callee for
		// each.
		//
		// If they were not mutually exclusive (for example, two Add
		// calls), then we could not definitively select the correct
		// callee.
		val += m.Multiply(42, selectA(i).Add(one(i), 2))
	}
	return val
}

type AddFunc func(int, int) int