jdk-sandbox: comparison test/jdk/java/net/httpclient/websocket/WebSocketTest.java

equal deleted inserted replaced

-:48e480e56aad
+:3a79d4cccbcb
 * @build DummyWebSocketServer
 * @run testng/othervm
 *       WebSocketTest
 */
-import org.testng.annotations.AfterTest;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 import java.io.IOException;
 import java.net.Authenticator;
 private static void assertFails(Class<? extends Throwable> clazz,
 CompletionStage<?> stage) {
 Support.assertCompletesExceptionally(clazz, stage);
 }
-private DummyWebSocketServer server;
-private WebSocket webSocket;
-@AfterTest
-public void cleanup() {
-System.out.println("AFTER TEST");
-if (server != null)
-server.close();
-if (webSocket != null)
-webSocket.abort();
-}
 @Test
 public void illegalArgument() throws IOException {
-server = new DummyWebSocketServer();
+try (var server = new DummyWebSocketServer()) {
 server.open();
-webSocket = newBuilder().proxy(NO_PROXY).build()
+var webSocket = newBuilder().proxy(NO_PROXY).build()
 .newWebSocketBuilder()
 .buildAsync(server.getURI(), new WebSocket.Listener() { })
 .join();
+try {
 assertFails(IAE, webSocket.sendPing(ByteBuffer.allocate(126)));
 assertFails(IAE, webSocket.sendPing(ByteBuffer.allocate(127)));
 assertFails(IAE, webSocket.sendPing(ByteBuffer.allocate(128)));
 assertFails(IAE, webSocket.sendPing(ByteBuffer.allocate(129)));
 assertFails(IAE, webSocket.sendPing(ByteBuffer.allocate(256)));
 assertFails(IAE, webSocket.sendPong(ByteBuffer.allocate(126)));
 assertFails(IAE, webSocket.sendPong(ByteBuffer.allocate(127)));
 assertFails(IAE, webSocket.sendPong(ByteBuffer.allocate(128)));
 assertFails(IAE, webSocket.sendPong(ByteBuffer.allocate(129)));
 assertFails(IAE, webSocket.sendPong(ByteBuffer.allocate(256)));
 assertFails(IOE, webSocket.sendText(Support.incompleteString(), true));
 assertFails(IOE, webSocket.sendText(Support.incompleteString(), false));
 assertFails(IOE, webSocket.sendText(Support.malformedString(), true));
 assertFails(IOE, webSocket.sendText(Support.malformedString(), false));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.stringWithNBytes(124)));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.stringWithNBytes(125)));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.stringWithNBytes(128)));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.stringWithNBytes(256)));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.stringWithNBytes(257)));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.stringWith2NBytes((123 / 2) + 1)));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.malformedString()));
 assertFails(IAE, webSocket.sendClose(NORMAL_CLOSURE, Support.incompleteString()));
 assertFails(IAE, webSocket.sendClose(-2, "a reason"));
 assertFails(IAE, webSocket.sendClose(-1, "a reason"));
 assertFails(IAE, webSocket.sendClose(0, "a reason"));
 assertFails(IAE, webSocket.sendClose(1, "a reason"));
 assertFails(IAE, webSocket.sendClose(500, "a reason"));
 assertFails(IAE, webSocket.sendClose(998, "a reason"));
 assertFails(IAE, webSocket.sendClose(999, "a reason"));
 assertFails(IAE, webSocket.sendClose(1002, "a reason"));
 assertFails(IAE, webSocket.sendClose(1003, "a reason"));
 assertFails(IAE, webSocket.sendClose(1006, "a reason"));
 assertFails(IAE, webSocket.sendClose(1007, "a reason"));
 assertFails(IAE, webSocket.sendClose(1009, "a reason"));
 assertFails(IAE, webSocket.sendClose(1010, "a reason"));
 assertFails(IAE, webSocket.sendClose(1012, "a reason"));
 assertFails(IAE, webSocket.sendClose(1013, "a reason"));
 assertFails(IAE, webSocket.sendClose(1015, "a reason"));
 assertFails(IAE, webSocket.sendClose(5000, "a reason"));
 assertFails(IAE, webSocket.sendClose(32768, "a reason"));
 assertFails(IAE, webSocket.sendClose(65535, "a reason"));
 assertFails(IAE, webSocket.sendClose(65536, "a reason"));
 assertFails(IAE, webSocket.sendClose(Integer.MAX_VALUE, "a reason"));
 assertFails(IAE, webSocket.sendClose(Integer.MIN_VALUE, "a reason"));
 assertThrows(IAE, () -> webSocket.request(Integer.MIN_VALUE));
 assertThrows(IAE, () -> webSocket.request(Long.MIN_VALUE));
 assertThrows(IAE, () -> webSocket.request(-1));
 assertThrows(IAE, () -> webSocket.request(0));
-server.close();
+} finally {
+webSocket.abort();
+}
+}
 }
 @Test
 public void partialBinaryThenText() throws IOException {
-server = new DummyWebSocketServer();
+try (var server = new DummyWebSocketServer()) {
 server.open();
-webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
+var webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
 .buildAsync(server.getURI(), new WebSocket.Listener() { })
 .join();
-webSocket.sendBinary(ByteBuffer.allocate(16), false).join();
+try {
-assertFails(ISE, webSocket.sendText("text", false));
+webSocket.sendBinary(ByteBuffer.allocate(16), false).join();
-assertFails(ISE, webSocket.sendText("text", true));
+assertFails(ISE, webSocket.sendText("text", false));
-// Pings & Pongs are fine
+assertFails(ISE, webSocket.sendText("text", true));
-webSocket.sendPing(ByteBuffer.allocate(125)).join();
+// Pings & Pongs are fine
-webSocket.sendPong(ByteBuffer.allocate(125)).join();
+webSocket.sendPing(ByteBuffer.allocate(125)).join();
-server.close();
+webSocket.sendPong(ByteBuffer.allocate(125)).join();
+} finally {
+webSocket.abort();
+}
+}
 }
 @Test
 public void partialTextThenBinary() throws IOException {
-server = new DummyWebSocketServer();
+try (var server = new DummyWebSocketServer()) {
 server.open();
-webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
+var webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
 .buildAsync(server.getURI(), new WebSocket.Listener() { })
 .join();
+try {
 webSocket.sendText("text", false).join();
 assertFails(ISE, webSocket.sendBinary(ByteBuffer.allocate(16), false));
 assertFails(ISE, webSocket.sendBinary(ByteBuffer.allocate(16), true));
 // Pings & Pongs are fine
 webSocket.sendPing(ByteBuffer.allocate(125)).join();
 webSocket.sendPong(ByteBuffer.allocate(125)).join();
-server.close();
+} finally {
+webSocket.abort();
+}
+}
 }
 @Test
 public void sendMethodsThrowIOE1() throws IOException {
-server = new DummyWebSocketServer();
+try (var server = new DummyWebSocketServer()) {
 server.open();
-webSocket = newBuilder().proxy(NO_PROXY).build()
+var webSocket = newBuilder().proxy(NO_PROXY).build()
 .newWebSocketBuilder()
 .buildAsync(server.getURI(), new WebSocket.Listener() { })
 .join();
+try {
 webSocket.sendClose(NORMAL_CLOSURE, "ok").join();
 assertFails(IOE, webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "ok"));
 assertFails(IOE, webSocket.sendText("", true));
 assertFails(IOE, webSocket.sendText("", false));
 assertFails(IOE, webSocket.sendText("abc", true));
 assertFails(IOE, webSocket.sendText("abc", false));
 assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(0), true));
 assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(0), false));
 assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(1), true));
 assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(1), false));
 assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(125)));
 assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(124)));
 assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(1)));
 assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(0)));
 assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(125)));
 assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(124)));
 assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(1)));
 assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(0)));
+} finally {
-server.close();
+webSocket.abort();
+}
+}
 }
 @DataProvider(name = "sequence")
 public Object[][] data1() {
 int[] CLOSE = {
 @Test(dataProvider = "sequence")
 public void listenerSequentialOrder(int[] binary, long requestSize)
 throws IOException
 {
+try (var server = Support.serverWithCannedData(binary)) {
-server = Support.serverWithCannedData(binary);
+server.open();
-server.open();
+CompletableFuture<Void> violation = new CompletableFuture<>();
-CompletableFuture<Void> violation = new CompletableFuture<>();
+MockListener listener = new MockListener(requestSize) {
-MockListener listener = new MockListener(requestSize) {
+final AtomicBoolean guard = new AtomicBoolean();
-final AtomicBoolean guard = new AtomicBoolean();
+private <T> T checkRunExclusively(Supplier<T> action) {
-private <T> T checkRunExclusively(Supplier<T> action) {
+if (guard.getAndSet(true)) {
-if (guard.getAndSet(true)) {
-violation.completeExceptionally(new RuntimeException());
-}
-try {
-return action.get();
-} finally {
-if (!guard.getAndSet(false)) {
 violation.completeExceptionally(new RuntimeException());
 }
-}
+try {
-}
+return action.get();
+} finally {
-@Override
+if (!guard.getAndSet(false)) {
-public void onOpen(WebSocket webSocket) {
+violation.completeExceptionally(new RuntimeException());
-checkRunExclusively(() -> {
+}
-super.onOpen(webSocket);
+}
-return null;
+}
-});
-}
+@Override
+public void onOpen(WebSocket webSocket) {
-@Override
+checkRunExclusively(() -> {
-public CompletionStage<?> onText(WebSocket webSocket,
+super.onOpen(webSocket);
-CharSequence data,
+return null;
-boolean last) {
+});
-return checkRunExclusively(
+}
-() -> super.onText(webSocket, data, last));
-}
+@Override
+public CompletionStage<?> onText(WebSocket webSocket,
-@Override
+CharSequence data,
-public CompletionStage<?> onBinary(WebSocket webSocket,
+boolean last) {
-ByteBuffer data,
+return checkRunExclusively(
-boolean last) {
+() -> super.onText(webSocket, data, last));
-return checkRunExclusively(
+}
-() -> super.onBinary(webSocket, data, last));
-}
+@Override
+public CompletionStage<?> onBinary(WebSocket webSocket,
-@Override
+ByteBuffer data,
-public CompletionStage<?> onPing(WebSocket webSocket,
+boolean last) {
-ByteBuffer message) {
+return checkRunExclusively(
-return checkRunExclusively(
+() -> super.onBinary(webSocket, data, last));
-() -> super.onPing(webSocket, message));
+}
-}
+@Override
-@Override
+public CompletionStage<?> onPing(WebSocket webSocket,
-public CompletionStage<?> onPong(WebSocket webSocket,
+ByteBuffer message) {
-ByteBuffer message) {
+return checkRunExclusively(
-return checkRunExclusively(
+() -> super.onPing(webSocket, message));
-() -> super.onPong(webSocket, message));
+}
-}
+@Override
-@Override
+public CompletionStage<?> onPong(WebSocket webSocket,
-public CompletionStage<?> onClose(WebSocket webSocket,
+ByteBuffer message) {
-int statusCode,
+return checkRunExclusively(
-String reason) {
+() -> super.onPong(webSocket, message));
-return checkRunExclusively(
+}
-() -> super.onClose(webSocket, statusCode, reason));
-}
+@Override
+public CompletionStage<?> onClose(WebSocket webSocket,
-@Override
+int statusCode,
-public void onError(WebSocket webSocket, Throwable error) {
+String reason) {
-checkRunExclusively(() -> {
+return checkRunExclusively(
-super.onError(webSocket, error);
+() -> super.onClose(webSocket, statusCode, reason));
-return null;
+}
-});
-}
+@Override
-};
+public void onError(WebSocket webSocket, Throwable error) {
+checkRunExclusively(() -> {
-webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
+super.onError(webSocket, error);
-.buildAsync(server.getURI(), listener)
+return null;
-.join();
+});
+}
+};
-listener.invocations();
-violation.complete(null); // won't affect if completed exceptionally
+var webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
-violation.join();
+.buildAsync(server.getURI(), listener)
+.join();
-server.close();
+try {
+listener.invocations();
+violation.complete(null); // won't affect if completed exceptionally
+violation.join();
+} finally {
+webSocket.abort();
+}
+}
 }
 @Test
 public void sendMethodsThrowIOE2() throws Exception {
-server = Support.serverWithCannedData(0x88, 0x00);
+try (var server = Support.serverWithCannedData(0x88, 0x00)) {
 server.open();
-CompletableFuture<Void> onCloseCalled = new CompletableFuture<>();
-CompletableFuture<Void> canClose = new CompletableFuture<>();
+CompletableFuture<Void> onCloseCalled = new CompletableFuture<>();
+CompletableFuture<Void> canClose = new CompletableFuture<>();
-WebSocket.Listener listener = new WebSocket.Listener() {
-@Override
+WebSocket.Listener listener = new WebSocket.Listener() {
-public CompletionStage<?> onClose(WebSocket webSocket,
+@Override
-int statusCode,
+public CompletionStage<?> onClose(WebSocket webSocket,
-String reason) {
+int statusCode,
-System.out.printf("onClose(%s, '%s')%n", statusCode, reason);
+String reason) {
-onCloseCalled.complete(null);
+System.out.printf("onClose(%s, '%s')%n", statusCode, reason);
-return canClose;
+onCloseCalled.complete(null);
-}
+return canClose;
+}
-@Override
-public void onError(WebSocket webSocket, Throwable error) {
+@Override
-System.out.println("onError(" + error + ")");
+public void onError(WebSocket webSocket, Throwable error) {
-onCloseCalled.completeExceptionally(error);
+System.out.println("onError(" + error + ")");
-}
+onCloseCalled.completeExceptionally(error);
-};
+}
+};
-webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
-.buildAsync(server.getURI(), listener)
+var webSocket = newBuilder().proxy(NO_PROXY).build().newWebSocketBuilder()
-.join();
+.buildAsync(server.getURI(), listener)
+.join();
-onCloseCalled.join();      // Wait for onClose to be called
+try {
-canClose.complete(null);   // Signal to the WebSocket it can close the output
+onCloseCalled.join();      // Wait for onClose to be called
-TimeUnit.SECONDS.sleep(5); // Give canClose some time to reach the WebSocket
+canClose.complete(null);   // Signal to the WebSocket it can close the output
+TimeUnit.SECONDS.sleep(5); // Give canClose some time to reach the WebSocket
-assertFails(IOE, webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "ok"));
+assertFails(IOE, webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "ok"));
-assertFails(IOE, webSocket.sendText("", true));
-assertFails(IOE, webSocket.sendText("", false));
+assertFails(IOE, webSocket.sendText("", true));
-assertFails(IOE, webSocket.sendText("abc", true));
+assertFails(IOE, webSocket.sendText("", false));
-assertFails(IOE, webSocket.sendText("abc", false));
+assertFails(IOE, webSocket.sendText("abc", true));
-assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(0), true));
+assertFails(IOE, webSocket.sendText("abc", false));
-assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(0), false));
+assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(0), true));
-assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(1), true));
+assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(0), false));
-assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(1), false));
+assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(1), true));
+assertFails(IOE, webSocket.sendBinary(ByteBuffer.allocate(1), false));
-assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(125)));
-assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(124)));
+assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(125)));
-assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(1)));
+assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(124)));
-assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(0)));
+assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(1)));
+assertFails(IOE, webSocket.sendPing(ByteBuffer.allocate(0)));
-assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(125)));
-assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(124)));
+assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(125)));
-assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(1)));
+assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(124)));
-assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(0)));
+assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(1)));
+assertFails(IOE, webSocket.sendPong(ByteBuffer.allocate(0)));
-server.close();
+} finally {
+webSocket.abort();
+}
+}
 }
 // Used to verify a server requiring Authentication
 private static final String USERNAME = "chegar";
 private static final String PASSWORD = "a1b2c3";
 0x80, 0x00,                               // ]
 0x88, 0x00                                // <CLOSE>
 };
 CompletableFuture<List<byte[]>> actual = new CompletableFuture<>();
-server = serverSupplier.apply(binary);
+try (var server = serverSupplier.apply(binary)) {
 server.open();
 WebSocket.Listener listener = new WebSocket.Listener() {
 List<byte[]> collectedBytes = new ArrayList<>();
 ByteBuffer buffer = ByteBuffer.allocate(1024);
 @Override
 public CompletionStage<?> onBinary(WebSocket webSocket,
 ByteBuffer message,
 boolean last) {
 System.out.printf("onBinary(%s, %s)%n", message, last);
 webSocket.request(1);
 append(message);
 if (last) {
 buffer.flip();
 byte[] bytes = new byte[buffer.remaining()];
 buffer.get(bytes);
 buffer.clear();
 processWholeBinary(bytes);
 }
 return null;
 }
 private void append(ByteBuffer message) {
 if (buffer.remaining() < message.remaining()) {
 assert message.remaining() > 0;
 int cap = (buffer.capacity() + message.remaining()) * 2;
 ByteBuffer b = ByteBuffer.allocate(cap);
 b.put(buffer.flip());
 buffer = b;
 }
 buffer.put(message);
 }
 private void processWholeBinary(byte[] bytes) {
 String stringBytes = new String(bytes, UTF_8);
 System.out.println("processWholeBinary: " + stringBytes);
 collectedBytes.add(bytes);
 }
 @Override
 public CompletionStage<?> onClose(WebSocket webSocket,
 int statusCode,
 String reason) {
 actual.complete(collectedBytes);
 return null;
 }
 @Override
 public void onError(WebSocket webSocket, Throwable error) {
 actual.completeExceptionally(error);
 }
 };
-webSocket = newBuilder()
+var webSocket = newBuilder()
 .proxy(NO_PROXY)
 .authenticator(new WSAuthenticator())
 .build().newWebSocketBuilder()
 .buildAsync(server.getURI(), listener)
 .join();
+try {
 List<byte[]> a = actual.join();
 assertEquals(a, expected);
+} finally {
-server.close();
+webSocket.abort();
+}
+}
 }
 @Test(dataProvider = "servers")
 public void simpleAggregatingTextMessages
 (Function<int[],DummyWebSocketServer> serverSupplier)
 0x80, 0x00,                               // "
 0x88, 0x00                                // <CLOSE>
 };
 CompletableFuture<List<String>> actual = new CompletableFuture<>();
-server = serverSupplier.apply(binary);
+try (var server = serverSupplier.apply(binary)) {
 server.open();
 WebSocket.Listener listener = new WebSocket.Listener() {
 List<String> collectedStrings = new ArrayList<>();
 StringBuilder text = new StringBuilder();
 @Override
 public CompletionStage<?> onText(WebSocket webSocket,
 CharSequence message,
 boolean last) {
 System.out.printf("onText(%s, %s)%n", message, last);
 webSocket.request(1);
 text.append(message);
 if (last) {
 String str = text.toString();
 text.setLength(0);
 processWholeText(str);
 }
 return null;
 }
 private void processWholeText(String string) {
 System.out.println(string);
 collectedStrings.add(string);
 }
 @Override
 public CompletionStage<?> onClose(WebSocket webSocket,
 int statusCode,
 String reason) {
 actual.complete(collectedStrings);
 return null;
 }
 @Override
 public void onError(WebSocket webSocket, Throwable error) {
 actual.completeExceptionally(error);
 }
 };
-webSocket = newBuilder()
+var webSocket = newBuilder()
 .proxy(NO_PROXY)
 .authenticator(new WSAuthenticator())
 .build().newWebSocketBuilder()
 .buildAsync(server.getURI(), listener)
 .join();
+try {
 List<String> a = actual.join();
 assertEquals(a, expected);
+} finally {
-server.close();
+webSocket.abort();
+}
+}
 }
 /*
 * Exercises the scenario where requests for more messages are made prior to
 * completing the returned CompletionStage instances.
 0x80, 0x00,                               // "
 0x88, 0x00                                // <CLOSE>
 };
 CompletableFuture<List<String>> actual = new CompletableFuture<>();
-server = serverSupplier.apply(binary);
+try (var server = serverSupplier.apply(binary)) {
 server.open();
 WebSocket.Listener listener = new WebSocket.Listener() {
 List<CharSequence> parts = new ArrayList<>();
 /*
 * A CompletableFuture which will complete once the current
 * message has been fully assembled. Until then the listener
 * returns this instance for every call.
 */
 CompletableFuture<?> currentCf = new CompletableFuture<>();
 List<String> collected = new ArrayList<>();
 @Override
 public CompletionStage<?> onText(WebSocket webSocket,
 CharSequence message,
 boolean last) {
 parts.add(message);
 if (!last) {
 webSocket.request(1);
 } else {
 this.currentCf.thenRun(() -> webSocket.request(1));
 CompletableFuture<?> refCf = this.currentCf;
 processWholeMessage(new ArrayList<>(parts), refCf);
 currentCf = new CompletableFuture<>();
 parts.clear();
 return refCf;
 }
 return currentCf;
 }
 @Override
 public CompletionStage<?> onClose(WebSocket webSocket,
 int statusCode,
 String reason) {
 actual.complete(collected);
 return null;
 }
 @Override
 public void onError(WebSocket webSocket, Throwable error) {
 actual.completeExceptionally(error);
 }
 public void processWholeMessage(List<CharSequence> data,
 CompletableFuture<?> cf) {
 StringBuilder b = new StringBuilder();
 data.forEach(b::append);
 String s = b.toString();
 System.out.println(s);
 cf.complete(null);
 collected.add(s);
 }
 };
-webSocket = newBuilder()
+var webSocket = newBuilder()
 .proxy(NO_PROXY)
 .authenticator(new WSAuthenticator())
 .build().newWebSocketBuilder()
 .buildAsync(server.getURI(), listener)
 .join();
+try {
 List<String> a = actual.join();
 assertEquals(a, expected);
+} finally {
-server.close();
+webSocket.abort();
+}
+}
 }
 // -- authentication specific tests
 /*
 .authenticator(new WSAuthenticator())
 .build()
 .newWebSocketBuilder()
 .buildAsync(server.getURI(), new WebSocket.Listener() { })
 .join();
+webSocket.abort();
 }
 }
 /*
 * Ensures authentication succeeds when an `Authorization` header is explicitly set.
 .proxy(NO_PROXY).build()
 .newWebSocketBuilder()
 .header("Authorization", hv)
 .buildAsync(server.getURI(), new WebSocket.Listener() { })
 .join();
+webSocket.abort();
 }
 }
 /*
 * Ensures authentication does not succeed when no authenticator is present.
 .newWebSocketBuilder()
 .buildAsync(server.getURI(), new WebSocket.Listener() { });
 try {
 var webSocket = cf.join();
+silentAbort(webSocket);
 fail("Expected exception not thrown");
 } catch (CompletionException expected) {
 WebSocketHandshakeException e = (WebSocketHandshakeException)expected.getCause();
 HttpResponse<?> response = e.getResponse();
 assertEquals(response.statusCode(), 401);
 try (var server = new DummyWebSocketServer(USERNAME, PASSWORD)) {
 server.open();
 Authenticator authenticator = new Authenticator() {
 @Override protected PasswordAuthentication getPasswordAuthentication() {
-return new PasswordAuthentication("BAD"+USERNAME, "".toCharArray());
+return new PasswordAuthentication("BAD" + USERNAME, "".toCharArray());
 }
 };
 CompletableFuture<WebSocket> cf = newBuilder()
 .proxy(NO_PROXY)
 .newWebSocketBuilder()
 .buildAsync(server.getURI(), new WebSocket.Listener() { });
 try {
 var webSocket = cf.join();
+silentAbort(webSocket);
 fail("Expected exception not thrown");
 } catch (CompletionException expected) {
 System.out.println("caught expected exception:" + expected);
 }
 }
 }
+private static void silentAbort(WebSocket ws) {
+try {
+ws.abort();
+} catch (Throwable t) { }
+}
 }

changeset 58289	3a79d4cccbcb
parent 53521	41fa3e6f2785