test/java/net/httpclient/RequestBodyTest.java

@@ -40,10 +40,11 @@
 import java.io.*;
 import java.net.URI;
 import jdk.incubator.http.HttpClient;
 import jdk.incubator.http.HttpRequest;
 import jdk.incubator.http.HttpResponse;
+import jdk.incubator.http.HttpResponse.BodyHandler;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;

@@ -51,10 +52,11 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.function.Consumer;
 import java.util.function.Supplier;
 import javax.net.ssl.SSLContext;
 import jdk.test.lib.util.FileUtils;
 import static java.nio.charset.StandardCharsets.*;
 import static java.nio.file.StandardOpenOption.*;

@@ -126,30 +128,32 @@
         for (boolean async : new boolean[] { false, true })
             for (String uri : new String[] { httpURI, httpsURI })
                 for (String file : new String[] { smallFilename, midSizedFilename })
                     for (RequestBody requestBodyType : RequestBody.values())
                         for (ResponseBody responseBodyType : ResponseBody.values())
+                            for (boolean bufferResponseBody : new boolean[] { false, true })
                             values.add(new Object[]
-                                {uri, requestBodyType, responseBodyType, file, async});
+                                    {uri, requestBodyType, responseBodyType, file, async, bufferResponseBody});
 
         return values.stream().toArray(Object[][]::new);
     }
 
     @Test(dataProvider = "exchanges")
     void exchange(String target,
                   RequestBody requestBodyType,
                   ResponseBody responseBodyType,
                   String file,
-                  boolean async)
+                  boolean async,
+                  boolean bufferResponseBody)
         throws Exception
     {
         Path filePath = Paths.get(fileroot + file);
         URI uri = new URI(target);
 
         HttpRequest request = createRequest(uri, requestBodyType, filePath);
 
-        checkResponse(client, request, requestBodyType, responseBodyType, filePath, async);
+        checkResponse(client, request, requestBodyType, responseBodyType, filePath, async, bufferResponseBody);
     }
 
     static final int DEFAULT_OFFSET = 10;
     static final int DEFAULT_LENGTH = 1000;
 

@@ -196,11 +200,12 @@
     void checkResponse(HttpClient client,
                        HttpRequest request,
                        RequestBody requestBodyType,
                        ResponseBody responseBodyType,
                        Path file,
-                       boolean async)
+                       boolean async,
+                       boolean bufferResponseBody)
         throws InterruptedException, IOException
     {
         String filename = file.toFile().getAbsolutePath();
         byte[] fileAsBytes = getFileBytes(filename);
         if (requestBodyType == RequestBody.BYTE_ARRAY_OFFSET) {

@@ -213,47 +218,61 @@
         Path tempFile = Paths.get("RequestBodyTest.tmp");
         FileUtils.deleteFileIfExistsWithRetry(tempFile);
 
         switch (responseBodyType) {
             case BYTE_ARRAY:
-                HttpResponse<byte[]> bar = getResponse(client, request, asByteArray(), async);
+                BodyHandler<byte[]> bh = asByteArray();
+                if (bufferResponseBody) bh = buffering(bh, 50);
+                HttpResponse<byte[]> bar = getResponse(client, request, bh, async);
                 assertEquals(bar.statusCode(), 200);
                 assertEquals(bar.body(), fileAsBytes);
                 break;
             case BYTE_ARRAY_CONSUMER:
                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
-                HttpResponse<Void> v = getResponse(client, request,
-                        asByteArrayConsumer(o -> consumerBytes(o, baos) ), async);
+                Consumer<Optional<byte[]>> consumer = o -> consumerBytes(o, baos);
+                BodyHandler<Void> bh1 = asByteArrayConsumer(consumer);
+                if (bufferResponseBody) bh1 = buffering(bh1, 49);
+                HttpResponse<Void> v = getResponse(client, request, bh1, async);
                 byte[] ba = baos.toByteArray();
                 assertEquals(v.statusCode(), 200);
                 assertEquals(ba, fileAsBytes);
                 break;
             case DISCARD:
                 Object o = new Object();
-                HttpResponse<Object> or = getResponse(client, request, discard(o), async);
+                BodyHandler<Object> bh2 = discard(o);
+                if (bufferResponseBody) bh2 = buffering(bh2, 51);
+                HttpResponse<Object> or = getResponse(client, request, bh2, async);
                 assertEquals(or.statusCode(), 200);
                 assertSame(or.body(), o);
                 break;
             case FILE:
-                HttpResponse<Path> fr = getResponse(client, request, asFile(tempFile), async);
+                BodyHandler<Path> bh3 = asFile(tempFile);
+                if (bufferResponseBody) bh3 = buffering(bh3, 48);
+                HttpResponse<Path> fr = getResponse(client, request, bh3, async);
                 assertEquals(fr.statusCode(), 200);
                 assertEquals(Files.size(tempFile), fileAsString.length());
                 assertEquals(Files.readAllBytes(tempFile), fileAsBytes);
                 break;
             case FILE_WITH_OPTION:
-                fr = getResponse(client, request, asFile(tempFile, CREATE_NEW, WRITE), async);
+                BodyHandler<Path> bh4 = asFile(tempFile, CREATE_NEW, WRITE);
+                if (bufferResponseBody) bh4 = buffering(bh4, 52);
+                fr = getResponse(client, request, bh4, async);
                 assertEquals(fr.statusCode(), 200);
                 assertEquals(Files.size(tempFile), fileAsString.length());
                 assertEquals(Files.readAllBytes(tempFile), fileAsBytes);
                 break;
             case STRING:
-                HttpResponse<String> sr = getResponse(client, request, asString(), async);
+                BodyHandler<String> bh5 = asString();
+                if(bufferResponseBody) bh5 = buffering(bh5, 47);
+                HttpResponse<String> sr = getResponse(client, request, bh5, async);
                 assertEquals(sr.statusCode(), 200);
                 assertEquals(sr.body(), fileAsString);
                 break;
             case STRING_WITH_CHARSET:
-                HttpResponse<String> r = getResponse(client, request, asString(StandardCharsets.UTF_8), async);
+                BodyHandler<String> bh6 = asString(StandardCharsets.UTF_8);
+                if (bufferResponseBody) bh6 = buffering(bh6, 53);
+                HttpResponse<String> r = getResponse(client, request, bh6, async);
                 assertEquals(r.statusCode(), 200);
                 assertEquals(r.body(), fileAsString);
                 break;
             default:
                 throw new AssertionError("Unknown response body:" + responseBodyType);