def.add_input("input1");
  def.add_input("input2");
  def.add_input("input3");
  def.add_input("input3");
  def.add_input("input3");

  AttrValue v0;
  v0.set_type(DataType::DT_INT32);
  v0.set_i(3);
  (*def.mutable_attr())["NumInput3"] = v0;
  AttrValue v1;
  v1.set_type(DataType::DT_FLOAT);
  (*def.mutable_attr())["SomeDataTypeAttr"] = v1;

  tensorflow::AttrValueMap attr_values = ExtractAttrs(minOp);
  tensorflow::AttrValueMap::const_iterator attr_found = attr_values.find("T");
  EXPECT_NE(attr_found, attr_values.cend());
  EXPECT_EQ(attr_found->second.type(), tensorflow::DataType::DT_FLOAT);
  attr_found = attr_values.find("Tidx");
  EXPECT_NE(attr_found, attr_values.cend());

        break;
      }
      case ::tensorflow::AttrValue::kI:
        flex_builder->Int(key, attr.i());
        break;
      case ::tensorflow::AttrValue::kF:
        flex_builder->Float(key, attr.f());
        break;
      case ::tensorflow::AttrValue::kB:
        flex_builder->Bool(key, attr.b());
        break;
      case tensorflow::AttrValue::kList:
        if (attr.list().s_size() > 0) {

      %out_c, %out_tensor = "tfd.delegate_kernel"(
        %in_c, %in1_tensor, %in2_tensor) {
        _name = "MatMul",
        attr1_name = "transpose_a", attr1_value = "bool$false",
        attr2_name = "transpose_b", attr2_value = "bool$false"
      } : (!tfrt.chain, !tfd.tf_tensor, !tfd.tf_tensor) -> (
        !tfrt.chain, !tfd.tf_tensor)
  }];

  let arguments = (ins TFRT_ChainType, Variadic<AnyType>);

        String tag = "tag", id = "id", css = "css", attrName = "attrName", attrValue = "attrValue";
        PrunedTag prunedtag = new PrunedTag(tag);
        prunedtag.setAttr(attrName, attrValue);
        prunedtag.setId(id);
        prunedtag.setCss(css);
        assertEquals("PrunedTag [tag=" + tag + ", id=" + id + ", css=" + css + ", attrName=" + attrName + ", attrValue=" + attrValue + "]",
                prunedtag.toString());
    }

        else strides
    )
    strides_attr = attr_value_pb2.AttrValue(
        list=attr_value_pb2.AttrValue.ListValue(i=strides_to_check)
    )

    if enable_per_channel_quantization:
      quantized_axis_attr = attr_value_pb2.AttrValue(i=3)
      quantized_dim_size_attr = attr_value_pb2.AttrValue(
          list=attr_value_pb2.AttrValue.ListValue(
              shape=[

                && StringUtils.compare(attrValue, other.attrValue) == 0;
    }

    public void setId(final String id) {
        this.id = id;
    }

    public void setCss(final String css) {
        this.css = css;
    }

    public void setAttr(final String name, final String value) {
        this.attrName = name;
        this.attrValue = value;
    }

    @Override

			break
		}
		e, ok := t.(xml.StartElement)
		if !ok || !strings.EqualFold(e.Name.Local, "meta") {
			continue
		}
		if attrValue(e.Attr, "name") != "go-import" {
			continue
		}
		if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 {
			imports = append(imports, metaImport{
				Prefix:   f[0],
				VCS:      f[1],
				RepoRoot: f[2],
			})
		}
	}

                    String attrValue = attrNode.getNodeValue();
                    if (StringUtil.isNotBlank(attrValue)) {
                        // if starting with www, append a protocol
                        if (attrValue.startsWith("www.")) {
                            attrValue = "http://" + attrValue;
                        }
                        return attrValue;
                    }
                }

            scanner.next();
            StringBuilder attrValue = new StringBuilder();
            while (!scanner.isEmpty() && !scanner.lookingAt(quote)) {
                if (scanner.lookingAt(HTML_ENCODED_CHAR)) {
                    parseHtmlEncodedChar(attrValue);
                } else if (scanner.lookingAt(HTML_ENTITY)) {
                    parseHtmlEntity(attrValue);
                } else {