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.
     *

		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

	seen := make(map[string]bool)
	for {
		e, err := r.Next()
		if err != nil {
			t.Fatal("r.Next:", err)
		}
		if e == nil {
			break
		}
		if e.Tag == TagVariable {
			vname, _ := e.Val(AttrName).(string)
			tAttr := e.Val(AttrType)
			typOff, ok := tAttr.(Offset)
			if !ok {
				t.Errorf("variable at offset %v has no type", e.Offset)
				continue
			}
			typ, err := d.Type(typOff)

			if entry.Tag != TagSubprogram {
				continue
			}

			if i > len(subprograms) {
				t.Fatalf("%s: too many subprograms (expected at most %d)", test.filename, i)
			}

			if got := entry.Val(AttrName).(string); got != subprograms[i].name {
				t.Errorf("%s: subprogram %d name is %s, expected %s", test.filename, i, got, subprograms[i].name)
			}
			ranges, err := d.Ranges(entry)
			if err != nil {

//go:generate stringer -type Attr -trimprefix=Attr

// An Attr identifies the attribute type in a DWARF [Entry.Field].
type Attr uint32

const (
	AttrSibling        Attr = 0x01
	AttrLocation       Attr = 0x02
	AttrName           Attr = 0x03
	AttrOrdering       Attr = 0x09
	AttrByteSize       Attr = 0x0B
	AttrBitOffset      Attr = 0x0C
	AttrBitSize        Attr = 0x0D
	AttrStmtList       Attr = 0x10
	AttrLowpc          Attr = 0x11

				return nil
			}
			for _, pcs := range ranges {
				if pcs[0] <= addr && addr < pcs[1] {
					var ok bool
					// TODO: AT_linkage_name, AT_MIPS_linkage_name.
					name, ok = entry.Val(dwarf.AttrName).(string)
					if ok {
						break FindName
					}
				}
			}
		}
	}

	// TODO: Report inlined functions.

	frames := []driver.Frame{
		{
			Func: name,

			dr.SkipChildren()
			continue
		}

		// Ignore system compilation units (this happens in
		// the Windows binary). We'll still decode the line
		// table, but won't check it.
		name := ent.Val(AttrName).(string)
		ignore := strings.HasPrefix(name, "C:/crossdev/") || strings.HasPrefix(name, "../../")

		// Decode CU's line table.
		lr, err := d.LineReader(ent)
		if err != nil {
			t.Fatal("d.LineReader:", err)