EXPECT_EQ(dltensor_out->device.device_id, dltensor_in->device.device_id);
  EXPECT_EQ(dltensor_out->ndim, dltensor_in->ndim);
  EXPECT_EQ(dltensor_out->dtype.code, dltensor_in->dtype.code);
  EXPECT_EQ(dltensor_out->dtype.bits, dltensor_in->dtype.bits);
  EXPECT_EQ(dltensor_out->dtype.lanes, dltensor_in->dtype.lanes);
  for (int i = 0; i < dltensor_in->ndim; ++i) {
    EXPECT_EQ(dltensor_out->shape[i], dltensor_in->shape[i]);
    if (dltensor_out->strides) {

        auto operand_or_result = value_shaped_type.getElementType();
        std::string dtype;

        TypeSwitch<Type>(operand_or_result)
            .Case<IntegerType>([&](Type) {
              dtype =
                  absl::StrCat("i", operand_or_result.getIntOrFloatBitWidth());
            })
            .Case<FloatType>([&](Type) {
              dtype =
                  absl::StrCat("f", operand_or_result.getIntOrFloatBitWidth());

// CHECK-NEXT:       attr {
// CHECK:              key: "dtype"
// CHECK-NEXT:         value {
// CHECK-NEXT:           type: DT_INT32
// CHECK-NEXT:         }
// CHECK-NEXT:       }
// CHECK-NEXT:       attr {
// CHECK-NEXT:         key: "value"
// CHECK-NEXT:         value {
// CHECK-NEXT:           tensor {
// CHECK-NEXT:             dtype: DT_INT32
// CHECK-NEXT:             tensor_shape {

    %0:2 = tf_executor.island wraps "tf.Const"() {dtype = "tfdtype$DT_INT32", value = dense<0> : tensor<i32>} : () -> (tensor<i32>) loc("foo")
    // CHECK: name: "foo{{_.*_1}}"
    %1:2 = tf_executor.island wraps "tf.Const"() {dtype = "tfdtype$DT_INT32", value = dense<1> : tensor<i32>} : () -> (tensor<i32>) loc("foo")
    // CHECK: name: "foo1"

  switch (dtype) {
#define CASE(type)                                       \
  case DataTypeToEnum<type>::value: {                    \
    type* typed_a = static_cast<type*>(a);               \
    type* typed_b = static_cast<type*>(b);               \
    for (int64_t i = 0; i < num_elements; ++i) {         \
      if (DataTypeIsFloating(dtype)) {                   \
        EXPECT_FLOAT_EQ(static_cast<float>(typed_a[i]),  \

#include "tsl/platform/statusor.h"

namespace tensorflow {

static size_t GetTensorSize(const TensorShape& shape, const DataType dtype) {
  return shape.num_elements() * DataTypeSize(dtype);
}

absl::StatusOr<Tensor> MakeTensorFromPjRtBuffer(
    const DataType dtype, const TensorShape& shape,
    std::unique_ptr<xla::PjRtBuffer> pjrt_buffer) {
  TF_ASSIGN_OR_RETURN(std::unique_ptr<xla::PjRtBuffer::ExternalReference> ref,

}

// Arbitrarily calculate the size of const of type whose size is unkown or
// varying. Each element of such a type is considered to have
// `kAssumedNumBytesPerElem` bytes.
int64_t GetSizeOfUnsupportedTypeConst(TF::ConstOp const_op) {
  return kAssumedNumBytesPerElem * const_op.getValue().getNumElements();
}

}  // namespace

int64_t GetSizeInBytes(TF::ConstOp const_op) {
  const Type dtype = const_op.getDtype();

        else -> error("unexpected type")
    }


internal
fun checkInScope(
    type: KType,
    typeScope: DataSchemaBuilder.PreIndex
) {
    if (type.classifier?.isInScope(typeScope) != true) {
        error("type $type used in a function is not in schema scope")
    }
}


private

     * @param str
     *            文字列。{@literal null}であってはいけません
     * @param ctype
     *            文字のタイプの配列。{@literal null}や空配列であってはいけません
     */
    public Tokenizer(final String str, final byte[] ctype) {
        assertArgumentNotNull("str", str);
        assertArgumentNotEmpty("ctype", ctype);

        this.str = str;
        this.ctype = ctype;
    }

    /**
     * @param ctype2
     *            文字のタイプの配列

node {
  name: "Constant"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "_tf.foo"
  op: "foo"