lastBusy = clock.getCurrentTime();
        }
        this.state = state;
        return this;
    }

    @Override
    public String getUid() {
        return context.getUid();
    }

    @Override
    public Long getPid() {
        return context.getPid();
    }

    @Override
    public Address getAddress() {
        return address;
    }

    public DaemonContext getContext() {

)

func FuzzNonCrash(f *testing.F) {
	f.Fuzz(func(*testing.T, bool) {
		pid := syscall.Getpid()
		if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
			panic(err)
		}
		// signal may not be received immediately. Wait for it.
		select{}
	})
}

func FuzzKill(f *testing.F) {
	f.Fuzz(func(*testing.T, bool) {
		pid := syscall.Getpid()
		if err := syscall.Kill(pid, syscall.SIGKILL); err != nil {
			panic(err)
		}

                    @Override
                    public Long apply(DaemonInfo info) {
                        return info.getPid();
                    }
                });
                if (!allDaemonPids.contains(daemonContext.getPid())) {
                    return new DaemonExpirationResult(GRACEFUL_EXPIRE, REGISTRY_ENTRY_UNEXPECTEDLY_LOST);
                }
            }

	MOVL	$·Baton(SB), BX
	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADDL	$(1024 * 8), SP

	// Ask signaller to setgid
	MOVL	$1, (BX)

	// Wait for setgid completion
loop:
	PAUSE
	MOVL	(BX), AX
	CMPL	AX, $0
	JNE	loop

	// Restore stack
	SUBL	$(1024 * 8), SP

	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), R15

	// Ask signaller to setgid
	MOVD	$·Baton(SB), R5
	MOVW	$1, 0(R5)

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R3
	CMPBNE	R3, $0, loop

	// Restore stack
	SUB	$(1024 * 8), R15

	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADDV	$(1024*8), R3

	// Ask signaller to setgid
	MOVW	$1, R12
	DBAR
	MOVW	R12, ·Baton(SB)
	DBAR

	// Wait for setgid completion
loop:
	DBAR
	MOVW	·Baton(SB), R12
	OR	R13, R13, R13	// hint that we're in a spin loop
	BNE	R12, loop
	DBAR

	// Restore stack
	ADDV	$(-1024*8), R3

	"testing"
	"time"
)

type command struct {
	pipe io.WriteCloser
	proc *exec.Cmd
	test *testing.T
}

func (c *command) Info() (pid, pgrp int) {
	pid = c.proc.Process.Pid

	pgrp, err := syscall.Getpgid(pid)
	if err != nil {
		c.test.Fatal(err)
	}

	return
}

func (c *command) Start() {
	if err := c.proc.Start(); err != nil {
		c.test.Fatal(err)
	}
}

func (c *command) Stop() {

	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), RSP

	// Ask signaller to setgid
	MOVD	$·Baton(SB), R0
	MOVD	$1, R1
storeloop:
	LDAXRW	(R0), R2
	STLXRW	R1, (R0), R3
	CBNZ	R3, storeloop

	// Wait for setgid completion
	MOVW	$0, R1
	MOVW	$0, R2
loop:
	LDAXRW	(R0), R3
	CMPW	R1, R3
	BNE	loop
	STLXRW	R2, (R0), R3
	CBNZ	R3, loop

type Info interface {
	// GetName returns the name that uniquely identifies this user among all
	// other active users.
	GetName() string
	// GetUID returns a unique value for a particular user that will change
	// if the user is removed from the system and another user is added with
	// the same name.
	GetUID() string
	// GetGroups returns the names of the groups the user is a member of
	GetGroups() []string

//go:build aix

package syscall

import "unsafe"

//go:cgo_import_dynamic libc_Getpgid getpgid "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_Getpgrp getpgrp "libc.a/shr_64.o"

//go:linkname libc_Getpgid libc_Getpgid
//go:linkname libc_Getpgrp libc_Getpgrp

var (
	libc_Getpgid,
	libc_Getpgrp libcFunc
)

func Getpgid(pid int) (pgid int, err error) {