import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.queue.MultiChannelQueue;

import java.util.concurrent.locks.Lock;

class IncomingQueue extends MultiChannelQueue {
    IncomingQueue(Lock lock) {
        super(lock);
    }

    public void requestStop() {
        queue(new EndOfStream());
    }

import org.gradle.internal.remote.internal.hub.protocol.ChannelIdentifier
import org.gradle.internal.remote.internal.hub.protocol.ChannelMessage
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream

class MultiChannelQueueTest extends AbstractQueueTest {
    final MultiChannelQueue queue = new MultiChannelQueue(lock)

    def "adds and caches channel queue on first lookup"() {

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub.queue

import org.gradle.internal.remote.internal.hub.protocol.EndOfStream

class MultiEndPointQueueTest extends AbstractQueueTest {
    final MultiEndPointQueue queue = new MultiEndPointQueue(lock)

    def "forwards queued unicast messages to first waiting endpoint"() {
        given:

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub.queue

import org.gradle.internal.dispatch.Dispatch
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage

class QueueInitializerTest extends AbstractQueueTest {
    final QueueInitializer initializer = new QueueInitializer()

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub.queue;

import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.HashSet;

        try {
            delegate.write(text);
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    @Override
    public void endOfStream(@Nullable Throwable failure) {
        try {
            delegate.close();
        } catch (IOException e) {
            if (failure == null) {
                throw UncheckedException.throwAsUncheckedException(e);

                    result.rethrowFailure().assertNormalExitValue();
                }
            } catch (ExecException e) {
                stdOut.endOfStream(e);
                stdErr.endOfStream(null);
            } finally {
                execHandle = null;
            }
        }

    void text(String text);

    /**
     * Called when the end of the stream is reached for some reason.
     *
     * @param failure The failure, if any, which caused the end of the stream.
     */
    void endOfStream(@Nullable Throwable failure);

                            addToIncoming(new StreamFailureMessage(e));
                            continue;
                        }
                        if (message == null || message instanceof EndOfStream) {
                            return;
                        }
                        addToIncoming(message);
                    }
                } finally {
                    lock.lock();

        private OutputListener destination;

        @Override
        public void text(String message) {
            destination.onOutput(message);
        }

        @Override
        public void endOfStream(@Nullable Throwable failure) {
        }

        public void setDestination(OutputListener destination) {
            this.destination = destination;
        }
    }