*/
    AUTO,
    /**
     * Don't attempt to isolate the work, use in-process workers.
     */
    NONE,
    /**
     * Isolate the work in its own classloader, use in-process workers.
     */
    CLASSLOADER,
    /**
     * Isolate the work in a separate process, use out-of-process workers.
     */
    PROCESS

 */

package org.gradle.process.internal.worker;

import java.io.Serializable;

/**
 * Handles requests to do work in worker process. Is instantiated in the build process and serialized to the worker process.
 */
public interface RequestHandler<IN, OUT> extends Serializable {
    /**
     * Executes the given request and returns the response. Called in the worker process only.
     */
    OUT run(IN request);

 * limitations under the License.
 */

package org.gradle.process.internal;

import org.gradle.api.Action;
import org.gradle.api.internal.ProcessOperations;
import org.gradle.process.ExecOperations;
import org.gradle.process.ExecResult;
import org.gradle.process.ExecSpec;
import org.gradle.process.JavaExecSpec;


public class DefaultExecOperations implements ExecOperations {

    private String processOutput;
    private InputStream processStdOutput;

    @Override
    public void connectStreams(Process process, String processName, Executor executor) {
        processStdOutput = process.getInputStream();
    }

    @Override
    @SuppressWarnings("DefaultCharset")
    public void start() {
        if (processStdOutput == null) {

 * limitations under the License.
 */

package org.gradle.process.internal

import junit.framework.AssertionFailedError
import org.gradle.api.reflect.ObjectInstantiationException
import org.gradle.process.internal.worker.RequestHandler
import org.gradle.process.internal.worker.WorkerControl
import org.gradle.process.internal.worker.WorkerProcessException
import org.gradle.test.fixtures.ConcurrentTestUtil

import org.gradle.process.ExecResult;
import org.gradle.process.internal.JavaExecHandleBuilder;
import org.gradle.process.internal.worker.request.Receiver;
import org.gradle.process.internal.worker.request.Request;
import org.gradle.process.internal.worker.request.RequestArgumentSerializers;
import org.gradle.process.internal.worker.request.RequestProtocol;
import org.gradle.process.internal.worker.request.RequestSerializerRegistry;

 * limitations under the License.
 */

package org.gradle.process.internal.streams;

import org.gradle.api.UncheckedIOException;
import org.gradle.process.internal.StreamsHandler;

import java.io.IOException;
import java.util.concurrent.Executor;

/**
 * A handler that writes nothing to the process' stdin
 */
public class EmptyStdInStreamsHandler implements StreamsHandler {
    @Override

//go:generate echo Fail e

-- inconsistent/a.go --
// Valid go file with inconsistent package name.
// Go generate should process this file with GOPACKAGE=a

package a
//go:generate echo Success $GOPACKAGE

-- inconsistent/b.go --
// Valid go file with inconsistent package name.
// Go generate should process this file with GOPACKAGE=b

//go:generate echo Success $GOPACKAGE
package b

-- inconsistent/c.go --

This is still true.

So, to be able to have **multiple processes** at the same time, there has to be a **single process listening on a port** that then transmits the communication to each worker process in some way.

### Memory per Process

 */

package org.gradle.internal.cc.impl.inputs.process.instrument

import org.gradle.integtests.fixtures.GroovyBuildScriptLanguage
import org.gradle.test.fixtures.file.TestFile
import spock.lang.Shared

/**
 * Base class for tests that invoke external process with the dynamic Groovy code.
 * There are many different ways to run a process in Groovy, and all are producing different byte code.