test/jdk/java/net/httpclient/websocket/jdk.incubator.httpclient/jdk/incubator/http/internal/websocket/ReceivingTest.java
branchhttp-client-branch
changeset 55943 952aca3f605a
parent 55922 77feac3903d9
child 55973 4d9b002587db
equal deleted inserted replaced
55937:c94a558a70ed 55943:952aca3f605a
    25 
    25 
    26 import jdk.incubator.http.WebSocket;
    26 import jdk.incubator.http.WebSocket;
    27 import org.testng.annotations.Test;
    27 import org.testng.annotations.Test;
    28 
    28 
    29 import java.net.URI;
    29 import java.net.URI;
       
    30 import java.nio.ByteBuffer;
    30 import java.util.List;
    31 import java.util.List;
    31 import java.util.concurrent.CompletableFuture;
    32 import java.util.concurrent.CompletableFuture;
    32 import java.util.concurrent.CompletionStage;
    33 import java.util.concurrent.CompletionStage;
    33 import java.util.concurrent.TimeUnit;
    34 import java.util.concurrent.TimeUnit;
    34 
    35 
    40 import static jdk.incubator.http.WebSocket.NORMAL_CLOSURE;
    41 import static jdk.incubator.http.WebSocket.NORMAL_CLOSURE;
    41 import static jdk.incubator.http.internal.common.Pair.pair;
    42 import static jdk.incubator.http.internal.common.Pair.pair;
    42 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onClose;
    43 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onClose;
    43 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onError;
    44 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onError;
    44 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onOpen;
    45 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onOpen;
       
    46 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onPing;
       
    47 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onPong;
    45 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onText;
    48 import static jdk.incubator.http.internal.websocket.MockListener.ListenerInvocation.onText;
    46 import static org.testng.Assert.assertEquals;
    49 import static org.testng.Assert.assertEquals;
    47 
    50 
    48 public class ReceivingTest {
    51 public class ReceivingTest {
    49 
    52 
    78             @Override
    81             @Override
    79             protected Receiver newReceiver(MessageStreamConsumer consumer) {
    82             protected Receiver newReceiver(MessageStreamConsumer consumer) {
    80                 return new MockReceiver(consumer, channel,
    83                 return new MockReceiver(consumer, channel,
    81                                         pair(now(), m -> m.onText("1", FIRST)),
    84                                         pair(now(), m -> m.onText("1", FIRST)),
    82                                         pair(now(), m -> m.onText("2", PART)),
    85                                         pair(now(), m -> m.onText("2", PART)),
    83                                         pair(now(), m -> m.onText("3", PART)),
    86                                         pair(now(), m -> m.onText("3", LAST)),
    84                                         pair(now(), m -> m.onText("4", LAST)),
       
    85                                         pair(now(), m -> m.onClose(NORMAL_CLOSURE, "no reason")));
    87                                         pair(now(), m -> m.onClose(NORMAL_CLOSURE, "no reason")));
    86             }
    88             }
    87         };
    89         };
    88         WebSocket ws = newInstance(listener, transport);
    90         WebSocket ws = newInstance(listener, transport);
    89         listener.onCloseOrOnErrorCalled().get(10, TimeUnit.SECONDS);
    91         listener.onCloseOrOnErrorCalled().get(10, TimeUnit.SECONDS);
    90         List<MockListener.ListenerInvocation> invocations = listener.invocations();
    92         List<MockListener.ListenerInvocation> invocations = listener.invocations();
    91         assertEquals(invocations, List.of(onOpen(ws),
    93         assertEquals(invocations, List.of(onOpen(ws),
    92                                           onText(ws, "1", FIRST),
    94                                           onText(ws, "1", FIRST),
    93                                           onText(ws, "2", PART),
    95                                           onText(ws, "2", PART),
    94                                           onText(ws, "3", PART),
    96                                           onText(ws, "3", LAST),
    95                                           onText(ws, "4", LAST),
    97                                           onClose(ws, NORMAL_CLOSURE, "no reason")));
       
    98     }
       
    99 
       
   100     @Test
       
   101     public void testText2() throws Exception {
       
   102         MockListener listener = new MockListener(Long.MAX_VALUE);
       
   103         MockTransport transport = new MockTransport() {
       
   104             @Override
       
   105             protected Receiver newReceiver(MessageStreamConsumer consumer) {
       
   106                 return new MockReceiver(consumer, channel,
       
   107                                         pair(now(),      m -> m.onText("1", FIRST)),
       
   108                                         pair(seconds(1), m -> m.onText("2", PART)),
       
   109                                         pair(now(),      m -> m.onText("3", LAST)),
       
   110                                         pair(seconds(1), m -> m.onClose(NORMAL_CLOSURE, "no reason")));
       
   111             }
       
   112         };
       
   113         WebSocket ws = newInstance(listener, transport);
       
   114         listener.onCloseOrOnErrorCalled().get(10, TimeUnit.SECONDS);
       
   115         List<MockListener.ListenerInvocation> invocations = listener.invocations();
       
   116         assertEquals(invocations, List.of(onOpen(ws),
       
   117                                           onText(ws, "1", FIRST),
       
   118                                           onText(ws, "2", PART),
       
   119                                           onText(ws, "3", LAST),
       
   120                                           onClose(ws, NORMAL_CLOSURE, "no reason")));
       
   121     }
       
   122 
       
   123     @Test
       
   124     public void testTextIntermixedWithPongs() throws Exception {
       
   125         MockListener listener = new MockListener(Long.MAX_VALUE);
       
   126         MockTransport transport = new MockTransport() {
       
   127             @Override
       
   128             protected Receiver newReceiver(MessageStreamConsumer consumer) {
       
   129                 return new MockReceiver(consumer, channel,
       
   130                                         pair(now(),      m -> m.onText("1", FIRST)),
       
   131                                         pair(now(),      m -> m.onText("2", PART)),
       
   132                                         pair(now(),      m -> m.onPong(ByteBuffer.allocate(16))),
       
   133                                         pair(seconds(1), m -> m.onPong(ByteBuffer.allocate(32))),
       
   134                                         pair(now(),      m -> m.onText("3", LAST)),
       
   135                                         pair(now(),      m -> m.onPong(ByteBuffer.allocate(64))),
       
   136                                         pair(now(),      m -> m.onClose(NORMAL_CLOSURE, "no reason")));
       
   137             }
       
   138         };
       
   139         WebSocket ws = newInstance(listener, transport);
       
   140         listener.onCloseOrOnErrorCalled().get(10, TimeUnit.SECONDS);
       
   141         List<MockListener.ListenerInvocation> invocations = listener.invocations();
       
   142         assertEquals(invocations, List.of(onOpen(ws),
       
   143                                           onText(ws, "1", FIRST),
       
   144                                           onText(ws, "2", PART),
       
   145                                           onPong(ws, ByteBuffer.allocate(16)),
       
   146                                           onPong(ws, ByteBuffer.allocate(32)),
       
   147                                           onText(ws, "3", LAST),
       
   148                                           onPong(ws, ByteBuffer.allocate(64)),
       
   149                                           onClose(ws, NORMAL_CLOSURE, "no reason")));
       
   150     }
       
   151 
       
   152     @Test
       
   153     public void testTextIntermixedWithPings() throws Exception {
       
   154         MockListener listener = new MockListener(Long.MAX_VALUE);
       
   155         MockTransport transport = new MockTransport() {
       
   156             @Override
       
   157             protected Receiver newReceiver(MessageStreamConsumer consumer) {
       
   158                 return new MockReceiver(consumer, channel,
       
   159                                         pair(now(),      m -> m.onText("1", FIRST)),
       
   160                                         pair(now(),      m -> m.onText("2", PART)),
       
   161                                         pair(now(),      m -> m.onPing(ByteBuffer.allocate(16))),
       
   162                                         pair(seconds(1), m -> m.onPing(ByteBuffer.allocate(32))),
       
   163                                         pair(now(),      m -> m.onText("3", LAST)),
       
   164                                         pair(now(),      m -> m.onPing(ByteBuffer.allocate(64))),
       
   165                                         pair(now(),      m -> m.onClose(NORMAL_CLOSURE, "no reason")));
       
   166             }
       
   167 
       
   168             @Override
       
   169             protected Transmitter newTransmitter() {
       
   170                 return new MockTransmitter() {
       
   171                     @Override
       
   172                     protected CompletionStage<?> whenSent() {
       
   173                         return now();
       
   174                     }
       
   175                 };
       
   176             }
       
   177         };
       
   178         WebSocket ws = newInstance(listener, transport);
       
   179         listener.onCloseOrOnErrorCalled().get(10, TimeUnit.SECONDS);
       
   180         List<MockListener.ListenerInvocation> invocations = listener.invocations();
       
   181         System.out.println(invocations);
       
   182         assertEquals(invocations, List.of(onOpen(ws),
       
   183                                           onText(ws, "1", FIRST),
       
   184                                           onText(ws, "2", PART),
       
   185                                           onPing(ws, ByteBuffer.allocate(16)),
       
   186                                           onPing(ws, ByteBuffer.allocate(32)),
       
   187                                           onText(ws, "3", LAST),
       
   188                                           onPing(ws, ByteBuffer.allocate(64)),
    96                                           onClose(ws, NORMAL_CLOSURE, "no reason")));
   189                                           onClose(ws, NORMAL_CLOSURE, "no reason")));
    97     }
   190     }
    98 
   191 
    99     private static CompletionStage<?> seconds(long s) {
   192     private static CompletionStage<?> seconds(long s) {
   100         return new CompletableFuture<>().completeOnTimeout(null, s, TimeUnit.SECONDS);
   193         return new CompletableFuture<>().completeOnTimeout(null, s, TimeUnit.SECONDS);