${server.callFromBuild("pending")}
            } as ${PendingChangesListener.canonicalName})

            task work(type: SimpleTask)
        """

        file("input.txt").text = "start"
    }

    def "build only starts when gate is opened"() {
        server.expect(server.get("command").send("close"))
        def command = server.expectAndBlock(server.get("command").send("open"))

### BEGIN INIT INFO
# Provides:          fess
# Required-Start:    $network $remote_fs $named
# Required-Stop:     $network $remote_fs $named
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Starts fess
# Description:       Starts fess using start-stop-daemon
### END INIT INFO

PATH=/bin:/usr/bin:/sbin:/usr/sbin
NAME=fess
DESC="Fess Server"
DEFAULT=/etc/default/$NAME

if [ `id -u` -ne 0 ]; then

  ~QueueRunner();

  /// Starts the queue runner with the given session.
  Status Start(Session* sess);

  /// Starts the queue runner with the given session and sets the run arguments
  /// for sess->Run. It also collects and stores the cost model.
  Status StartAndCollectCostGraph(Session* sess,
                                  const RunOptions& run_options = RunOptions());

			StabilityLevel: metrics.ALPHA,
		},
		[]string{"protocol", "transport", "stage"},
	)

	legacyregistry.MustRegister(starts)
	legacyregistry.MustRegister(latencies)
	legacyregistry.MustRegister(failures)
	return &DialMetrics{starts: starts, latencies: latencies, failures: failures, clock: clock.RealClock{}}
}

// Clock returns the clock.
func (m *DialMetrics) Clock() clock.Clock {

public interface StandardOutputRedirector {

    /**
     * Starts redirection of System.out and System.err to the listener attached to
     * {@link #redirectStandardErrorTo(OutputListener)} and
     * {@link #redirectStandardOutputTo(OutputListener)
     */
    void start();

    /**
     * Restores System.out and System.err to the values they had before {@link #start()} has been called.
     */
    void stop();

	g.Start(func() {
		f(stopCh)
	})
}

// StartWithContext starts f in a new goroutine in the group.
// ctx is passed to f as an argument. f should stop when ctx.Done() is available.
func (g *Group) StartWithContext(ctx context.Context, f func(context.Context)) {
	g.Start(func() {
		f(ctx)
	})
}

// Start starts f in a new goroutine in the group.
func (g *Group) Start(f func()) {
	g.wg.Add(1)

#!/bin/sh
#
# fess <summary>
#
# chkconfig:   2345 80 20
# description: Starts and stops a single fess instance on this system 
#

### BEGIN INIT INFO
# Provides: Fess
# Required-Start: $network $named
# Required-Stop: $network $named
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: This service manages the fess daemon

    /**
     * Collects whatever state is required the given process. Should not start work.
     */
    void connectStreams(Process process, String processName, Executor executor);

    /**
     * Starts reading/writing/whatever the process' streams. May block until the streams reach some particular state, e.g. indicate that the process has started successfully.
     */
    void start();

    /**

        when:
        handler.reservePort()
        handler.start(10, {})
        handler.start(11, {})
        handler.start(12, {})

        then:
        2 * factory.create(_ as String) >> Mock(ManagedExecutor)
    }

    def "cannot start contention handling when the handler was stopped"() {
        handler.stop()

        when:
        handler.start(10, {})

        then:

	}
	return false
}

// NewServer starts and returns a new [Server].
// The caller should call Close when finished, to shut it down.
func NewServer(handler http.Handler) *Server {
	ts := NewUnstartedServer(handler)
	ts.Start()
	return ts
}

// NewUnstartedServer returns a new [Server] but doesn't start it.
//
// After changing its configuration, the caller should call Start or
// StartTLS.
//