// If any call returns true, DoChildren stops and returns true.
// Otherwise, DoChildren returns false.
//
// Note that DoChildren(n, do) only calls do(x) for n's immediate children.
// If x's children should be processed, then do(x) must call DoChildren(x, do).
//
// DoChildren allows constructing general traversals of the IR graph
// that can stop early if needed. The most general usage is:
//

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.launcher.daemon.server;

/**
 * Indicates the state of the daemon when it stops doing work.
 */
public enum DaemonStopState {
    /**
     * Daemon was stopped cleanly and all work stopped.
     */
    Clean,
    /**

	func (c *B) Errorf(format string, args ...any)

	// Fail marks the function as having failed but continues ...
	func (c *B) Fail()

	// FailNow marks the function as having failed and stops its ...
	func (c *B) FailNow()

	// Failed reports whether the function has failed. 
	func (c *B) Failed() bool

	// Fatal is equivalent to Log() followed by FailNow(). 
	func (c *B) Fatal(args ...any)

        given:
        configureGarbageCollectionHeapEventsFor(256, 512, 35, garbageCollector.monitoringStrategy.gcRateThreshold + 0.2)

        when:
        run "injectEvents"

        then:
        daemons.daemon.stops()

        and:
        daemons.daemon.log.contains(DAEMON_WILL_STOP_MESSAGE)
        output.contains("""The Daemon will expire after the build after running out of JVM heap space.

public interface TestExecuter<T extends TestExecutionSpec> {

    @UsedByScanPlugin("test-distribution")
    void execute(T testExecutionSpec, TestResultProcessor testResultProcessor);

    /**
     * Stops any {@link TestClassProcessor} utilized by this {@code TestExecuter}.
     */
    @UsedByScanPlugin("test-distribution")
    void stopNow();

     * not use the result processor provided to {@link #startProcessing(TestResultProcessor)} after this method has
     * returned.
     */
    @Override
    void stop();

    /**
     * Stops any pending or asynchronous processing immediately
     *
     * Any test class assigned to this processor, but not yet run will not have results in the output.  The processor should

 */

package org.gradle.workers.internal;

public enum KeepAliveMode {
    /**
     * Keep alive until the end of the build session
     */
    SESSION,
    /**
     * Keep alive until the daemon stops
     */
    DAEMON

     * It should, however, stop accepting new work.</p>
     *
     * <p>
     * Requesting stopping does not guarantee the stoppable actually stops.
     * Requesting stopping means preparing for stopping; stopping accepting new work.
     * You have to call stop at some point anyway if your intention is to completely stop the stoppable.
     */
    void requestStop();

        exit 1
    ;;
esac

# Stops the service
if [ "$STOP_REQUIRED" = "true" ]; then
    echo -n "Stopping fess service..."
    if command -v systemctl >/dev/null; then
        systemctl --no-reload stop fess.service > /dev/null 2>&1 || true

    elif [ -x /etc/init.d/fess ]; then
        if command -v invoke-rc.d >/dev/null; then
            invoke-rc.d fess stop || true
        else

func NewRunner(f ...func(stop chan struct{})) *Runner {
	return &Runner{loopFuncs: f}
}

// Start begins running.
func (r *Runner) Start() {
	r.lock.Lock()
	defer r.lock.Unlock()
	if r.stop == nil {
		c := make(chan struct{})
		r.stop = &c
		for i := range r.loopFuncs {
			go r.loopFuncs[i](*r.stop)
		}
	}
}

// Stop stops running.
func (r *Runner) Stop() {
	r.lock.Lock()
	defer r.lock.Unlock()