* See the License for the specific language governing permissions and
 * limitations under the License.
 */

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

public class EndOfStream extends InterHubMessage {
    @Override
    public String toString() {
        return "[" + getClass().getSimpleName() + "]";
    }

    @Override
    public Delivery getDelivery() {

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

public class QueueInitializer {
    private EndOfStream endOfStream;

    void onStatefulMessage(InterHubMessage message) {
        if (message instanceof EndOfStream) {
            endOfStream = (EndOfStream) message;
        } else {

        if (open) {
            delegate.text(text);
        } else {
            open = true;
        }
    }

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

        action.text("line 1-")
        action.endOfStream(null)
    }

    def logsPartialLineOnClose()  {
        LineBufferingOutputStream outputStream = new LineBufferingOutputStream(action, eol, 8)

        when:
        outputStream.write("line 1".getBytes())
        outputStream.close()

        then:
        action.text("line 1")
        action.endOfStream(null)
    }

        when:
        skipper.text("a")
        skipper.endOfStream(null)

        then:
        1 * delegate.endOfStream(null)
        0 * delegate._
    }

    def "does not skip EOS if before first"() {
        given:
        def delegate = Mock(TextStream)
        def skipper = new SkipFirstTextStream(delegate)

        when:
        skipper.endOfStream(null)

        then:
        1 * delegate.endOfStream(null)

 * limitations under the License.
 */

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

import org.gradle.internal.remote.internal.hub.protocol.ChannelMessage;
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.queue.MultiEndPointQueue;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;
import org.gradle.internal.remote.internal.hub.protocol.RejectedMessage;

import org.gradle.internal.serialize.StatefulSerializer;
import org.gradle.internal.remote.internal.hub.protocol.ChannelIdentifier;
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

 * limitations under the License.
 */

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

import org.gradle.internal.remote.internal.RemoteConnection;
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;
import org.gradle.internal.remote.internal.hub.queue.EndPointQueue;

import java.util.HashSet;
import java.util.Set;

class ConnectionSet {

        result[2].channel == channelId1
        result[2].payload == "payload 3"
    }

    def "can serialise EndOfStream"() {
        when:
        def serialized = serialize(new EndOfStream())
        def result = deserialize(serialized)

        then:
        result instanceof EndOfStream
    }

    def serialize(InterHubMessage... messages) {
        def outStr = new ByteArrayOutputStream()

        then:
        1 * action.text("text")
        1 * action.endOfStream(null)
        0 * action._
    }

    def closeDoesNothingWhenNothingWritten() {
        TextStream action = Mock()
        def outstr = new LinePerThreadBufferingOutputStream(action)

        when:
        outstr.close()

        then:
        1 * action.endOfStream(null)
        0 * action._
    }