op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "while/Enter"
  op: "Enter"
  input: "Const"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.entity;

/**
 * @author shinsuke
 *
 */
public interface UrlQueue<IDTYPE> {

    IDTYPE getId();

    void setId(IDTYPE id);

    String getSessionId();

    void setSessionId(String sessionId);

    String getMethod();

    void setMethod(String method);

    String getUrl();

  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  experimental_debug_info {
  }
}
library {
  function {
    signature {
      name: "cond"
      input_arg {
        name: "cond"
        type: DT_INT32
      }
      input_arg {
        name: "cond1"
        type: DT_FLOAT
      }
      output_arg {
        name: "cond2"
        type: DT_BOOL
      }

  // a `dtype` to be added on the NodeDef. We verify that we correctly use the
  // DerivedAttr to populate the NodeDef.
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   type: DT_FLOAT
  // CHECK:   float_val: 2
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   type: DT_FLOAT
  // CHECK:   float_val: 3
  // CHECK:      key: "dtype"

LogicalResult ConstantFoldMul(mhlo::MulOp op, PatternRewriter &rewriter) {
  ShapedType type = mlir::dyn_cast<ShapedType>(op.getType());
  Type etype = type.getElementType();
  Attribute result = {};
  if (mlir::isa<FloatType>(etype)) {
    result =
        BinaryFolder<mhlo::MulOp, FloatType, APFloat, std::multiplies<APFloat>>(
            &op);
  } else if (mlir::isa<IntegerType>(etype)) {
    result =

// CHECK-NEXT:   op: "Const"
// 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 {
// CHECK-NEXT:         }

                      const char* name, const char* raw_device_name) {
  AbstractOperationPtr op_ptr(ctx->CreateOperation());
  TF_RETURN_IF_ERROR(op_ptr->Reset("ReadVariableOp", raw_device_name));
  TF_RETURN_IF_ERROR(MaybeSetOpName(op_ptr.get(), name));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(resource));
  TF_RETURN_IF_ERROR(op_ptr->SetAttrType("dtype", dtype));
  int num_retvals = 1;

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"

  input: "arg1"
  input: "var1_add/value"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "var2_add/value"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 8.0

                     TensorShape shape) {
  EXPECT_TRUE(n->IsConstant());
  Tensor tensor;
  TF_EXPECT_OK(GetNodeAttr(n->attrs(), "value", &tensor));
  DataType dtype;
  TF_EXPECT_OK(GetNodeAttr(n->attrs(), "dtype", &dtype));
  EXPECT_EQ(tensor.dtype(), dtype);
  test::ExpectTensorEqual<T>(tensor, test::AsTensor(values, shape));
}

void ExpectTypeAndShape(const Node* n, DataType expected_dtype,