add test and the right pre-emptive check

Author: azkrishpy

src/main/java/software/amazon/awssdk/crt/http/HttpClientConnection.java

@@ -63,20 +63,25 @@ public HttpStream makeRequest(HttpRequest request, HttpStreamResponseHandler str
      *        requests in the meantime.
      *
      *        <p>If the request was created with an {@link HttpRequestBodyStream} and this
-     *        parameter is {@code true}, the first call to {@link HttpStreamBase#writeData}
-     *        will throw an {@link IllegalStateException}.
+     *        parameter is {@code true}, an {@link IllegalStateException} is thrown
+     *        immediately.
      * @throws CrtRuntimeException if stream creation fails
      * @return The HttpStream that represents this Request/Response Pair. It can be closed at any time during the
      *          request/response, but must be closed by the user thread making this request when it's done.
      */
     public HttpStream makeRequest(HttpRequest request, HttpStreamResponseHandler streamHandler,
-            boolean useManualDataWrites) throws CrtRuntimeException {
+            boolean useManualDataWrites) throws CrtRuntimeException, IllegalStateException {
         if (isNull()) {
             throw new IllegalStateException("HttpClientConnection has been closed, can't make requests on it.");
         }
         if (getVersion() == HttpVersion.HTTP_2) {
             throw new IllegalArgumentException("HTTP/1 only method called on an HTTP/2 connection.");
         }
+        if (useManualDataWrites && request.getBodyStream() != null) {
+            throw new IllegalStateException(
+                "Cannot use manual data writes with a body stream on an HTTP/1.1 request. "
+                + "Either remove the body stream or set useManualDataWrites to false.");
+        }
         HttpStreamBase stream = httpClientConnectionMakeRequest(getNativeHandle(),
                 request.marshalForJni(),
                 request.getBodyStream(),

src/test/java/software/amazon/awssdk/crt/test/WriteDataTest.java

@@ -12,6 +12,7 @@
 import software.amazon.awssdk.crt.http.*;
 
 import java.net.URI;
+import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.concurrent.CompletableFuture;
@@ -278,4 +279,71 @@ public void onResponseComplete(HttpStreamBase stream, int errorCode) {
         shutdownComplete.get(60, TimeUnit.SECONDS);
         CrtResource.waitForNoResources();
     }
+
+    /**
+     * Tests that makeRequest throws IllegalStateException when called with both
+     * a body stream and useManualDataWrites=true on an HTTP/1.1 connection.
+     */
+    @Test(expected = IllegalStateException.class)
+    public void testHttp1MakeRequestWithBodyStreamAndManualWrites() throws Exception {
+        skipIfAndroid();
+        skipIfLocalhostUnavailable();
+
+        URI uri = new URI(HOST + ":" + H1_TLS_PORT);
+
+        HttpRequestBodyStream bodyStream = new HttpRequestBodyStream() {
+            @Override
+            public boolean sendRequestBody(ByteBuffer bodyBytesOut) {
+                return true;
+            }
+        };
+
+        HttpHeader[] headers = new HttpHeader[]{
+            new HttpHeader("Host", uri.getHost()),
+        };
+        // Create request WITH body stream AND useManualDataWrites=true
+        HttpRequest request = new HttpRequest("PUT", "/echo", headers, bodyStream);
+
+        CompletableFuture<Void> reqCompleted = new CompletableFuture<>();
+        TestHttpResponse response = new TestHttpResponse();
+
+        CompletableFuture<Void> shutdownComplete;
+        try (HttpClientConnectionManager connPool = createConnectionPoolManager(uri, HttpVersion.HTTP_1_1)) {
+            shutdownComplete = connPool.getShutdownCompleteFuture();
+            try (HttpClientConnection conn = connPool.acquireConnection().get(60, TimeUnit.SECONDS)) {
+
+                HttpStreamResponseHandler streamHandler = new HttpStreamResponseHandler() {
+                    @Override
+                    public void onResponseHeaders(HttpStream stream, int responseStatusCode, int blockType,
+                            HttpHeader[] nextHeaders) {
+                        response.statusCode = responseStatusCode;
+                        response.headers.addAll(Arrays.asList(nextHeaders));
+                    }
+
+                    @Override
+                    public int onResponseBody(HttpStream stream, byte[] bodyBytesIn) {
+                        response.bodyBuffer.put(bodyBytesIn);
+                        return bodyBytesIn.length;
+                    }
+
+                    @Override
+                    public void onResponseComplete(HttpStream stream, int errorCode) {
+                        response.onCompleteErrorCode = errorCode;
+                        reqCompleted.complete(null);
+                    }
+                };
+
+                HttpStream stream = conn.makeRequest(request, streamHandler, true);
+                stream.activate();
+
+                stream.writeData("hello".getBytes(StandardCharsets.UTF_8), true, null);
+
+                reqCompleted.get(60, TimeUnit.SECONDS);
+                stream.close();
+            }
+        }
+
+        shutdownComplete.get(60, TimeUnit.SECONDS);
+        CrtResource.waitForNoResources();
+    }
 }