});
        }
    }

    /**
     * Remove any context associated with tracking the startup of this process.
     */
    public void removeStartupContext() {
        this.associatedBuildOperation = null;
        streamsHandler.removeStartupContext();
    }

    private void startProcess() {
        lock.lock();
        try {
            if (aborted) {

        public void start() {
            inputHandler.start();
            outputHandler.start();
        }

        @Override
        public void removeStartupContext() {
            inputHandler.removeStartupContext();
            outputHandler.removeStartupContext();
        }

        @Override
        public void stop() {
            outputHandler.stop();
            inputHandler.stop();
        }

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    @Override
    public void start() {
    }

    @Override
    public void removeStartupContext() {
    }

    @Override
    public void stop() {
    }

    @Override
    public void disconnect() {
    }

            throw new IllegalStateException("Unable to get process output as consuming has not finished yet.");
        }
        return processOutput;
    }

    @Override
    public void removeStartupContext() {
    }

    @Override
    public void stop() {
    }

    @Override
    public void disconnect() {
    }

     */
    void start();

    /**
     * Remove any context associated with tracking the startup of the process.
     */
    void removeStartupContext();

    /**
     * Disconnects from the process without waiting for further work.
     */
    void disconnect();

    /**

    Map<String, String> getEnvironment();

    /**
     * Starts this process, blocking until the process has started.
     *
     * @return this
     */
    ExecHandle start();

    void removeStartupContext();

    ExecHandleState getState();

    /**
     * Aborts the process, blocking until the process has exited. Does nothing if the process has already completed.
     */
    void abort();

    /**

    }

    @Override
    public void start() {
        executor.execute(standardInputWriter);
    }

    @Override
    public void removeStartupContext() {
    }

    @Override
    public void stop() {
        disconnect();
        try {
            completed.await();
        } catch (InterruptedException e) {

        }
        standardOutputReader.associateBuildOperation(CurrentBuildOperationRef.instance().get());
        executor.execute(standardOutputReader);
    }

    @Override
    public void removeStartupContext() {
        standardOutputReader.clearAssociatedBuildOperation();
        if (readErrorStream) {
            standardErrorReader.clearAssociatedBuildOperation();
        }
    }

    @Override

        // Inform the exec handle to clear the startup context, so that it can be garbage collected
        // This may contain references to tasks, projects, and builds which we don't want to keep around
        execHandle.removeStartupContext();
    }

    @Override
    public ExecResult waitForStop() {
        try {
            return execHandle.waitForFinish().assertNormalExitValue();
        } finally {
            cleanup();