*/
package org.gradle.launcher.daemon.protocol;

/**
 * Carries some text that should be made available via the daemon's System.in
 */
public class ForwardInput extends InputMessage {
    private final byte[] bytes;

    public ForwardInput(byte[] bytes) {
        this.bytes = bytes;
    }

    public byte[] getBytes() {
        return bytes;
    }

import org.gradle.internal.IoActions;
import org.gradle.internal.logging.events.OutputEvent;
import org.gradle.internal.logging.events.OutputEventListener;
import org.gradle.launcher.daemon.protocol.ForwardInput;
import org.gradle.launcher.daemon.protocol.UserResponse;

import java.io.InputStream;
import java.util.function.Function;

/**

        daemonConnection.stop()
    }

    def "forwards queued input events to stdin handler until end of input received"() {
        StdinHandler handler = Mock()
        def input1 = new ForwardInput("hello".bytes)
        def input2 = new ForwardInput("hello".bytes)
        def closeInput = new CloseInput()
        def received = new CountDownLatch(1)

        when:
        daemonConnection.onStdin(handler)

            }
        });
        return forwarder.forwardInput(stdinHandler -> {
            DaemonClientInputForwarder inputForwarder = new DaemonClientInputForwarder(finalStandardInput, message -> {
                if (message instanceof UserResponse) {
                    stdinHandler.onUserResponse((UserResponse) message);
                } else if (message instanceof ForwardInput) {
                    stdinHandler.onInput((ForwardInput) message);

 */

package org.gradle.internal.daemon.clientinput;

import org.gradle.launcher.daemon.protocol.ForwardInput;
import org.gradle.launcher.daemon.protocol.UserResponse;

public interface StdinHandler {
    void onUserResponse(UserResponse input);

    void onInput(ForwardInput input);

    void onEndOfInput();

import org.gradle.internal.logging.events.PromptOutputEvent
import org.gradle.internal.logging.events.ReadStdInEvent
import org.gradle.launcher.daemon.protocol.CloseInput
import org.gradle.launcher.daemon.protocol.ForwardInput
import org.gradle.launcher.daemon.protocol.UserResponse
import org.gradle.util.ConcurrentSpecification

import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit

                } else {
                    String text = new String(buffer, 0, nread);
                    byte[] result = text.getBytes(Charset.defaultCharset());
                    ForwardInput message = new ForwardInput(result);
                    dispatch.dispatch(message);
                }
            });
        }

        @Override
        public void readAndForwardText(Normalizer normalizer) {

    private static class ForwardInputSerializer implements Serializer<ForwardInput> {
        @Override
        public void write(Encoder encoder, ForwardInput message) throws Exception {
            encoder.writeBinary(message.getBytes());
        }

        @Override
        public ForwardInput read(Decoder decoder) throws Exception {
            return new ForwardInput(decoder.readBinary());
        }
    }

        messageResult instanceof CloseInput
    }

    def "can serialize ForwardInput messages"() {
        expect:
        def message = new ForwardInput("greetings".bytes)
        def messageResult = serialize(message, serializer)
        messageResult instanceof ForwardInput
        messageResult.bytes == message.bytes
    }

    def "can serialize UserResponse messages"() {

        this.forwarder = new ClientInputForwarder(inputReader, eventDispatch);
    }

    @Override
    public void execute(final DaemonCommandExecution execution) {
        forwarder.forwardInput(stdinHandler -> {
            execution.getConnection().onStdin(stdinHandler);
            try {
                execution.proceed();
            } finally {
                execution.getConnection().onStdin(null);