def consumer = new DaemonOutputConsumer()

    def "consumes process output until EOF"() {
        def process = process('hey Joe!')

        when:
        consumer.connectStreams(process, "cool process", executor)
        consumer.start()
        consumer.stop()
        then:
        consumer.processOutput.trim() == 'hey Joe!'
    }

    def "consumes process greeting noticed in output"() {
        def output = """

    }

    String getPermissions() {
        if (isWindows()) {
            return "-rwxr-xr-x"
        }

        def process = ["ls", "-ld", file.absolutePath].execute()
        def result = process.inputStream.text
        def error = process.errorStream.text
        def retval = process.waitFor()
        if (retval != 0) {
            throw new RuntimeException("Could not list permissions for '$file': $error")
        }

 */

package org.gradle.process.internal.worker.request;

/**
 * Protocol for controlling a worker process.
 * <p>
 * This protocol is used by the daemon to control the current work the worker process is doing.
 */
public interface RequestProtocol {
    /**
     * Runs the given request in the worker process.
     * <p>

            Process process = processLauncher.start(processBuilder);
            streamsHandler.connectStreams(process, execHandle.getDisplayName(), executor);
            this.process = process;
        } finally {
            lock.unlock();
        }
    }

    private void completed(int exitValue) {
        if (aborted) {

	// must have a parent process group in the same session or mask SIGTTOU
	// (which we do). An orphaned process group cannot receive
	// terminal-generated SIGTSTP at all.
	//
	// Achieving this requires three processes total:
	// - Top-level process: this is the main test process and creates the
	// pseudo-terminal.
	// - GO_TEST_TERMINAL_SIGNALS=1: This process creates a new process

 * limitations under the License.
 */

package org.gradle.process.internal.worker;

import org.gradle.api.Action;

public interface WorkerProcessFactory {
    /**
     * Creates a builder for workers that will run the given action. The worker action is serialized to the worker process and executed.
     *
     * <p>The worker process is not started until {@link WorkerProcess#start()} is called.</p>
     *

        }
    }

    List<String> listObjectFiles() {
        def process = ['ar', '-t', binaryFile.getAbsolutePath()].execute(environments, null)
        return process.inputStream.readLines().drop(1)
    }

    List<String> listLinkedLibraries() {
        def process = ['otool', '-L', binaryFile.absolutePath].execute(environments, null)
        def lines = process.inputStream.readLines()
        return lines
    }

     * Setting host to {@code *} will make the process listen on all network interfaces. This is not supported on Java 8 and below.
     * Setting host to anything else will make the process listen on that address.
     * </p>
     * <p>
     * When run in {@link #getServer() client} mode, the process attempts to connect to the given host and {@link #getPort()}.
     * </p>
     *
     * @since 7.6
     */
    @Incubating
    @Optional

    /**
     * Sets the standard input stream for the process executing the command. The stream is closed after the process
     * completes.
     *
     * @param inputStream The standard input stream for the process. Must not be null.
     * @return this
     */
    BaseExecSpec setStandardInput(InputStream inputStream);

    /**
     * Returns the standard input stream for the process executing the command. The stream is closed after the process

// on all systems are Interrupt (send the process an interrupt) and
// Kill (force the process to exit). Interrupt is not implemented on
// Windows; using it with [os.Process.Signal] will return an error.
var (
	Interrupt Signal = syscall.Note("interrupt")
	Kill      Signal = syscall.Note("kill")
)

func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) {
	sysattr := &syscall.ProcAttr{