Long pid
        ConcurrentTestUtil.poll {
            pid = getPidFromOutput(gradleHandle) as Long
        }
        this.process = new ProcessFixture(pid)
    }

    DaemonClientFixture kill() {
        process.kill(false)
        gradleHandle.waitForFailure()
        return this
    }

    static String getPidFromOutput(GradleHandle build) {

	echo "waiting for decom to finish..."
	count=$((count + 1))
	if [ ${count} -eq 120 ]; then
		./mc cat /tmp/expanded_*.log
	fi
	sleep 1
done

kill $pid_1
kill $pid_2

sleep 5

(minio server --address ":9001" http://localhost:9001/tmp/xl/{11...30}/disk{0...3} 2>&1 >/tmp/removed.log) &
pid=$!

sleep 5

				t.Errorf("Manager chose to kill pod: %v, but should have chosen %v", podKiller.pod.Name, podToEvict.Name)
			}
			if podKiller.gracePeriodOverride == nil {
				t.Errorf("Manager chose to kill pod but should have had a grace period override.")
			}
			observedGracePeriod = *podKiller.gracePeriodOverride
			if observedGracePeriod != int64(1) {

	{_SigThrow, "sys:"},

	// Issued to all other procs when calling runtime·exit.
	{_SigGoExit, "go: exit "},

	// Kill is sent by external programs to cause an exit.
	{_SigKill, "kill"},

	// Interrupts can be handled if desired, otherwise they cause an exit.
	{_SigNotify + _SigKill, "interrupt"},
	{_SigNotify + _SigKill, "hangup"},

	// Alarms can be handled if desired, otherwise they're ignored.
	{_SigNotify, "alarm"},

	i = pthread_sigmask(SIG_BLOCK, &mask, NULL);
	if (i != 0) {
		fprintf(stderr, "pthread_sigmask: %s\n", strerror(i));
		exit(EXIT_FAILURE);
	}

	if (verbose) {
		printf("calling kill\n");
	}

	if (kill(0, SIGIO) < 0) {
		die("kill");
	}

	if (verbose) {
		printf("waiting for sigioSeen\n");
	}

	// Wait until the signal has been delivered.
	i = 0;
	while (!sigioSeen) {
		ts.tv_sec = 0;

import org.gradle.tooling.ProjectConnection

class DistributionChecksumCrossVersionSpec extends ToolingApiSpecification {
    // Newer clients no longer kill the JVM when a distribution is invalid.
    @TargetGradleVersion(">=3.0 <6.3")
    def "invalid Gradle distribution does not kill the TAPI client with older Gradle versions"() {
        given:
        toolingApi.requireDaemons()
        toolingApi.requireIsolatedUserHome()

	t.Logf("sigwinch...")
	syscall.Kill(syscall.Getpid(), syscall.SIGWINCH)
	waitSigAll(t, c1, syscall.SIGWINCH)

	// Send two more SIGHUPs, to make sure that
	// they get delivered on c1 and that not reading
	// from c does not block everything.
	t.Logf("sighup...")
	syscall.Kill(syscall.Getpid(), syscall.SIGHUP)
	waitSigAll(t, c1, syscall.SIGHUP)
	t.Logf("sighup...")
	syscall.Kill(syscall.Getpid(), syscall.SIGHUP)

    }

    /**
     * When the daemon is started on *nix, we need to detach it from the terminal session of the parent process,
     * otherwise if a ctrl-c is entered on the terminal, it will kill all processes in the session.  This test compiles
     * a native executable that can retrieve the session id of a process so that we can verify that the session id
     * of the daemon is different than the session id of the client.

	testenv.MustHaveGoBuild(t)
	t.Parallel()

	p, err := StartProcess(testenv.GoToolPath(t), []string{"go"}, &ProcAttr{})
	if err != nil {
		t.Fatalf("starting test process: %v", err)
	}
	p.Wait()
	if got := p.Signal(Kill); got != ErrProcessDone {
		t.Errorf("got %v want %v", got, ErrProcessDone)
	}
}

// Lookup of a process that does not exist at time of lookup.
func TestProcessAlreadyDone(t *testing.T) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build unix && !linux

package runtime

// sigFromUser reports whether the signal was sent because of a call
// to kill.
//
//go:nosplit
func (c *sigctxt) sigFromUser() bool {
	return c.sigcode() == _SI_USER