* <p>The worker process executes the request using an instance of the implementation type specified as a parameter to {@link WorkerProcessFactory#multiRequestWorker(Class)}.</p>
 *
 * <p>The worker process must be explicitly started and stopped using the methods on {@link WorkerControl}.</p>
 */
public interface MultiRequestWorkerProcessBuilder<IN, OUT> extends WorkerProcessSettings {
    /**
     * Creates a worker.
     *

			fmt.Println("Healstatus on items ===")
			for _, item := range status.Items {
				if err = enc.Encode(&item); err != nil {
					log.Fatalln(err)
				}
			}
			break
		}
		if status.Summary == "stopped" {
			fmt.Println("Healstatus on items ===")
			fmt.Println("Heal failed with", status.FailureDetail)
			break
		}

		for _, item := range status.Items {
			if err = enc.Encode(&item); err != nil {

    }

    public ServiceRegistry getServices() {
        return services;
    }

    @Override
    public void close() {
        // Force the user home services to be stopped first, because the dependencies between the user home services and the global services are not preserved currently
        CompositeStoppable.stoppable(services.get(GradleUserHomeScopeServiceRegistry.class), services).stop();
    }

            instant.actionCompleted
        }

        when:
        async {
            worker.runLater(action)
            worker.stop()
            instant.stopped
        }

        then:
        instant.stopped > instant.actionCompleted
    }

    def "can use operation to test that a method blocks until action is complete"() {
        Worker worker = new Worker(executor)

        given:

	// Meant to be run inside a goroutine
	// Waits for and reacts to changes in whatever type the controller
	// is concerned with.
	//
	// Returns an error always non-nil explaining why the worker stopped
	Run(ctx context.Context) error

	// Retrieves the informer used to back this controller
	Informer() Informer[T]

	// Returns true if the informer cache has synced, and all the objects from

		} else {
			r.readImport()
		}
	}

	info.header = r.buf

	// If we stopped successfully before EOF, we read a byte that told us we were done.
	// Return all but that last byte, which would cause a syntax error if we let it through.
	if r.err == nil && !r.eof {
		info.header = r.buf[:len(r.buf)-1]
	}

	// If we stopped for a syntax error, consume the whole file so that

        } catch (final ContainerNotAvailableException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("SuggestCreator is stopped.", e);
            } else if (logger.isInfoEnabled()) {
                logger.info("SuggestCreator is stopped.");
            }
            exitCode = Constants.EXIT_FAIL;
        } catch (final Throwable t) {

	{18, "SIGABND", "abend"},
	{19, "SIGCONT", "continued"},
	{20, "SIGCHLD", "child exited"},
	{21, "SIGTTIN", "stopped (tty input)"},
	{22, "SIGTTOU", "stopped (tty output)"},
	{23, "SIGIO", "I/O possible"},
	{24, "SIGQUIT", "quit"},
	{25, "SIGTSTP", "stopped"},
	{26, "SIGTRAP", "trace/breakpoint trap"},
	{27, "SIGIOER", "I/O error"},
	{28, "SIGWINCH", "window changed"},

  # Wait (if necessary) for service to stop.
  $timeout = 10
  $stopped = (Get-service $service).Status -eq 'Stopped'
  for ($i = 0; $i -lt $timeout -and !($stopped); $i++) {
      Start-Sleep 1
      $stopped = (Get-service $service).Status -eq 'Stopped'
  }

  if ((Get-service $service).Status -ne 'Stopped') {
    # Force kill the processes.

 *
 * You need to either always call start() and stop() in each test or use a
 * JUnit @Rule with an instance of this class.
 *
 * When used as a rule, the proxy is stopped automatically at the end of the test,
 * but it is _not_ automatically started.
 *
 * To use the proxy with a build, you must call configureProxy(GradleExecuter) before
 * starting the proxy.
 *