return true;
        }
        return false;
    }

    public void addChildUrlRule(final String tagName, final String attrName) {
        if (StringUtil.isNotBlank(tagName) && StringUtil.isNotBlank(attrName)) {
            childUrlRuleMap.put(tagName, attrName);
        }
    }

    protected XPathAPI getXPathAPI() {
        XPathAPI cachedXPathAPI = xpathAPI.get();

        reader.beginObject();
        while (reader.peek() != END_OBJECT) {
            String attrName = reader.nextName();
            if (reader.peek() == BOOLEAN) {
                boolean attrValue = reader.nextBoolean();
                attributes = attributesFactory.concat(attributes, Attribute.of(attrName, Boolean.class), attrValue);
            } else if (reader.peek() == NUMBER) {

            serializer.startTag(NAMESPACE, tagName).text(value).endTag(NAMESPACE, tagName);
        }
    }

    private void writeAttr(String attrName, String value, XmlSerializer serializer) throws IOException {
        if (value != null) {
            serializer.attribute(NAMESPACE, attrName, value);
        }
    }

	must(err)
	rdr := dw.Reader()
	rdr.Seek(0)
	for {
		e, err := rdr.Next()
		must(err)
		if e == nil {
			break
		}
		if e.Tag != dwarf.TagCompileUnit {
			continue
		}
		pkgname, _ := e.Val(dwarf.AttrName).(string)
		if pkgname == "runtime" {
			continue
		}
		if pkgname == "crypto/internal/nistec/fiat" {
			continue // golang.org/issue/49372
		}
		if e.Val(dwarf.AttrStmtList) == nil {
			continue
		}

	SYS_EXTATTR_SET_FILE       = 356 // { int extattr_set_file(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes); }
	SYS_EXTATTR_GET_FILE       = 357 // { int extattr_get_file(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes); }

            Stream.of(attrUidNumber, attrGidNumber)
                    .forEach(attrName -> OptionalUtil.ofNullable(attributes.get(attrName)).filter(StringUtil::isNotBlank).ifPresent(s -> {
                        try {
                            DfTypeUtil.toLong(s);
                        } catch (final NumberFormatException e) {
                            consumer.accept(attrName);
                        }
                    }));
        } else {

            writeLocationTracking(locationTracker, tagName, serializer);
#end
        }
    }

    private void writeAttr(String attrName, String value, XMLStreamWriter serializer) throws IOException, XMLStreamException {
        if (value != null) {
            serializer.writeAttribute(attrName, value);
        }
    }
#if ( $locationTracking )

    /**
     * Method writeLocationTracking.
     *

    llvm::SmallVector<std::string, 4> attr_names(undefined_attrs.size());
    std::transform(undefined_attrs.begin(), undefined_attrs.end(),
                   attr_names.begin(),
                   [](StringAttr attr) { return attr.getValue().str(); });
    func.emitError(llvm::Twine("Undefined attributes are used: ",
                               llvm::join(attr_names, ",")));
    return failure();
  }

		ex.dies = append(ex.dies, entry)
		if _, found := ex.idxByOffset[entry.Offset]; found {
			return errors.New("DIE clash on offset")
		}
		ex.idxByOffset[entry.Offset] = idx
		if name, ok := entry.Val(dwarf.AttrName).(string); ok {
			ex.byname[name] = append(ex.byname[name], idx)
		}
		if len(nesting) > 0 {
			parent := nesting[len(nesting)-1]
			ex.kids[parent] = append(ex.kids[parent], idx)
			ex.parent[idx] = parent
		}

				// validate attribute(NFACCT_NAME)
				assert.Equal(t, 1, len(tc.handler.requests[0].data))
				assert.Equal(t,
					tc.handler.requests[0].data[0].Serialize(),
					nl.NewRtAttr(attrName, nl.ZeroTerminated(tc.counterName)).Serialize(),
				)
			}
		})
	}
}
func TestRunner_Get(t *testing.T) {
	testCases := []struct {
		name         string
		counterName  string