//
	// On Windows, calling Release a second time returns EINVAL.
	return p.release()
}

// Kill causes the [Process] to exit immediately. Kill does not wait until
// the Process has actually exited. This only kills the Process itself,
// not any other processes it may have started.
func (p *Process) Kill() error {
	return p.kill()
}

// Wait waits for the [Process] to exit, and then returns a

		h.printf("cgi: copy error: %v", err)
		// And kill the child CGI process so we don't hang on
		// the deferred cmd.Wait above if the error was just
		// the client (rw) going away. If it was a read error
		// (because the child died itself), then the extra
		// kill of an already-dead process is harmless (the PID
		// won't be reused until the Wait above).
		cmd.Process.Kill()
	}
}

	// GetPodStatus and the following SyncPod will not return errors in the
	// case where the pod has been deleted. We are not adding any pods into
	// the fakePodProvider so they are 'deleted'.
	podStatus, err := m.GetPodStatus(ctx, pod.UID, pod.Name, pod.Namespace)
	assert.NoError(t, err)
	result := m.SyncPod(context.Background(), pod, podStatus, []v1.Secret{}, backOff)
	// This will return an error if the pod has _not_ been deleted.

     */
    int getPort();

    /**
     * Forcefully kills this daemon and all child processes.
     */
    void kill();

    /**
     * Forcefully kills this daemon, but not child processes.
     */
    void killDaemonOnly();

    /**
     * Changes the authentication token for this daemon in the registry, so that client will see a different token to that expected by this daemon
     */

	go func() {
		defer wg.Done()
		// We don't check the error return of Kill. It is
		// possible that the process has already exited, in
		// which case Kill will return an error "process
		// already finished". The purpose of this test is to
		// see whether the race detector reports an error; it
		// doesn't matter whether this Kill succeeds or not.
		cmd.Process.Kill()
	}()

	go func() {
		defer wg.Done()

                result << event
                if (!killed) {
                    sync.waitForAllPendingCalls()
                    sync.releaseAll()
                    toolingApi.daemons.daemon.kill()
                    killed = true
                }
            }, EnumSet.of(OperationType.TEST)).run()
        }

        then: "build fails with a DaemonDisappearedException"

CONFFILE="${CONFDIR}/rsyncd.conf"
SECRETS="${CONFDIR}/rsyncd.secrets"

mkdir -p "${CONFDIR}"

if [[ -f "${PIDFILE}" ]]; then
  PID=$(cat "${PIDFILE}")
  echo "Cleaning up old PID file: ${PIDFILE}"
  kill "${PID}" &> /dev/null || true
  rm "${PIDFILE}"
fi

PASSWORD=$(</rsyncd.password)

cat <<EOF >"${SECRETS}"
k8s:${PASSWORD}
EOF
chmod go= "${SECRETS}"

USER_CONFIG=
if [[ "$(id -u)" == "0" ]]; then

    kill "${ETCD_SCRAPE_PID}" &>/dev/null || :
    wait "${ETCD_SCRAPE_PID}" &>/dev/null || :
    kube::etcd::scrape || :
    (
      # shellcheck disable=SC2015
      cd "${ETCD_SCRAPE_DIR}"/.. && \
      tar czf etcd-scrapes.tgz etcd-scrapes && \
      rm -rf etcd-scrapes || :
    )
  fi
  if [[ -n "${ETCD_PID-}" ]]; then
    kill "${ETCD_PID}" &>/dev/null || :

/**
 * Verifies that we can spawn large amounts of workers without running out of memory, because the old ones will be killed
 * if necessary.
 *
 * <p>
 *     This mostly is a test for Windows, as other OSes have effectively-unlimited virtual memory, and won't need to kill
 *     processes.
 * </p>
 */
class WorkerPruningSoakTest extends AbstractIntegrationSpec {

		if err := syscall.Exec(os.Args[0], argv, os.Environ()); err != nil {
			t.Fatal(err)
		}
	}

	var cmds []*exec.Cmd
	defer func() {
		for _, cmd := range cmds {
			cmd.Process.Kill()
		}
	}()

	args := append(append([]string(nil), os.Args[1:]...), "-test.run=^Test18146$")
	for n := attempts; n > 0; n-- {
		cmd := exec.Command(os.Args[0], args...)
		cmd.Env = append(os.Environ(), "test18146=exec")