mirrors/JetBrainsRuntime
1
0
Fork 0
mirror of https://github.com/JetBrains/JetBrainsRuntime.git synced 2025-12-06 09:29:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

8308024: HttpClient (HTTP/1.1) sends an extraneous empty chunk if the BodyPublisher supplies an empty buffer

Browse Source 
Reviewed-by: djelinski, michaelm
(cherry picked from commit 72294c5402)
This commit is contained in:
Daniel Fuchs
2023-05-16 09:13:17 +00:00
committed by Vitaly Provodin
parent 3fbc2c1dc0
commit e3c0e7b9bf
5 changed files with 416 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/java.net.http/share/classes/jdk/internal/net/http/Http1Request.java
View File

@@ -350,11 +350,18 @@ class Http1Request {
http1Exchange.appendToOutgoing(t);
} else {
int chunklen = item.remaining();
ArrayList<ByteBuffer> l = new ArrayList<>(3);
l.add(getHeader(chunklen));
l.add(item);
l.add(ByteBuffer.wrap(CRLF));
http1Exchange.appendToOutgoing(l);
if (chunklen > 0) {
ArrayList<ByteBuffer> l = new ArrayList<>(3);
l.add(getHeader(chunklen));
l.add(item);
l.add(ByteBuffer.wrap(CRLF));
http1Exchange.appendToOutgoing(l);
} else {
if (debug.on()) {
debug.log("dropping empty buffer, request one more");
}
request(1);
}
}
}

231
test/jdk/java/net/httpclient/AbstractNoBody.java
View File

@@ -21,35 +21,43 @@
* questions.
*/
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.concurrent.Executor;
import java.net.URI;
import java.net.http.HttpClient.Version;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpsConfigurator;
import com.sun.net.httpserver.HttpsServer;
import java.net.http.HttpClient;
import java.util.concurrent.atomic.AtomicLong;
import javax.net.ssl.SSLContext;
import jdk.httpclient.test.lib.http2.Http2TestServer;
import jdk.httpclient.test.lib.http2.Http2TestExchange;
import jdk.httpclient.test.lib.http2.Http2Handler;
import jdk.httpclient.test.lib.common.HttpServerAdapters;
import jdk.test.lib.net.SimpleSSLContext;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.DataProvider;
public abstract class AbstractNoBody {
import static java.lang.System.err;
import static java.lang.System.out;
import static java.net.http.HttpClient.Builder.NO_PROXY;
import static java.net.http.HttpClient.Version.HTTP_1_1;
import static java.net.http.HttpClient.Version.HTTP_2;
import static org.testng.Assert.assertEquals;
public abstract class AbstractNoBody implements HttpServerAdapters {
SSLContext sslContext;
HttpServer httpTestServer; // HTTP/1.1 [ 4 servers ]
HttpsServer httpsTestServer; // HTTPS/1.1
Http2TestServer http2TestServer; // HTTP/2 ( h2c )
Http2TestServer https2TestServer; // HTTP/2 ( h2 )
HttpTestServer httpTestServer; // HTTP/1.1 [ 4 servers ]
HttpTestServer httpsTestServer; // HTTPS/1.1
HttpTestServer http2TestServer; // HTTP/2 ( h2c )
HttpTestServer https2TestServer; // HTTP/2 ( h2 )
String httpURI_fixed;
String httpURI_chunk;
String httpsURI_fixed;
@@ -62,8 +70,17 @@ public abstract class AbstractNoBody {
static final String SIMPLE_STRING = "Hello world. Goodbye world";
static final int ITERATION_COUNT = 3;
// a shared executor helps reduce the amount of threads created by the test
static final Executor executor = Executors.newFixedThreadPool(ITERATION_COUNT * 2);
static final ExecutorService executor = Executors.newFixedThreadPool(ITERATION_COUNT * 2);
static final ExecutorService serverExecutor = Executors.newFixedThreadPool(ITERATION_COUNT * 4);
static final AtomicLong clientCount = new AtomicLong();
static final long start = System.nanoTime();
public static String now() {
long now = System.nanoTime() - start;
long secs = now / 1000_000_000;
long mill = (now % 1000_000_000) / 1000_000;
long nan = now % 1000_000;
return String.format("[%d s, %d ms, %d ns] ", secs, mill, nan);
}
@DataProvider(name = "variants")
public Object[][] variants() {
@@ -88,55 +105,86 @@ public abstract class AbstractNoBody {
};
}
HttpClient newHttpClient() {
private volatile HttpClient sharedClient;
static Version version(String uri) {
if (uri.contains("/http1/") || uri.contains("/https1/"))
return HTTP_1_1;
if (uri.contains("/http2/") || uri.contains("/https2/"))
return HTTP_2;
return null;
}
HttpRequest.Builder newRequestBuilder(String uri) {
var builder = HttpRequest.newBuilder(URI.create(uri));
return builder;
}
private HttpClient makeNewClient() {
clientCount.incrementAndGet();
return HttpClient.newBuilder()
.executor(executor)
.proxy(NO_PROXY)
.sslContext(sslContext)
.build();
}
static String serverAuthority(HttpServer server) {
return InetAddress.getLoopbackAddress().getHostName() + ":"
+ server.getAddress().getPort();
HttpClient newHttpClient(boolean share) {
if (!share) return makeNewClient();
HttpClient shared = sharedClient;
if (shared != null) return shared;
synchronized (this) {
shared = sharedClient;
if (shared == null) {
shared = sharedClient = makeNewClient();
}
return shared;
}
}
record CloseableClient(HttpClient client, boolean shared)
implements Closeable {
public void close() {
if (shared) return;
client.close();
}
}
@BeforeTest
public void setup() throws Exception {
printStamp(START, "setup");
HttpServerAdapters.enableServerLogging();
sslContext = new SimpleSSLContext().get();
if (sslContext == null)
throw new AssertionError("Unexpected null sslContext");
// HTTP/1.1
HttpHandler h1_fixedLengthNoBodyHandler = new HTTP1_FixedLengthNoBodyHandler();
HttpHandler h1_chunkNoBodyHandler = new HTTP1_ChunkedNoBodyHandler();
InetSocketAddress sa = new InetSocketAddress(InetAddress.getLoopbackAddress(), 0);
httpTestServer = HttpServer.create(sa, 0);
httpTestServer.setExecutor(serverExecutor);
httpTestServer.createContext("/http1/noBodyFixed", h1_fixedLengthNoBodyHandler);
httpTestServer.createContext("/http1/noBodyChunk", h1_chunkNoBodyHandler);
httpURI_fixed = "http://" + serverAuthority(httpTestServer) + "/http1/noBodyFixed";
httpURI_chunk = "http://" + serverAuthority(httpTestServer) + "/http1/noBodyChunk";
HttpTestHandler h1_fixedLengthNoBodyHandler = new FixedLengthNoBodyHandler();
HttpTestHandler h1_chunkNoBodyHandler = new ChunkedNoBodyHandler();
httpsTestServer = HttpsServer.create(sa, 0);
httpsTestServer.setExecutor(serverExecutor);
httpsTestServer.setHttpsConfigurator(new HttpsConfigurator(sslContext));
httpsTestServer.createContext("/https1/noBodyFixed", h1_fixedLengthNoBodyHandler);
httpsTestServer.createContext("/https1/noBodyChunk", h1_chunkNoBodyHandler);
httpsURI_fixed = "https://" + serverAuthority(httpsTestServer) + "/https1/noBodyFixed";
httpsURI_chunk = "https://" + serverAuthority(httpsTestServer) + "/https1/noBodyChunk";
httpTestServer = HttpTestServer.create(HTTP_1_1, null, serverExecutor);
httpTestServer.addHandler(h1_fixedLengthNoBodyHandler,"/http1/noBodyFixed");
httpTestServer.addHandler(h1_chunkNoBodyHandler, "/http1/noBodyChunk");
httpURI_fixed = "http://" + httpTestServer.serverAuthority() + "/http1/noBodyFixed";
httpURI_chunk = "http://" + httpTestServer.serverAuthority() + "/http1/noBodyChunk";
httpsTestServer = HttpTestServer.create(HTTP_1_1, sslContext, serverExecutor);
httpsTestServer.addHandler(h1_fixedLengthNoBodyHandler,"/https1/noBodyFixed");
httpsTestServer.addHandler(h1_chunkNoBodyHandler, "/https1/noBodyChunk");
httpsURI_fixed = "https://" + httpsTestServer.serverAuthority() + "/https1/noBodyFixed";
httpsURI_chunk = "https://" + httpsTestServer.serverAuthority() + "/https1/noBodyChunk";
// HTTP/2
Http2Handler h2_fixedLengthNoBodyHandler = new HTTP2_FixedLengthNoBodyHandler();
Http2Handler h2_chunkedNoBodyHandler = new HTTP2_ChunkedNoBodyHandler();
HttpTestHandler h2_fixedLengthNoBodyHandler = new FixedLengthNoBodyHandler();
HttpTestHandler h2_chunkedNoBodyHandler = new ChunkedNoBodyHandler();
http2TestServer = new Http2TestServer("localhost", false, 0, serverExecutor, null);
http2TestServer = HttpTestServer.create(HTTP_2, null, serverExecutor);
http2TestServer.addHandler(h2_fixedLengthNoBodyHandler, "/http2/noBodyFixed");
http2TestServer.addHandler(h2_chunkedNoBodyHandler, "/http2/noBodyChunk");
http2URI_fixed = "http://" + http2TestServer.serverAuthority() + "/http2/noBodyFixed";
http2URI_chunk = "http://" + http2TestServer.serverAuthority() + "/http2/noBodyChunk";
https2TestServer = new Http2TestServer("localhost", true, 0, serverExecutor, sslContext);
https2TestServer = HttpTestServer.create(HTTP_2, sslContext, serverExecutor);
https2TestServer.addHandler(h2_fixedLengthNoBodyHandler, "/https2/noBodyFixed");
https2TestServer.addHandler(h2_chunkedNoBodyHandler, "/https2/noBodyChunk");
https2URI_fixed = "https://" + https2TestServer.serverAuthority() + "/https2/noBodyFixed";
@@ -146,77 +194,102 @@ public abstract class AbstractNoBody {
httpsTestServer.start();
http2TestServer.start();
https2TestServer.start();
var shared = newHttpClient(true);
out.println("HTTP/1.1 server (http) listening at: " + httpTestServer.serverAuthority());
out.println("HTTP/1.1 server (TLS) listening at: " + httpsTestServer.serverAuthority());
out.println("HTTP/2 server (h2c) listening at: " + http2TestServer.serverAuthority());
out.println("HTTP/2 server (h2) listening at: " + https2TestServer.serverAuthority());
out.println("Shared client is: " + shared);
printStamp(END,"setup");
}
@AfterTest
public void teardown() throws Exception {
printStamp(START, "teardown");
httpTestServer.stop(0);
httpsTestServer.stop(0);
sharedClient.close();
httpTestServer.stop();
httpsTestServer.stop();
http2TestServer.stop();
https2TestServer.stop();
executor.close();
serverExecutor.close();
printStamp(END, "teardown");
}
static final long start = System.nanoTime();
static final String START = "start";
static final String END = "end ";
static long elapsed() { return (System.nanoTime() - start)/1000_000;}
void printStamp(String what, String fmt, Object... args) {
long elapsed = elapsed();
long sec = elapsed/1000;
long ms = elapsed % 1000;
String time = sec > 0 ? sec + "sec " : "";
time = time + ms + "ms";
System.out.printf("%s: %s \t [%s]\t %s%n",
getClass().getSimpleName(), what, time, String.format(fmt,args));
getClass().getSimpleName(), what, now(), String.format(fmt,args));
}
static class HTTP1_FixedLengthNoBodyHandler implements HttpHandler {
static class FixedLengthNoBodyHandler implements HttpTestHandler {
@Override
public void handle(HttpExchange t) throws IOException {
public void handle(HttpTestExchange t) throws IOException {
//out.println("NoBodyHandler received request to " + t.getRequestURI());
boolean echo = "echo".equals(t.getRequestURI().getRawQuery());
byte[] reqbytes;
try (InputStream is = t.getRequestBody()) {
is.readAllBytes();
reqbytes = is.readAllBytes();
}
if (echo) {
t.sendResponseHeaders(200, reqbytes.length);
if (reqbytes.length > 0) {
try (var os = t.getResponseBody()) {
os.write(reqbytes);
}
}
} else {
t.sendResponseHeaders(200, 0); // no body
}
t.sendResponseHeaders(200, -1); // no body
}
}
static class HTTP1_ChunkedNoBodyHandler implements HttpHandler {
static class ChunkedNoBodyHandler implements HttpTestHandler {
@Override
public void handle(HttpExchange t) throws IOException {
public void handle(HttpTestExchange t) throws IOException {
//out.println("NoBodyHandler received request to " + t.getRequestURI());
boolean echo = "echo".equals(t.getRequestURI().getRawQuery());
byte[] reqbytes;
try (InputStream is = t.getRequestBody()) {
is.readAllBytes();
reqbytes = is.readAllBytes();
}
if (echo) {
t.sendResponseHeaders(200, -1);
try (var os = t.getResponseBody()) {
os.write(reqbytes);
}
} else {
t.sendResponseHeaders(200, -1); // chunked
t.getResponseBody().close(); // write nothing
}
t.sendResponseHeaders(200, 0); // chunked
t.getResponseBody().close(); // write nothing
}
}
static class HTTP2_FixedLengthNoBodyHandler implements Http2Handler {
@Override
public void handle(Http2TestExchange t) throws IOException {
//out.println("NoBodyHandler received request to " + t.getRequestURI());
try (InputStream is = t.getRequestBody()) {
is.readAllBytes();
}
t.sendResponseHeaders(200, 0);
}
/*
* Converts a ByteBuffer containing bytes encoded using
* the given charset into a string.
* This method does not throw but will replace
* unrecognized sequences with the replacement character.
*/
public static String asString(ByteBuffer buffer, Charset charset) {
var decoded = charset.decode(buffer);
char[] chars = new char[decoded.length()];
decoded.get(chars);
return new String(chars);
}
static class HTTP2_ChunkedNoBodyHandler implements Http2Handler {
@Override
public void handle(Http2TestExchange t) throws IOException {
//out.println("NoBodyHandler received request to " + t.getRequestURI());
try (InputStream is = t.getRequestBody()) {
is.readAllBytes();
}
t.sendResponseHeaders(200, -1);
t.getResponseBody().close(); // write nothing
}
/*
* Converts a ByteBuffer containing UTF-8 bytes into a
* string. This method does not throw but will replace
* unrecognized sequences with the replacement character.
*/
public static String asString(ByteBuffer buffer) {
return asString(buffer, StandardCharsets.UTF_8);
}
}

75
test/jdk/java/net/httpclient/NoBodyPartOne.java
View File

@@ -33,7 +33,6 @@
* NoBodyPartOne
*/
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
@@ -44,6 +43,7 @@ import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandler;
import java.net.http.HttpResponse.BodyHandlers;
import org.testng.annotations.Test;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
@@ -55,20 +55,20 @@ public class NoBodyPartOne extends AbstractNoBody {
printStamp(START, "testAsString(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null)
client = newHttpClient();
HttpRequest req = HttpRequest.newBuilder(URI.create(uri))
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
BodyHandler<String> handler = i % 2 == 0 ? BodyHandlers.ofString()
: BodyHandlers.ofString(UTF_8);
HttpResponse<String> response = client.send(req, handler);
String body = response.body();
assertEquals(body, "");
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
HttpRequest req = newRequestBuilder(uri)
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
BodyHandler<String> handler = i % 2 == 0 ? BodyHandlers.ofString()
: BodyHandlers.ofString(UTF_8);
HttpResponse<String> response = client.send(req, handler);
String body = response.body();
assertEquals(body, "");
}
}
// We have created many clients here. Try to speed up their release.
if (!sameClient) System.gc();
}
@Test(dataProvider = "variants")
@@ -76,20 +76,22 @@ public class NoBodyPartOne extends AbstractNoBody {
printStamp(START, "testAsFile(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null)
client = newHttpClient();
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
HttpRequest req = HttpRequest.newBuilder(URI.create(uri))
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
Path p = Paths.get("NoBody_testAsFile.txt");
HttpResponse<Path> response = client.send(req, BodyHandlers.ofFile(p));
Path bodyPath = response.body();
assertTrue(Files.exists(bodyPath));
assertEquals(Files.size(bodyPath), 0);
try (var cl = new CloseableClient(client, sameClient)) {
HttpRequest req = newRequestBuilder(uri)
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
Path p = Paths.get("NoBody_testAsFile.txt");
HttpResponse<Path> response = client.send(req, BodyHandlers.ofFile(p));
Path bodyPath = response.body();
assertEquals(response.statusCode(), 200);
assertTrue(Files.exists(bodyPath));
assertEquals(Files.size(bodyPath), 0, Files.readString(bodyPath));
}
}
// We have created many clients here. Try to speed up their release.
if (!sameClient) System.gc();
}
@Test(dataProvider = "variants")
@@ -97,17 +99,18 @@ public class NoBodyPartOne extends AbstractNoBody {
printStamp(START, "testAsByteArray(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null)
client = newHttpClient();
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
HttpRequest req = HttpRequest.newBuilder(URI.create(uri))
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
HttpResponse<byte[]> response = client.send(req, BodyHandlers.ofByteArray());
byte[] body = response.body();
assertEquals(body.length, 0);
try (var cl = new CloseableClient(client, sameClient)) {
HttpRequest req = newRequestBuilder(uri)
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
HttpResponse<byte[]> response = client.send(req, BodyHandlers.ofByteArray());
byte[] body = response.body();
assertEquals(body.length, 0);
}
}
// We have created many clients here. Try to speed up their release.
if (!sameClient) System.gc();
}
}

160
test/jdk/java/net/httpclient/NoBodyPartThree.java Normal file
View File

@@ -0,0 +1,160 @@
/*
* Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8308024
* @summary Test request and response body handlers/subscribers when there is no body
* @library /test/lib /test/jdk/java/net/httpclient/lib
* @build jdk.test.lib.net.SimpleSSLContext jdk.httpclient.test.lib.http2.Http2TestServer
* @run testng/othervm
* -Djdk.httpclient.HttpClient.log=all
* NoBodyPartThree
*/
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
public class NoBodyPartThree extends AbstractNoBody {
static final AtomicInteger REQID = new AtomicInteger();
volatile boolean consumerHasBeenCalled;
@Test(dataProvider = "variants")
public void testAsByteArrayPublisher(String uri, boolean sameClient) throws Exception {
printStamp(START, "testAsByteArrayPublisher(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
var u = uri + "/testAsByteArrayPublisher/first/" + REQID.getAndIncrement();
HttpRequest req = newRequestBuilder(u + "?echo")
.PUT(BodyPublishers.ofByteArrays(List.of()))
.build();
System.out.println("sending " + req);
Consumer<Optional<byte[]>> consumer = oba -> {
consumerHasBeenCalled = true;
oba.ifPresent(ba -> fail("Unexpected non-empty optional:"
+ asString(ByteBuffer.wrap(ba))));
};
consumerHasBeenCalled = false;
var response = client.send(req, BodyHandlers.ofByteArrayConsumer(consumer));
assertTrue(consumerHasBeenCalled);
assertEquals(response.statusCode(), 200);
u = uri + "/testAsByteArrayPublisher/second/" + REQID.getAndIncrement();
req = newRequestBuilder(u + "?echo")
.PUT(BodyPublishers.ofByteArrays(List.of(new byte[0])))
.build();
System.out.println("sending " + req);
consumerHasBeenCalled = false;
response = client.send(req, BodyHandlers.ofByteArrayConsumer(consumer));
assertTrue(consumerHasBeenCalled);
assertEquals(response.statusCode(), 200);
}
}
}
@Test(dataProvider = "variants")
public void testStringPublisher(String uri, boolean sameClient) throws Exception {
printStamp(START, "testStringPublisher(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
var u = uri + "/testStringPublisher/" + REQID.getAndIncrement();
HttpRequest req = newRequestBuilder(u + "?echo")
.PUT(BodyPublishers.ofString(""))
.build();
System.out.println("sending " + req);
HttpResponse<InputStream> response = client.send(req, BodyHandlers.ofInputStream());
assertEquals(response.statusCode(), 200);
byte[] body = response.body().readAllBytes();
assertEquals(body.length, 0);
}
}
}
@Test(dataProvider = "variants")
public void testInputStreamPublisherBuffering(String uri, boolean sameClient) throws Exception {
printStamp(START, "testInputStreamPublisherBuffering(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
var u = uri + "/testInputStreamPublisherBuffering/" + REQID.getAndIncrement();
HttpRequest req = newRequestBuilder(u + "?echo")
.PUT(BodyPublishers.ofInputStream(InputStream::nullInputStream))
.build();
System.out.println("sending " + req);
HttpResponse<byte[]> response = client.send(req,
BodyHandlers.buffering(BodyHandlers.ofByteArray(), 1024));
assertEquals(response.statusCode(), 200);
byte[] body = response.body();
assertEquals(body.length, 0);
}
}
}
@Test(dataProvider = "variants")
public void testEmptyArrayPublisher(String uri, boolean sameClient) throws Exception {
printStamp(START, "testEmptyArrayPublisher(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
var u = uri + "/testEmptyArrayPublisher/" + REQID.getAndIncrement();
HttpRequest req = newRequestBuilder(u + "?echo")
.PUT(BodyPublishers.ofByteArray(new byte[0]))
.build();
System.out.println("sending " + req);
var response = client.send(req, BodyHandlers.ofLines());
assertEquals(response.statusCode(), 200);
assertEquals(response.body().toList(), List.of());
}
}
}
}

103
test/jdk/java/net/httpclient/NoBodyPartTwo.java
View File

@@ -34,7 +34,7 @@
*/
import java.io.InputStream;
import java.net.URI;
import java.nio.ByteBuffer;
import java.util.Optional;
import java.util.function.Consumer;
import java.net.http.HttpClient;
@@ -42,7 +42,9 @@ import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
@@ -55,22 +57,23 @@ public class NoBodyPartTwo extends AbstractNoBody {
printStamp(START, "testAsByteArrayConsumer(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null)
client = newHttpClient();
HttpRequest req = HttpRequest.newBuilder(URI.create(uri))
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
Consumer<Optional<byte[]>> consumer = oba -> {
consumerHasBeenCalled = true;
oba.ifPresent(ba -> fail("Unexpected non-empty optional:" + ba));
};
consumerHasBeenCalled = false;
client.send(req, BodyHandlers.ofByteArrayConsumer(consumer));
assertTrue(consumerHasBeenCalled);
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
HttpRequest req = newRequestBuilder(uri)
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
Consumer<Optional<byte[]>> consumer = oba -> {
consumerHasBeenCalled = true;
oba.ifPresent(ba -> fail("Unexpected non-empty optional: "
+ asString(ByteBuffer.wrap(ba))));
};
consumerHasBeenCalled = false;
client.send(req, BodyHandlers.ofByteArrayConsumer(consumer));
assertTrue(consumerHasBeenCalled);
}
}
// We have created many clients here. Try to speed up their release.
if (!sameClient) System.gc();
}
@Test(dataProvider = "variants")
@@ -78,18 +81,18 @@ public class NoBodyPartTwo extends AbstractNoBody {
printStamp(START, "testAsInputStream(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null)
client = newHttpClient();
HttpRequest req = HttpRequest.newBuilder(URI.create(uri))
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
HttpResponse<InputStream> response = client.send(req, BodyHandlers.ofInputStream());
byte[] body = response.body().readAllBytes();
assertEquals(body.length, 0);
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
HttpRequest req = newRequestBuilder(uri)
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
HttpResponse<InputStream> response = client.send(req, BodyHandlers.ofInputStream());
byte[] body = response.body().readAllBytes();
assertEquals(body.length, 0);
}
}
// We have created many clients here. Try to speed up their release.
if (!sameClient) System.gc();
}
@Test(dataProvider = "variants")
@@ -97,19 +100,19 @@ public class NoBodyPartTwo extends AbstractNoBody {
printStamp(START, "testBuffering(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null)
client = newHttpClient();
HttpRequest req = HttpRequest.newBuilder(URI.create(uri))
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
HttpResponse<byte[]> response = client.send(req,
BodyHandlers.buffering(BodyHandlers.ofByteArray(), 1024));
byte[] body = response.body();
assertEquals(body.length, 0);
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
HttpRequest req = newRequestBuilder(uri)
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
HttpResponse<byte[]> response = client.send(req,
BodyHandlers.buffering(BodyHandlers.ofByteArray(), 1024));
byte[] body = response.body();
assertEquals(body.length, 0);
}
}
// We have created many clients here. Try to speed up their release.
if (!sameClient) System.gc();
}
@Test(dataProvider = "variants")
@@ -117,17 +120,17 @@ public class NoBodyPartTwo extends AbstractNoBody {
printStamp(START, "testDiscard(\"%s\", %s)", uri, sameClient);
HttpClient client = null;
for (int i=0; i< ITERATION_COUNT; i++) {
if (!sameClient || client == null)
client = newHttpClient();
HttpRequest req = HttpRequest.newBuilder(URI.create(uri))
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
Object obj = new Object();
HttpResponse<Object> response = client.send(req, BodyHandlers.replacing(obj));
assertEquals(response.body(), obj);
if (!sameClient || client == null) {
client = newHttpClient(sameClient);
}
try (var cl = new CloseableClient(client, sameClient)) {
HttpRequest req = newRequestBuilder(uri)
.PUT(BodyPublishers.ofString(SIMPLE_STRING))
.build();
Object obj = new Object();
HttpResponse<Object> response = client.send(req, BodyHandlers.replacing(obj));
assertEquals(response.body(), obj);
}
}
// We have created many clients here. Try to speed up their release.
if (!sameClient) System.gc();
}
}