if (op.name() == "SomeOp") {
      ASSERT_EQ(2, op.input_arg_size());
      ASSERT_EQ("input1", op.input_arg(0).name());
      ASSERT_EQ(::tensorflow::DT_UINT8, op.input_arg(0).type());
      ASSERT_EQ(1, op.attr_size());
      ASSERT_EQ("string", op.attr(0).type());
      found = true;
    }
  }
  EXPECT_TRUE(found);
  TF_DeleteStatus(status);
  TF_DeleteBuffer(op_list_buffer);
}

}

bool HasOptionalAttrs(
    const ApiDef& api_def,
    const std::unordered_map<string, string>& inferred_input_attrs) {
  for (int i = 0; i < api_def.attr_size(); ++i) {
    const auto& attr(api_def.attr(i));
    if ((inferred_input_attrs.find(attr.name()) ==
         inferred_input_attrs.end()) &&
        attr.has_default_value()) {
      return true;
    }
  }

    }
  }
  // Add the static functions to set optional attrs
  if (op_info.has_optional_attrs) {
    strings::StrAppend(&class_decl, "\n");
    for (int i = 0; i < op_info.graph_op_def.attr_size(); ++i) {
      const auto& attr(op_info.graph_op_def.attr(i));
      const auto& api_def_attr(op_info.api_def.attr(i));
      if ((op_info.inferred_input_attrs.find(attr.name()) !=

      "list(type)",   "func",         "float",      "bool",
      "tensor",       "list(string)", "list(bool)", "list(shape)",
      "list(tensor)", "list(attr)"};
  for (int i = 0; i < op_info.graph_op_def.attr_size(); ++i) {
    const auto& attr(op_info.graph_op_def.attr(i));
    const auto& api_def_attr(op_info.api_def.attr(i));
    // Skip inferred arguments
    if (op_info.inferred_input_attrs.count(attr.name()) > 0) continue;

    EXPECT_EQ(node_def.op(), "TestKernelAttrGetNodeDef");
    EXPECT_EQ(node_def.name(), "FakeNode");
    EXPECT_EQ(node_def.device(), "FakeDevice");
    EXPECT_EQ(node_def.attr_size(), 1);
    const ::tensorflow::AttrValue& value = node_def.attr().at("Attr");
    EXPECT_TRUE(value.value_case() == ::tensorflow::AttrValue::ValueCase::kI);
    EXPECT_EQ(value.i(), 1234);
    TF_DeleteBuffer(node_def_buf);

        absl::InlinedVector<mlir::Attribute, 8> attrs;
        for (const auto& item : value.list().func()) {
          TF_ASSIGN_OR_RETURN(auto attr, ConvertFunctionCallName(item.name()));
          if (item.attr_size() != 0)
            return errors::Unimplemented(
                "func attributes with non-zero attr.size()");
          if (attr) attrs.push_back(attr);
        }
        return builder_.getArrayAttr(

      LIST_CASE(tensor, TF_ATTR_FUNC);
#undef LIST_CASE
      // All lists empty, determine the type from the OpDef.
      if (metadata.list_size == 0) {
        for (int i = 0; i < oper->node.op_def().attr_size(); ++i) {
          const auto& a = oper->node.op_def().attr(i);
          if (a.name() != attr_name) continue;
          const string& typestr = a.type();
          if (typestr == "list(string)") {

		return -1, -1, -1
	}
	var namebuf [1024]byte
	sz := int32(copy(namebuf[:], path))
	A2e(namebuf[:sz])
	attr_sz := uint32(unsafe.Sizeof(*attr))
	var parms [7]unsafe.Pointer
	parms[0] = unsafe.Pointer(&sz)
	parms[1] = unsafe.Pointer(&namebuf[0])
	parms[2] = unsafe.Pointer(&attr_sz)
	parms[3] = unsafe.Pointer(attr)
	parms[4] = unsafe.Pointer(&rv)
	parms[5] = unsafe.Pointer(&rc)
	parms[6] = unsafe.Pointer(&rn)