continue
		}
		ap, err := f.COFFSymbolReadSectionDefAux(k)
		if tp.ok {
			if err != nil {
				t.Errorf("unexpected failure on %d, got error %v", k, err)
				continue
			}
			got := fmt.Sprintf("%+v", *ap)
			if got != tp.auxstr {
				t.Errorf("COFFSymbolReadSectionDefAux on %d bad return, got:\n%s\nwant:\n%s\n", k, got, tp.auxstr)
				continue
			}
		} else {
			if err == nil {

	withAndWithoutRunner(func(setGoCoverDir bool, tag string) {
		tp := "emitToWriter"
		rdir, edir := mktestdirs(t, tag, tp, dir)
		output, err := runHarness(t, harnessPath, tp, setGoCoverDir, rdir, edir)
		if err != nil {
			t.Logf("%s", output)
			t.Fatalf("running 'harness -tp %s': %v", tp, err)
		}
		want := []string{"main", tp}
		avoid := []string{"final"}

}

func ensureNoTags(gvk schema.GroupVersionKind, tp reflect.Type, parents []reflect.Type, typesAllowedTags map[reflect.Type]bool) []error {
	errs := []error{}
	if _, ok := typesAllowedTags[tp]; ok {
		return errs
	}

	// Don't look at the same type multiple times
	if containsType(parents, tp) {
		return nil
	}
	parents = append(parents, tp)

	switch tp.Kind() {
	case reflect.Map, reflect.Slice, reflect.Pointer:

	once sync.Once
	tmpl *template.Template
}

func (r *Template) tp() *template.Template {
	r.once.Do(r.build)
	return r.tmpl
}

func (r *Template) build() {
	r.tmpl = template.Must(template.New(r.name).Parse(r.text))
	r.name, r.text = "", ""
}

func (r *Template) Execute(w io.Writer, data any) error {
	return r.tp().Execute(w, data)
}

	cleanup      func()
	blockChannel chan any
}

func (tp TestProxy) Run(stop <-chan error) error {
	if tp.run == nil {
		return nil
	}
	return tp.run(stop)
}

func (tp TestProxy) Drain(bool) error {
	tp.blockChannel <- "unblock"
	return nil
}

func (tp TestProxy) Cleanup() {
	if tp.cleanup != nil {
		tp.cleanup()
	}
}

func (tp TestProxy) UpdateConfig(_ []byte) error {
	return nil
}

func netpoll(delay int64) (gList, int32) {
	if kq == -1 {
		return gList{}, 0
	}
	var tp *timespec
	var ts timespec
	if delay < 0 {
		tp = nil
	} else if delay == 0 {
		tp = &ts
	} else {
		ts.setNsec(delay)
		if ts.tv_sec > 1e6 {
			// Darwin returns EINVAL if the sleep time is too long.
			ts.tv_sec = 1e6
		}
		tp = &ts
	}
	var events [64]keventt
retry:

		tp.addr = tp.elem + alignDown(n-(tp.elem-oldelem), ptrBits*goarch.PtrSize)
	} else {
		tp.addr += alignDown(n, ptrBits*goarch.PtrSize)
	}

	if tp.addr-tp.elem >= tp.typ.PtrBytes {
		// We're starting in the non-pointer area of an array.
		// Move up to the next element.
		tp.elem += tp.typ.Size_
		tp.addr = tp.elem
		tp.mask = readUintptr(tp.typ.GCData)

	return taggedPointer(uintptr(ptr))<<32 | taggedPointer(tag)
}

// Pointer returns the pointer from a taggedPointer.
func (tp taggedPointer) pointer() unsafe.Pointer {
	return unsafe.Pointer(uintptr(tp >> 32))
}

// Tag returns the tag from a taggedPointer.
func (tp taggedPointer) tag() uintptr {
	return uintptr(tp)

        return doSelectEntity(xprepareCBAsPK(id), tp);
    }

    protected ThumbnailQueueCB xprepareCBAsPK(String id) {
        assertObjectNotNull("id", id);
        return newConditionBean().acceptPK(id);
    }

    protected <ENTITY extends ThumbnailQueue> OptionalEntity<ENTITY> doSelectOptionalByPK(String id, Class<? extends ENTITY> tp) {

        return doSelectEntity(xprepareCBAsPK(id), tp);
    }

    protected CrawlingInfoCB xprepareCBAsPK(String id) {
        assertObjectNotNull("id", id);
        return newConditionBean().acceptPK(id);
    }

    protected <ENTITY extends CrawlingInfo> OptionalEntity<ENTITY> doSelectOptionalByPK(String id, Class<? extends ENTITY> tp) {