_SIGEV_THREAD_ID = 0x4
)

//struct Sigset {
//	uint64	sig[1];
//};
//typedef uint64 Sigset;

type timespec struct {
	tv_sec  int64
	tv_nsec int64
}

//go:nosplit
func (ts *timespec) setNsec(ns int64) {
	ts.tv_sec = ns / 1e9
	ts.tv_nsec = ns % 1e9
}

type timeval struct {
	tv_sec  int64
	tv_usec int64
}

func (tv *timeval) set_usec(x int32) {
	tv.tv_usec = int64(x)
}

        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());
    }

    public void test_parse() {

	}
}

func TestSetBase(t *testing.T) {
	var tab PosTable
	b1 := NewFileBase("b1", "b1")
	orig := MakePos(b1, 42, 7)
	xpos := tab.XPos(orig)

	pos := tab.Pos(xpos)
	new := NewInliningBase(b1, 2)
	pos.SetBase(new)
	xpos = tab.XPos(pos)

	pos = tab.Pos(xpos)
	if inl := pos.Base().InliningIndex(); inl != 2 {
		t.Fatalf("wrong inlining index: %d", inl)
	}

// AMD64 does not have link register, so this returns 0.
func (c *context) lr() uintptr      { return 0 }
func (c *context) set_lr(x uintptr) {}

func (c *context) set_ip(x uintptr) { c.rip = uint64(x) }
func (c *context) set_sp(x uintptr) { c.rsp = uint64(x) }
func (c *context) set_fp(x uintptr) { c.rbp = uint64(x) }

func prepareContextForSigResume(c *context) {
	c.r8 = c.rsp
	c.r9 = c.rip
}

func dumpregs(r *context) {

        /**
         * @return String
         */
        public String getEee() {
            return null;
        }

        /**
         * @param eee
         */
        public void setEee(final String eee) {
        }

        /**
         * @return int
         */
        public int getFff() {
            return fff_;
        }

        /**
         * @param fff

both these failures must be very small. A check that is too noisy will be ignored
by the programmer overwhelmed by the output; a check that misses too many of the
cases it's looking for will give a false sense of security. Neither is acceptable.
A vet check must be accurate enough that everything it reports is worth examining,

     *
     * This should only be collected if it is very cheap to do so. For example, some HTTP servers send an
     * “X-Checksum-Sha1” that makes the sha1 available cheaply. In this case it makes sense to advertise this as metadata here.
     *
     * @return The sha1, or null if it's unknown.
     */
    @Nullable
    HashCode getSha1();

    boolean wasMissing();

	// activates may do a couple milliseconds of GC-related work and nothing
	// else in the few seconds that the profiler observes.
	spec := new(itimerspec)
	spec.it_value.setNsec(1 + int64(cheaprandn(uint32(1e9/hz))))
	spec.it_interval.setNsec(1e9 / int64(hz))

	var timerid int32
	var sevp sigevent
	sevp.notify = _SIGEV_THREAD_ID
	sevp.signo = _SIGPROF
	sevp.sigev_notify_thread_id = int32(mp.procid)

	pad_cgo_0   [8]byte
	uc_mcontext mcontext
	uc_filler   [5]int64
	pad_cgo_1   [8]byte
}

type timespec struct {
	tv_sec  int64
	tv_nsec int64
}

//go:nosplit
func (ts *timespec) setNsec(ns int64) {
	ts.tv_sec = ns / 1e9
	ts.tv_nsec = ns % 1e9
}

type timeval struct {
	tv_sec  int64
	tv_usec int64
}

func (tv *timeval) set_usec(x int32) {
	tv.tv_usec = int64(x)
}

	_SIGEV_THREAD_ID = 0x4

	_AF_UNIX    = 0x1
	_SOCK_DGRAM = 0x2
)

type timespec struct {
	tv_sec  int64
	tv_nsec int64
}

//go:nosplit
func (ts *timespec) setNsec(ns int64) {
	ts.tv_sec = ns / 1e9
	ts.tv_nsec = ns % 1e9
}

type timeval struct {
	tv_sec  int64
	tv_usec int64
}

func (tv *timeval) set_usec(x int32) {
	tv.tv_usec = int64(x)
}