if typstr != want && (kind != "macho" || typstr != machoBug[want]) {
					t.Errorf("%s:\n\thave %s\n\twant %s", t1.Name, typstr, want)
				}
			}
		}
		if e.Tag != TagCompileUnit {
			r.SkipChildren()
		}
	}

	for k := range testcases {
		if !seen[k] {
			t.Errorf("missing %s", k)
		}
	}
}

func TestTypedefCycle(t *testing.T) {

			r.cu = e
		}
	} else {
		r.lastChildren = false
	}
	return e, nil
}

// SkipChildren skips over the child entries associated with
// the last [Entry] returned by [Reader.Next]. If that [Entry] did not have
// children or [Reader.Next] has not been called, SkipChildren is a no-op.
func (r *Reader) SkipChildren() {
	if r.err != nil || !r.lastChildren {
		return
	}

				}
				if strings.Contains(lne.File.Name, `\`) {
					t.Errorf("filename should not contain backslash: %v", lne.File.Name)
				}
			}
		}
		rdr.SkipChildren()
	}
}

func TestIssue38192(t *testing.T) {
	testenv.MustHaveGoBuild(t)

	mustHaveDWARF(t)

	t.Parallel()

	// Build a test program that contains a translation unit whose

	dr := d.Reader()
	for {
		ent, err := dr.Next()
		if err != nil {
			t.Fatal("dr.Next:", err)
		} else if ent == nil {
			break
		}

		if ent.Tag != TagCompileUnit {
			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)

						units[method] = append(units[method], ent.Val(AttrName))
					}
					if method == 0 {
						if ent.Tag != TagCompileUnit {
							t.Fatalf("found unexpected tag %v on top level", ent.Tag)
						}
						r.SkipChildren()
					}
				}
			}
			t.Logf("skipping CUs:     %v", units[0])
			t.Logf("not-skipping CUs: %v", units[1])
			if !reflect.DeepEqual(units[0], units[1]) {
				t.Fatal("set of CUs differ")
			}
		})

			if err != nil {
				fatalf("malformed __cgo__ name: %s", name)
			}
			types[i] = t.Type
			p.recordTypedefs(t.Type, f.NamePos[names[i]])
		}
		if e.Tag != dwarf.TagCompileUnit {
			r.SkipChildren()
		}
	}

	// Record types and typedef information.
	for i, n := range names {
		if strings.HasSuffix(n.Go, "GetTypeID") && types[i].String() == "func() CFTypeID" {

		{"(*Reader).AddressSize", Method, 5},
		{"(*Reader).ByteOrder", Method, 14},
		{"(*Reader).Next", Method, 0},
		{"(*Reader).Seek", Method, 0},
		{"(*Reader).SeekPC", Method, 7},
		{"(*Reader).SkipChildren", Method, 0},
		{"(*StructType).Common", Method, 0},
		{"(*StructType).Defn", Method, 0},
		{"(*StructType).Size", Method, 0},
		{"(*StructType).String", Method, 0},
		{"(*TypedefType).Common", Method, 0},

pkg debug/dwarf, method (*QualType) String() string
pkg debug/dwarf, method (*Reader) Next() (*Entry, error)
pkg debug/dwarf, method (*Reader) Seek(Offset)
pkg debug/dwarf, method (*Reader) SkipChildren()
pkg debug/dwarf, method (*StructType) Common() *CommonType
pkg debug/dwarf, method (*StructType) Defn() string
pkg debug/dwarf, method (*StructType) Size() int64
pkg debug/dwarf, method (*StructType) String() string