package org.gradle.launcher.daemon.protocol;

/**
 * Carries the user's response to a {@link org.gradle.internal.logging.events.PromptOutputEvent}.
 */
public class UserResponse extends InputMessage {
    private final String response;

    public UserResponse(String response) {
        this.response = response;
    }

    public String getResponse() {
        return response;
    }

    val responseCode = userResponse.code

    val method = userResponse.request.method
    when (responseCode) {
      HTTP_PROXY_AUTH -> {
        val selectedProxy = route!!.proxy
        if (selectedProxy.type() != Proxy.Type.HTTP) {
          throw ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy")
        }
        return client.proxyAuthenticator.authenticate(route, userResponse)
      }

 */

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();

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

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;

/**
 * Forwards user input received from the client to this process' System.in and {@link UserInputReader}.
 */

    private static class UserResponseSerializer implements Serializer<UserResponse> {
        @Override
        public void write(Encoder encoder, UserResponse message) throws Exception {
            encoder.writeString(message.getResponse());
        }

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

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

import static org.gradle.util.internal.TextUtil.toPlatformLineSeparators

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

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.concurrent.Executor;

        messageResult.bytes == message.bytes
    }

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

    def "can serialize user input request event"() {

                if (command instanceof CloseInput) {
                    handler.onEndOfInput();
                    return true;
                } else if (command instanceof UserResponse) {
                    handler.onUserResponse((UserResponse) command);
                } else {
                    handler.onInput((ForwardInput) command);
                }
            } catch (Exception e) {