You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hc.apache.org by ol...@apache.org on 2025/01/01 12:35:42 UTC

(httpcomponents-core) branch master updated (8bfbb6f31 -> 5b748d0c3)

This is an automated email from the ASF dual-hosted git repository.

olegk pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/httpcomponents-core.git


    from 8bfbb6f31 Added more convenience methods to classic request / response builders
     new dddf73e8e Added Jetty 12 compatibility tests
     new 5b748d0c3 Minor code cleanups in the H2, HTTP1 and JSSE integration tests

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../testing/compatibility/ContainerImages.java     |  49 +++
 .../{NginxCompatIT.java => JettyCompatIT.java}     |  48 +--
 ...atTest.java => AsyncHttp2CompatNoPushTest.java} |  16 +-
 .../compatibility/nio/AsyncHttpCompatTest.java     |  52 +++
 .../hc/core5/testing/nio/H2IntegrationTest.java    | 232 ++++++----
 .../hc/core5/testing/nio/Http1IntegrationTest.java | 476 ++++++++++++++-------
 .../testing/nio/JSSEProviderIntegrationTest.java   |  40 +-
 .../src/test/resources/docker/BUILDING.txt         |  23 +
 .../src/test/resources/docker/server.p12           | Bin 0 -> 2787 bytes
 9 files changed, 659 insertions(+), 277 deletions(-)
 copy httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/{NginxCompatIT.java => JettyCompatIT.java} (67%)
 copy httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/{AsyncHttp1CompatTest.java => AsyncHttp2CompatNoPushTest.java} (79%)
 create mode 100644 httpcore5-testing/src/test/resources/docker/server.p12


(httpcomponents-core) 01/02: Added Jetty 12 compatibility tests

Posted by ol...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

olegk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/httpcomponents-core.git

commit dddf73e8ec9d6789d2c5c52a0c5325d451819c2f
Author: Oleg Kalnichevski <ol...@apache.org>
AuthorDate: Tue Dec 31 11:03:43 2024 +0100

    Added Jetty 12 compatibility tests
---
 .../testing/compatibility/ContainerImages.java     |  49 +++++++++++
 .../core5/testing/compatibility/JettyCompatIT.java |  94 +++++++++++++++++++++
 .../nio/AsyncHttp2CompatNoPushTest.java            |  76 +++++++++++++++++
 .../compatibility/nio/AsyncHttpCompatTest.java     |  52 ++++++++++++
 .../src/test/resources/docker/BUILDING.txt         |  23 +++++
 .../src/test/resources/docker/server.p12           | Bin 0 -> 2787 bytes
 6 files changed, 294 insertions(+)

diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/ContainerImages.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/ContainerImages.java
index 882d53d61..ae402e73f 100644
--- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/ContainerImages.java
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/ContainerImages.java
@@ -26,12 +26,15 @@
  */
 package org.apache.hc.core5.testing.compatibility;
 
+import java.util.Random;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.output.Slf4jLogConsumer;
 import org.testcontainers.images.builder.ImageFromDockerfile;
+import org.testcontainers.images.builder.Transferable;
 import org.testcontainers.utility.DockerImageName;
 
 public final class ContainerImages {
@@ -47,11 +50,23 @@ public final class ContainerImages {
     public static final String NGINX = "test-nginx";
     public static final String HTTPBIN = "test-httpbin";
     public static final String DANTE = "test-dante";
+    public static final String JETTY = "test-jetty";
 
     public static int HTTP_PORT = 80;
     public static int H2C_PORT = 81;
     public static int HTTPS_PORT = 443;
     public static int SOCKS_PORT = 1080;
+    public static int HTTP_EXT_PORT = 8080;
+    public static int HTTPS_EXT_PORT = 8443;
+
+    static byte[] blob() {
+        final Random random = new Random(System.currentTimeMillis());
+        final byte[] bytes = new byte[5 * 1024 * 1024 + random.nextInt(102400)];
+        for (int i = 0; i < bytes.length; i++) {
+            bytes[i] = (byte) ('0' + random.nextInt(10));
+        }
+        return bytes;
+    }
 
     public static GenericContainer<?> httpBin(final Network network) {
         return new GenericContainer<>(DockerImageName.parse("kennethreitz/httpbin:latest"))
@@ -72,6 +87,7 @@ public final class ContainerImages {
                 .withFileFromString("aaa", AAA)
                 .withFileFromString("bbb", BBB)
                 .withFileFromString("ccc", CCC)
+                .withFileFromTransferable("blob", Transferable.of(blob()))
                 .withDockerfileFromBuilder(builder -> builder
                         .from("httpd:2.4")
                         .env("var_dir", "/var/httpd")
@@ -95,6 +111,7 @@ public final class ContainerImages {
                         .copy("aaa", "${www_dir}/")
                         .copy("bbb", "${www_dir}/")
                         .copy("ccc", "${www_dir}/")
+                        .copy("blob", "${www_dir}/")
                         .build()))
                 .withNetwork(network)
                 .withNetworkAliases(APACHE_HTTPD)
@@ -113,6 +130,7 @@ public final class ContainerImages {
                 .withFileFromString("aaa", AAA)
                 .withFileFromString("bbb", BBB)
                 .withFileFromString("ccc", CCC)
+                .withFileFromTransferable("blob", Transferable.of(blob()))
                 .withDockerfileFromBuilder(builder -> builder
                         .from("nginx:1.23")
                         .env("var_dir", "/var/nginx")
@@ -127,6 +145,7 @@ public final class ContainerImages {
                         .copy("aaa", "${www_dir}/")
                         .copy("bbb", "${www_dir}/")
                         .copy("ccc", "${www_dir}/")
+                        .copy("blob", "${www_dir}/")
                         .build()))
                 .withNetwork(network)
                 .withNetworkAliases(NGINX)
@@ -147,4 +166,34 @@ public final class ContainerImages {
                 .withExposedPorts(SOCKS_PORT);
     }
 
+    public static GenericContainer<?> jetty(final Network network) {
+        return new GenericContainer<>(new ImageFromDockerfile()
+                .withFileFromClasspath("server.p12", "docker/server.p12")
+                .withFileFromString("aaa", AAA)
+                .withFileFromString("bbb", BBB)
+                .withFileFromString("ccc", CCC)
+                .withFileFromTransferable("blob", Transferable.of(blob()))
+                .withDockerfileFromBuilder(builder -> builder
+                        .from("jetty:12.0-jdk17-amazoncorretto")
+                        .env("jetty_base", "/var/lib/jetty/")
+                        .env("webapp_root", "${jetty_base}/webapps/ROOT")
+                        .env("uid", "jetty")
+                        .user("root")
+                        .copy("server.p12", "${jetty_base}/etc/keystore.p12")
+                        .run("echo 'jetty.sslContext.keyStorePassword=nopassword' >> ${jetty_base}/start.d/ssl.ini")
+                        .run("mkdir -p ${webapp_root}/")
+                        .copy("aaa", "${webapp_root}/")
+                        .copy("bbb", "${webapp_root}/")
+                        .copy("ccc", "${webapp_root}/")
+                        .copy("blob", "${webapp_root}/")
+                        .run("chown -R ${uid}:${uid} ${jetty_base}/")
+                        .user("${uid}:${uid}")
+                        .run("java -jar ${JETTY_HOME}/start.jar --add-modules=http2 --add-modules=ee10-deploy --approve-all-licenses")
+                        .build()))
+                .withNetwork(network)
+                .withNetworkAliases(JETTY)
+                .withLogConsumer(new Slf4jLogConsumer(LOG))
+                .withExposedPorts(HTTP_EXT_PORT, HTTPS_EXT_PORT);
+    }
+
 }
diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/JettyCompatIT.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/JettyCompatIT.java
new file mode 100644
index 000000000..2a34b0b7f
--- /dev/null
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/JettyCompatIT.java
@@ -0,0 +1,94 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.hc.core5.testing.compatibility;
+
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.URIScheme;
+import org.apache.hc.core5.http2.HttpVersionPolicy;
+import org.apache.hc.core5.testing.compatibility.classic.ClassicHttpCompatTest;
+import org.apache.hc.core5.testing.compatibility.nio.AsyncHttp1CompatTest;
+import org.apache.hc.core5.testing.compatibility.nio.AsyncHttp2CompatNoPushTest;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+@Testcontainers(disabledWithoutDocker = true)
+class JettyCompatIT {
+
+    private static Network NETWORK = Network.newNetwork();
+    @Container
+    static final GenericContainer<?> JETTY_CONTAINER = ContainerImages.jetty(NETWORK);
+
+    @AfterAll
+    static void cleanup() {
+        JETTY_CONTAINER.close();
+    }
+
+    static HttpHost targetContainerHost() {
+        return new HttpHost(URIScheme.HTTP.id, JETTY_CONTAINER.getHost(), JETTY_CONTAINER.getMappedPort(ContainerImages.HTTP_EXT_PORT));
+    }
+
+    static HttpHost targetContainerTLSHost() {
+        return new HttpHost(URIScheme.HTTPS.id, JETTY_CONTAINER.getHost(), JETTY_CONTAINER.getMappedPort(ContainerImages.HTTPS_EXT_PORT));
+    }
+
+    @Nested
+    @DisplayName("Classic, HTTP/1, plain")
+    class ClassicHttp1 extends ClassicHttpCompatTest {
+
+        public ClassicHttp1() throws Exception {
+            super(targetContainerHost());
+        }
+
+    }
+
+    @Nested
+    @DisplayName("Async, HTTP/1, plain")
+    class AsyncHttp1 extends AsyncHttp1CompatTest {
+
+        public AsyncHttp1() throws Exception {
+            super(targetContainerHost());
+        }
+
+    }
+
+    @Nested
+    @DisplayName("Async, HTTP/2, TLS")
+    class AsyncHttp2Tls extends AsyncHttp2CompatNoPushTest {
+
+        public AsyncHttp2Tls() throws Exception {
+            super(targetContainerTLSHost(), HttpVersionPolicy.FORCE_HTTP_2);
+        }
+
+    }
+
+}
diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttp2CompatNoPushTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttp2CompatNoPushTest.java
new file mode 100644
index 000000000..b39efee0c
--- /dev/null
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttp2CompatNoPushTest.java
@@ -0,0 +1,76 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.hc.core5.testing.compatibility.nio;
+
+import java.util.function.Consumer;
+
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http2.HttpVersionPolicy;
+import org.apache.hc.core5.http2.config.H2Config;
+import org.apache.hc.core5.http2.impl.nio.bootstrap.H2AsyncRequester;
+import org.apache.hc.core5.http2.impl.nio.bootstrap.H2RequesterBootstrap;
+import org.apache.hc.core5.http2.ssl.H2ClientTlsStrategy;
+import org.apache.hc.core5.reactor.IOReactorConfig;
+import org.apache.hc.core5.testing.compatibility.TLSTestContexts;
+import org.apache.hc.core5.testing.extension.nio.H2AsyncRequesterResource;
+import org.apache.hc.core5.util.Timeout;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+public abstract class AsyncHttp2CompatNoPushTest extends AsyncHttpCompatTest<H2AsyncRequester> {
+
+    static final Timeout TIMEOUT = Timeout.ofSeconds(5);
+
+    private final HttpHost target;
+    @RegisterExtension
+    private final H2AsyncRequesterResource clientResource;
+
+    public AsyncHttp2CompatNoPushTest(final HttpHost target, final HttpVersionPolicy versionPolicy) {
+        super(target);
+        this.target = target;
+        this.clientResource = new H2AsyncRequesterResource();
+        this.clientResource.configure(bootstrap -> bootstrap
+                .setIOReactorConfig(IOReactorConfig.custom()
+                        .setSoTimeout(TIMEOUT)
+                        .build())
+                .setH2Config(H2Config.custom()
+                        .setPushEnabled(true)
+                        .build())
+                .setTlsStrategy(new H2ClientTlsStrategy(TLSTestContexts.createClientSSLContext()))
+                .setVersionPolicy(versionPolicy));
+    }
+
+    void configure(final Consumer<H2RequesterBootstrap> customizer) {
+        clientResource.configure(customizer);
+    }
+
+    @Override
+    H2AsyncRequester client() {
+        return clientResource.start();
+    }
+
+}
diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java
index 3107316c8..d87c5f12b 100644
--- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java
@@ -168,4 +168,56 @@ public abstract class AsyncHttpCompatTest<T extends HttpAsyncRequester> {
         }
     }
 
+    @Test
+    void test_multiple_request_execution_large_blob() throws Exception {
+        final HttpAsyncRequester client = client();
+        final Future<AsyncClientEndpoint> connectFuture = client.connect(target, TIMEOUT, null, null);
+        final AsyncClientEndpoint endpoint = connectFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
+        try {
+            final int n = 20;
+            final CountDownLatch countDownLatch = new CountDownLatch(n);
+            final Queue<Result<String>> resultQueue = new ConcurrentLinkedQueue<>();
+            for (int i = 0; i < n; i++) {
+                final HttpRequest httpget = new BasicHttpRequest(Method.GET, target, "/blob");
+                endpoint.execute(
+                        new BasicRequestProducer(httpget, null),
+                        new BasicResponseConsumer<>(new StringAsyncEntityConsumer()),
+                        new FutureCallback<Message<HttpResponse, String>>() {
+
+                            @Override
+                            public void completed(final Message<HttpResponse, String> responseMessage) {
+                                resultQueue.add(new Result<>(
+                                        httpget,
+                                        responseMessage.getHead(),
+                                        responseMessage.getBody()));
+                                countDownLatch.countDown();
+                            }
+
+                            @Override
+                            public void failed(final Exception ex) {
+                                resultQueue.add(new Result<>(httpget, ex));
+                                countDownLatch.countDown();
+                            }
+
+                            @Override
+                            public void cancelled() {
+                                failed(new RequestNotExecutedException());
+                            }
+
+                        });
+            }
+            Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time");
+            for (final Result<String> result : resultQueue) {
+                if (result.isOK()) {
+                    Assertions.assertNotNull(result.response);
+                    Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status");
+                } else {
+                    Assertions.fail(result.exception);
+                }
+            }
+        } finally {
+            endpoint.releaseAndDiscard();
+        }
+    }
+
 }
diff --git a/httpcore5-testing/src/test/resources/docker/BUILDING.txt b/httpcore5-testing/src/test/resources/docker/BUILDING.txt
index 8896f184f..0e5664f7f 100644
--- a/httpcore5-testing/src/test/resources/docker/BUILDING.txt
+++ b/httpcore5-testing/src/test/resources/docker/BUILDING.txt
@@ -22,8 +22,31 @@ openssl ca -config test-CA/openssl.cnf -days 36500 \
  && rm httpcore5-testing/src/test/resources/docker/server-certreq.pem
 ---
 
+# Export the certificate and the key into P12 store
+
+---
+openssl pkcs12 -export -out httpcore5-testing/src/test/resources/docker/server.p12 \
+ -CAfile test-CA/ca-cert.pem \
+ -in httpcore5-testing/src/test/resources/docker/server-cert.pem \
+ -inkey httpcore5-testing/src/test/resources/docker/server-key.pem \
+ -passin pass:nopassword -passout pass:nopassword
+---
+
+# Verify the P12 store
+
+---
+openssl pkcs12 -info -in httpcore5-testing/src/test/resources/docker/server.p12 \
+ -passin pass:nopassword -passout pass:nopassword
+---
+
+---
+keytool -list -keystore httpcore5-testing/src/test/resources/docker/server.p12 -storepass nopassword
+---
+
 # Create JKS store with the Test CA cert
+---
 keytool -import -trustcacerts -alias test-ca -file test-CA/ca-cert.pem -keystore httpcore5-testing/src/test/resources/test-ca.jks -storepass nopassword
+---
 
 = Running a local version of HttpBin
 
diff --git a/httpcore5-testing/src/test/resources/docker/server.p12 b/httpcore5-testing/src/test/resources/docker/server.p12
new file mode 100644
index 000000000..a0410eaee
Binary files /dev/null and b/httpcore5-testing/src/test/resources/docker/server.p12 differ


(httpcomponents-core) 02/02: Minor code cleanups in the H2, HTTP1 and JSSE integration tests

Posted by ol...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

olegk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/httpcomponents-core.git

commit 5b748d0c36ebe1172e40120f7a5bc5a0efd00e51
Author: Oleg Kalnichevski <ol...@apache.org>
AuthorDate: Wed Jan 1 12:31:07 2025 +0100

    Minor code cleanups in the H2, HTTP1 and JSSE integration tests
---
 .../hc/core5/testing/nio/H2IntegrationTest.java    | 232 ++++++----
 .../hc/core5/testing/nio/Http1IntegrationTest.java | 476 ++++++++++++++-------
 .../testing/nio/JSSEProviderIntegrationTest.java   |  40 +-
 3 files changed, 517 insertions(+), 231 deletions(-)

diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java
index e34f6e972..514b98b47 100644
--- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java
@@ -38,8 +38,6 @@ import java.io.InterruptedIOException;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.net.InetSocketAddress;
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
@@ -104,6 +102,7 @@ import org.apache.hc.core5.http.nio.support.classic.AbstractClassicServerExchang
 import org.apache.hc.core5.http.protocol.DefaultHttpProcessor;
 import org.apache.hc.core5.http.protocol.HttpContext;
 import org.apache.hc.core5.http.protocol.HttpCoreContext;
+import org.apache.hc.core5.http.support.BasicRequestBuilder;
 import org.apache.hc.core5.http2.H2Error;
 import org.apache.hc.core5.http2.H2StreamResetException;
 import org.apache.hc.core5.http2.config.H2Config;
@@ -143,12 +142,8 @@ abstract class H2IntegrationTest {
         resources.client().configure(H2Config.DEFAULT);
     }
 
-    private URI createRequestURI(final InetSocketAddress serverEndpoint, final String path) {
-        try {
-            return new URI(scheme.id, null, "localhost", serverEndpoint.getPort(), path, null, null);
-        } catch (final URISyntaxException e) {
-            throw new IllegalStateException();
-        }
+    private HttpHost target(final InetSocketAddress serverEndpoint) {
+        return new HttpHost(scheme.id, null, "localhost", serverEndpoint.getPort());
     }
 
     @Test
@@ -159,15 +154,20 @@ abstract class H2IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 10; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
 
         }
@@ -191,14 +191,19 @@ abstract class H2IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.head()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.HEAD, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
             Assertions.assertNotNull(result);
@@ -217,17 +222,26 @@ abstract class H2IntegrationTest {
         server.register("/", () -> new MultiLineResponseHandler("0123456789abcdef", 5000));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/"), null),
+                new BasicRequestProducer(request1, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
 
+        final BasicHttpRequest request2 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/")
+                .build();
         final Future<Message<HttpResponse, String>> future2 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/")),
+                new BasicRequestProducer(request2, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer(512)), null);
 
         final Message<HttpResponse, String> result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
@@ -263,14 +277,18 @@ abstract class H2IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 10; i++) {
-            final HttpRequest request = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             queue.add(streamEndpoint.execute(
                     new BasicRequestProducer(request, new StringAsyncEntityProducer("Hi there", ContentType.TEXT_PLAIN)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
@@ -296,14 +314,18 @@ abstract class H2IntegrationTest {
         server.register("*", () -> new EchoHandler(2048));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/echo"),
-                        new MultiLineEntityProducer("0123456789abcdef", 5000)),
+                new BasicRequestProducer(request, new MultiLineEntityProducer("0123456789abcdef", 5000)),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
         final Message<HttpResponse, String> result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
         Assertions.assertNotNull(result1);
@@ -326,17 +348,23 @@ abstract class H2IntegrationTest {
         server.register("/", () -> new MultiLineResponseHandler("0123456789abcd", 3));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(H2Config.custom()
                 .setInitialWindowSize(16)
                 .build());
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/")
+                .build();
+
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/"), null),
+                new BasicRequestProducer(request, null),
                 new BasicResponseConsumer<>(new AbstractClassicEntityConsumer<String>(16, Executors.newSingleThreadExecutor()) {
 
                     @Override
@@ -382,12 +410,17 @@ abstract class H2IntegrationTest {
         server.register("*", () -> new EchoHandler(2048));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/echo")
+                .build();
+
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, new AbstractClassicEntityProducer(4096, ContentType.TEXT_PLAIN, Executors.newSingleThreadExecutor()) {
 
@@ -477,16 +510,21 @@ abstract class H2IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(H2Config.custom()
                 .setInitialWindowSize(512)
                 .build());
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
+
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcd", 2000)),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -526,6 +564,8 @@ abstract class H2IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(H2Config.custom()
                 .setPushEnabled(true)
                 .build());
@@ -533,14 +573,18 @@ abstract class H2IntegrationTest {
 
         final BlockingQueue<Message<HttpResponse, String>> pushMessageQueue = new LinkedBlockingDeque<>();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
+
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                new BasicRequestProducer(request, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()),
-                (request, context) -> new AbstractAsyncPushHandler<Message<HttpResponse, String>>(new BasicResponseConsumer<>(new StringAsyncEntityConsumer())) {
+                (r, c) -> new AbstractAsyncPushHandler<Message<HttpResponse, String>>(new BasicResponseConsumer<>(new StringAsyncEntityConsumer())) {
 
                     @Override
                     protected void handleResponse(
@@ -627,17 +671,23 @@ abstract class H2IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(H2Config.custom()
                 .setPushEnabled(true)
                 .build());
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
+
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                new BasicRequestProducer(request1, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
         final Message<HttpResponse, String> result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
         Assertions.assertNotNull(result1);
@@ -669,18 +719,22 @@ abstract class H2IntegrationTest {
                 .build());
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(H2Config.custom()
                 .setMaxConcurrentStreams(20)
                 .build());
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, Void>>> queue = new LinkedList<>();
         for (int i = 0; i < 2000; i++) {
-            final HttpRequest request1 = new BasicHttpRequest(Method.GET, createRequestURI(serverEndpoint, "/"));
+            final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/")
+                    .build();
             final Future<Message<HttpResponse, Void>> future = streamEndpoint.execute(
                     new BasicRequestProducer(request1, null),
                     new BasicResponseConsumer<>(new DiscardingEntityConsumer<>()), null);
@@ -738,13 +792,18 @@ abstract class H2IntegrationTest {
             }
         });
         final InetSocketAddress serverEndpoint = server.start();
+
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
-        request1.addHeader("password", "secret");
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/echo")
+                .addHeader("password", "secret")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcdef", 5000)),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -753,9 +812,12 @@ abstract class H2IntegrationTest {
         final HttpResponse response1 = result1.getHead();
         Assertions.assertNotNull(response1);
         Assertions.assertEquals(200, response1.getCode());
-        Assertions.assertNotNull("All is well", result1.getBody());
+        Assertions.assertEquals("All is well", result1.getBody());
 
-        final HttpRequest request2 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+        final BasicHttpRequest request2 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/echo")
+                .build();
         final Future<Message<HttpResponse, String>> future2 = streamEndpoint.execute(
                 new BasicRequestProducer(request2, new MultiLineEntityProducer("0123456789abcdef", 5000)),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -764,7 +826,7 @@ abstract class H2IntegrationTest {
         final HttpResponse response2 = result2.getHead();
         Assertions.assertNotNull(response2);
         Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response2.getCode());
-        Assertions.assertNotNull("You shall not pass", result2.getBody());
+        Assertions.assertEquals("You shall not pass", result2.getBody());
     }
 
     @Test
@@ -835,12 +897,16 @@ abstract class H2IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/echo")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcdef", 5000)),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -880,13 +946,17 @@ abstract class H2IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.GET, createRequestURI(serverEndpoint, "/hello"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         final DigestingEntityConsumer<String> entityConsumer = new DigestingEntityConsumer<>("MD5", new StringAsyncEntityConsumer());
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, null),
@@ -918,17 +988,22 @@ abstract class H2IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final int n = 10;
         final CountDownLatch latch = new CountDownLatch(n);
         final AtomicInteger count = new AtomicInteger(0);
         for (int i = 0; i < n; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             streamEndpoint.execute(
-                    new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             streamEndpoint.execute(new PingCommand(new BasicPingHandler(result -> {
                 if (result) {
@@ -950,13 +1025,17 @@ abstract class H2IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
         final Future<IOSession> sessionFuture = client.requestSession(new HttpHost("localhost", serverEndpoint.getPort()), TIMEOUT, null);
         final IOSession session = sessionFuture.get();
         try (final ClientSessionEndpoint streamEndpoint = new ClientSessionEndpoint(session)) {
-
-            final HttpRequest request = new BasicHttpRequest(Method.GET, createRequestURI(serverEndpoint, "/hello"));
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             request.addHeader(HttpHeaders.CONNECTION, HeaderElements.CLOSE);
             final HttpCoreContext context = HttpCoreContext.create();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
@@ -983,15 +1062,19 @@ abstract class H2IntegrationTest {
                 .build());
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.GET, createRequestURI(serverEndpoint, "/hello"));
-        request1.setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
-                "1234567890123456789012345678901234567890");
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
+                        "1234567890123456789012345678901234567890")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -1013,17 +1096,22 @@ abstract class H2IntegrationTest {
                 .setMaxHeaderListSize(100)
                 .build());
         final InetSocketAddress serverEndpoint = server.start();
+
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(
                 new DefaultHttpProcessor(H2RequestContent.INSTANCE, H2RequestTargetHost.INSTANCE, H2RequestConnControl.INSTANCE));
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
-        request1.setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
-                "1234567890123456789012345678901234567890");
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
+                        "1234567890123456789012345678901234567890")
+                .build();
 
         final byte[] b = new byte[2048];
         for (int i = 0; i < b.length; i++) {
diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java
index 945dde1eb..5665aa7aa 100644
--- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java
@@ -38,8 +38,6 @@ import java.io.InterruptedIOException;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.net.InetSocketAddress;
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.nio.ByteBuffer;
 import java.nio.channels.WritableByteChannel;
 import java.nio.charset.Charset;
@@ -124,6 +122,7 @@ import org.apache.hc.core5.http.protocol.RequestConnControl;
 import org.apache.hc.core5.http.protocol.RequestContent;
 import org.apache.hc.core5.http.protocol.RequestTargetHost;
 import org.apache.hc.core5.http.protocol.RequestValidateHost;
+import org.apache.hc.core5.http.support.BasicRequestBuilder;
 import org.apache.hc.core5.reactor.IOSession;
 import org.apache.hc.core5.reactor.ProtocolIOSession;
 import org.apache.hc.core5.testing.SSLTestContexts;
@@ -151,12 +150,8 @@ abstract class Http1IntegrationTest {
         this.resources = new Http1TestResources(scheme, TIMEOUT);
     }
 
-    private URI createRequestURI(final InetSocketAddress serverEndpoint, final String path) {
-        try {
-            return new URI(scheme.id, null, "localhost", serverEndpoint.getPort(), path, null, null);
-        } catch (final URISyntaxException e) {
-            throw new IllegalStateException();
-        }
+    private HttpHost target(final InetSocketAddress serverEndpoint) {
+        return new HttpHost(scheme.id, null, "localhost", serverEndpoint.getPort());
     }
 
     @Test
@@ -167,14 +162,19 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
             Assertions.assertNotNull(result);
@@ -194,14 +194,16 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final URI requestURI = createRequestURI(serverEndpoint, "/hello");
         for (int i = 0; i < 5; i++) {
-            final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                    "localhost", serverEndpoint.getPort(), TIMEOUT);
+            final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
             try (final ClientSessionEndpoint streamEndpoint = connectFuture.get()) {
                 final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                        AsyncRequestBuilder.get(requestURI)
+                        AsyncRequestBuilder.get()
+                                .setHttpHost(target)
+                                .setPath("/hello")
                                 .addHeader(HttpHeaders.CONNECTION, "close")
                                 .build(),
                         new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -225,6 +227,8 @@ abstract class Http1IntegrationTest {
         server.configure(new DefaultHttpProcessor(new RequestValidateHost()));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
         final int reqNo = 5;
@@ -233,8 +237,12 @@ abstract class Http1IntegrationTest {
             final Future<ClientSessionEndpoint> connectFuture = client.connect("localhost", serverEndpoint.getPort(), TIMEOUT);
             final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
 
@@ -259,6 +267,8 @@ abstract class Http1IntegrationTest {
         server.configure(new DefaultHttpProcessor(new RequestValidateHost()));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
         final int reqNo = 5;
@@ -267,10 +277,12 @@ abstract class Http1IntegrationTest {
             final Future<ClientSessionEndpoint> connectFuture = client.connect("localhost", serverEndpoint.getPort(), TIMEOUT);
             final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST,
-                            createRequestURI(serverEndpoint, "/hello"),
-                            new MultiLineEntityProducer("Hello", 16 * i)),
+                    new BasicRequestProducer(request, new MultiLineEntityProducer("Hello", 16 * i)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
 
@@ -294,6 +306,8 @@ abstract class Http1IntegrationTest {
         server.configure(new DefaultHttpProcessor(new RequestValidateHost()));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
         final int reqNo = 5;
@@ -302,10 +316,12 @@ abstract class Http1IntegrationTest {
             final Future<ClientSessionEndpoint> connectFuture = client.connect("localhost", serverEndpoint.getPort(), TIMEOUT);
             final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST,
-                            createRequestURI(serverEndpoint, "/hello"),
-                            new MultiLineEntityProducer("Hello", 16 * i)),
+                    new BasicRequestProducer(request, new MultiLineEntityProducer("Hello", 16 * i)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
 
@@ -328,15 +344,20 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
         }
         while (!queue.isEmpty()) {
@@ -359,13 +380,18 @@ abstract class Http1IntegrationTest {
         server.register("/", () -> new MultiLineResponseHandler("0123456789abcdef", 5000));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/")),
+                new BasicRequestProducer(request1, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
 
         final Message<HttpResponse, String> result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
@@ -380,8 +406,12 @@ abstract class Http1IntegrationTest {
             Assertions.assertEquals("0123456789abcdef", t1.nextToken());
         }
 
+        final BasicHttpRequest request2 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/")
+                .build();
         final Future<Message<HttpResponse, String>> future2 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/")),
+                new BasicRequestProducer(request2, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer(512)), null);
 
         final Message<HttpResponse, String> result2 = future2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
@@ -405,15 +435,20 @@ abstract class Http1IntegrationTest {
         server.register("/", () -> new MultiLineResponseHandler("0123456789abcdef", 2000));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
         }
         while (!queue.isEmpty()) {
@@ -440,15 +475,19 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/hello"),
-                            AsyncEntityProducers.create("Hi there")),
+                    new BasicRequestProducer(request, AsyncEntityProducers.create("Hi there")),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
             Assertions.assertNotNull(result);
@@ -468,16 +507,20 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/hello"),
-                            AsyncEntityProducers.create("Hi there")),
+                    new BasicRequestProducer(request, AsyncEntityProducers.create("Hi there")),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
         }
         while (!queue.isEmpty()) {
@@ -500,13 +543,17 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 5; i++) {
-            final HttpRequest request = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             request.setVersion(HttpVersion.HTTP_1_0);
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
                     new BasicRequestProducer(request, AsyncEntityProducers.create("Hi there")),
@@ -529,12 +576,16 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
+        final BasicHttpRequest request = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         request.setVersion(HttpVersion.HTTP_1_0);
         final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
                 new BasicRequestProducer(request, new BasicAsyncEntityProducer(new byte[] {'a', 'b', 'c'}, null, true)),
@@ -551,13 +602,17 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 5; i++) {
-            final HttpRequest request = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
                     new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -579,15 +634,19 @@ abstract class Http1IntegrationTest {
         server.register("*", () -> new EchoHandler(2048));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/echo"),
-                            new MultiLineEntityProducer("0123456789abcdef", 5000)),
+                    new BasicRequestProducer(request, new MultiLineEntityProducer("0123456789abcdef", 5000)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
             Assertions.assertNotNull(result);
@@ -611,16 +670,20 @@ abstract class Http1IntegrationTest {
         server.register("/", () -> new MultiLineResponseHandler("0123456789abcdef", 2000));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 2; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/"),
-                            AsyncEntityProducers.create("Hi there")),
+                    new BasicRequestProducer(request, AsyncEntityProducers.create("Hi there")),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
         }
         while (!queue.isEmpty()) {
@@ -648,16 +711,20 @@ abstract class Http1IntegrationTest {
         server.register("*", () -> new EchoHandler(2048));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/echo"),
-                            new MultiLineEntityProducer("0123456789abcdef", 5000)),
+                    new BasicRequestProducer(request, new MultiLineEntityProducer("0123456789abcdef", 5000)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
         }
         while (!queue.isEmpty()) {
@@ -684,14 +751,19 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.head()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.HEAD, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
             Assertions.assertNotNull(result);
@@ -710,14 +782,17 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final URI requestURI = createRequestURI(serverEndpoint, "/hello");
         for (int i = 0; i < 5; i++) {
             final Future<ClientSessionEndpoint> connectFuture = client.connect(
                     "localhost", serverEndpoint.getPort(), TIMEOUT);
             try (final ClientSessionEndpoint streamEndpoint = connectFuture.get()) {
                 final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                        AsyncRequestBuilder.head(requestURI)
+                        AsyncRequestBuilder.head()
+                                .setHttpHost(target)
+                                .setPath("/hello")
                                 .addHeader(HttpHeaders.CONNECTION, "close")
                                 .build(),
                         new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -739,15 +814,20 @@ abstract class Http1IntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.head()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.HEAD, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
         }
         while (!queue.isEmpty()) {
@@ -791,14 +871,19 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
         final Future<IOSession> sessionFuture = client.requestSession(
                 new HttpHost("localhost", serverEndpoint.getPort()), TIMEOUT, null);
         final IOSession ioSession = sessionFuture.get();
         try (final ClientSessionEndpoint streamEndpoint = new ClientSessionEndpoint(ioSession)) {
 
-            final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
-            request1.addHeader("password", "secret");
+            final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .addHeader("password", "secret")
+                    .build();
             final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                     new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcdef", 1000)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -811,7 +896,10 @@ abstract class Http1IntegrationTest {
 
             Assertions.assertTrue(ioSession.isOpen());
 
-            final HttpRequest request2 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+            final BasicHttpRequest request2 = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .build();
             final Future<Message<HttpResponse, String>> future2 = streamEndpoint.execute(
                     new BasicRequestProducer(request2, new MultiLineEntityProducer("0123456789abcdef", 5000)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -824,8 +912,11 @@ abstract class Http1IntegrationTest {
 
             Assertions.assertTrue(ioSession.isOpen());
 
-            final HttpRequest request3 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
-            request3.addHeader("password", "secret");
+            final BasicHttpRequest request3 = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .addHeader("password", "secret")
+                    .build();
             final Future<Message<HttpResponse, String>> future3 = streamEndpoint.execute(
                     new BasicRequestProducer(request3, new MultiLineEntityProducer("0123456789abcdef", 1000)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -838,7 +929,10 @@ abstract class Http1IntegrationTest {
 
             Assertions.assertTrue(ioSession.isOpen());
 
-            final HttpRequest request4 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+            final BasicHttpRequest request4 = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .build();
             final Future<Message<HttpResponse, String>> future4 = streamEndpoint.execute(
                     new BasicRequestProducer(request4, AsyncEntityProducers.create("blah")),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -885,13 +979,18 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
         final Future<IOSession> sessionFuture = client.requestSession(
                 new HttpHost("localhost", serverEndpoint.getPort()), TIMEOUT, null);
         final IOSession ioSession = sessionFuture.get();
         try (final ClientSessionEndpoint streamEndpoint = new ClientSessionEndpoint(ioSession)) {
 
-            final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+            final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .build();
             final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                     new BasicRequestProducer(request1, new MultiBinEntityProducer(
                             new byte[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'},
@@ -903,7 +1002,7 @@ abstract class Http1IntegrationTest {
             final HttpResponse response1 = result1.getHead();
             Assertions.assertNotNull(response1);
             Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode());
-            Assertions.assertNotNull("You shall not pass", result1.getBody());
+            Assertions.assertEquals("You shall not pass", result1.getBody());
 
             Assertions.assertFalse(streamEndpoint.isOpen());
         }
@@ -994,20 +1093,24 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(Http1Config.custom()
                 .setWaitForContinueTimeout(Timeout.ofMilliseconds(100))
                 .build());
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         final Queue<Future<Message<HttpResponse, String>>> queue = new LinkedList<>();
         for (int i = 0; i < 5; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/")
+                    .build();
             queue.add(streamEndpoint.execute(
-                    new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/"),
-                            AsyncEntityProducers.create("Some important message")),
+                    new BasicRequestProducer(request, AsyncEntityProducers.create("Some important message")),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null));
         }
         while (!queue.isEmpty()) {
@@ -1017,7 +1120,7 @@ abstract class Http1IntegrationTest {
             final HttpResponse response = result.getHead();
             Assertions.assertNotNull(response);
             Assertions.assertEquals(200, response.getCode());
-            Assertions.assertNotNull("All is well", result.getBody());
+            Assertions.assertEquals("All is well", result.getBody());
         }
     }
 
@@ -1082,13 +1185,17 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < 3; i++) {
-            final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+            final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                    .setHttpHost(target)
+                    .setPath("/echo")
+                    .build();
             final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                     new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcdef", 100000)),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -1097,11 +1204,14 @@ abstract class Http1IntegrationTest {
             final HttpResponse response1 = result1.getHead();
             Assertions.assertNotNull(response1);
             Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode());
-            Assertions.assertNotNull("You shall not pass", result1.getBody());
+            Assertions.assertEquals("You shall not pass", result1.getBody());
 
             Assertions.assertTrue(streamEndpoint.isOpen());
         }
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/echo")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, new MultiBinEntityProducer(
                         new byte[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'},
@@ -1113,7 +1223,7 @@ abstract class Http1IntegrationTest {
         final HttpResponse response1 = result1.getHead();
         Assertions.assertNotNull(response1);
         Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode());
-        Assertions.assertNotNull("You shall not pass", result1.getBody());
+        Assertions.assertEquals("You shall not pass", result1.getBody());
     }
 
     @Test
@@ -1124,16 +1234,20 @@ abstract class Http1IntegrationTest {
         server.register("/", () -> new MultiLineResponseHandler("0123456789abcd", 100));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(Http1Config.custom()
                 .setBufferSize(256)
                 .build());
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.GET, createRequestURI(serverEndpoint, "/"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, null),
                 new BasicResponseConsumer<>(new AbstractClassicEntityConsumer<String>(16, Executors.newSingleThreadExecutor()) {
@@ -1181,12 +1295,16 @@ abstract class Http1IntegrationTest {
         server.register("*", () -> new EchoHandler(2048));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/echo"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/echo")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, new AbstractClassicEntityProducer(4096, ContentType.TEXT_PLAIN, Executors.newSingleThreadExecutor()) {
 
@@ -1276,16 +1394,20 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(Http1Config.custom()
                 .setBufferSize(256)
                 .build());
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcd", 2000)),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -1310,24 +1432,36 @@ abstract class Http1IntegrationTest {
         server.register("/hello*", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello-1")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/hello-1"),
-                        AsyncEntityProducers.create("Hi there")),
+                new BasicRequestProducer(request1, AsyncEntityProducers.create("Hi there")),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
-        final HttpRequest request2 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello-2"));
-        request2.addHeader(HttpHeaders.CONNECTION, "close");
+
+        final BasicHttpRequest request2 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello-2")
+                .addHeader(HttpHeaders.CONNECTION, "close")
+                .build();
         final Future<Message<HttpResponse, String>> future2 = streamEndpoint.execute(
                 new BasicRequestProducer(request2,
                         AsyncEntityProducers.create("Hi there")),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
+
+        final BasicHttpRequest request3 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello-3")
+                .build();
         final Future<Message<HttpResponse, String>> future3 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/hello-3"),
-                        AsyncEntityProducers.create("Hi there")),
+                new BasicRequestProducer(request3, AsyncEntityProducers.create("Hi there")),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
 
         final Message<HttpResponse, String> result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
@@ -1352,9 +1486,12 @@ abstract class Http1IntegrationTest {
                 CoreMatchers.instanceOf(CancellationException.class),
                 CoreMatchers.instanceOf(ExecutionException.class)));
 
+        final BasicHttpRequest request4 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello-3")
+                .build();
         final Future<Message<HttpResponse, String>> future4 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/hello-3"),
-                        AsyncEntityProducers.create("Hi there")),
+                new BasicRequestProducer(request4, AsyncEntityProducers.create("Hi there")),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
         final Exception exception2 = Assertions.assertThrows(Exception.class, () ->
                 future4.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()));
@@ -1371,24 +1508,36 @@ abstract class Http1IntegrationTest {
         server.register("/hello*", () -> new SingleLineResponseHandler("Hi back"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello-1")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/hello-1"),
-                        AsyncEntityProducers.create("Hi there")),
+                new BasicRequestProducer(request1, AsyncEntityProducers.create("Hi there")),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
-        final HttpRequest request2 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello-2"));
-        request2.addHeader(HttpHeaders.HOST, "blah:blah");
+
+        final BasicHttpRequest request2 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello-2")
+                .addHeader(HttpHeaders.HOST, "blah:blah")
+                .build();
         final Future<Message<HttpResponse, String>> future2 = streamEndpoint.execute(
                 new BasicRequestProducer(request2,
                         AsyncEntityProducers.create("Hi there")),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
+
+        final BasicHttpRequest request3 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello-3")
+                .build();
         final Future<Message<HttpResponse, String>> future3 = streamEndpoint.execute(
-                new BasicRequestProducer(Method.POST, createRequestURI(serverEndpoint, "/hello-3"),
-                        AsyncEntityProducers.create("Hi there")),
+                new BasicRequestProducer(request3, AsyncEntityProducers.create("Hi there")),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
 
         final Message<HttpResponse, String> result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
@@ -1405,7 +1554,7 @@ abstract class Http1IntegrationTest {
         final String entity2 = result2.getBody();
         Assertions.assertNotNull(response2);
         Assertions.assertEquals(400, response2.getCode());
-        Assertions.assertTrue(entity2.length() > 0);
+        Assertions.assertFalse(entity2.isEmpty());
 
 
         final Exception exception = Assertions.assertThrows(Exception.class, () ->
@@ -1522,12 +1671,17 @@ abstract class Http1IntegrationTest {
 
         });
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final AsyncRequestProducer requestProducer = new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello"));
+        final BasicHttpRequest request = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
+        final AsyncRequestProducer requestProducer = new BasicRequestProducer(request, null);
         final StringAsyncEntityConsumer entityConsumer = new StringAsyncEntityConsumer() {
 
             @Override
@@ -1562,13 +1716,18 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                new BasicRequestProducer(request, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
         final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
         Assertions.assertNotNull(result);
@@ -1587,13 +1746,18 @@ abstract class Http1IntegrationTest {
         server.register("/ehh", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                new BasicRequestProducer(request, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
         final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
         Assertions.assertNotNull(result);
@@ -1622,13 +1786,18 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
+        final BasicHttpRequest request = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                new BasicRequestProducer(request, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
         final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
         Assertions.assertNotNull(result);
@@ -1666,13 +1835,17 @@ abstract class Http1IntegrationTest {
         });
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.GET, createRequestURI(serverEndpoint, "/hello"));
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .build();
         final DigestingEntityConsumer<String> entityConsumer = new DigestingEntityConsumer<>("MD5", new StringAsyncEntityConsumer());
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, null),
@@ -1756,12 +1929,17 @@ abstract class Http1IntegrationTest {
 
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
+        final BasicHttpRequest request = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/boom")
+                .build();
         final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/boom")),
+                new BasicRequestProducer(request, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
         final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
         Assertions.assertNotNull(result);
@@ -1782,15 +1960,20 @@ abstract class Http1IntegrationTest {
                 .setMaxLineLength(100)
                 .build());
         final InetSocketAddress serverEndpoint = server.start();
+
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.GET, createRequestURI(serverEndpoint, "/hello"));
-        request1.setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
-                "1234567890123456789012345678901234567890");
+        final BasicHttpRequest request1 = BasicRequestBuilder.get()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
+                        "1234567890123456789012345678901234567890")
+                .build();
         final Future<Message<HttpResponse, String>> future1 = streamEndpoint.execute(
                 new BasicRequestProducer(request1, null),
                 new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -1812,17 +1995,22 @@ abstract class Http1IntegrationTest {
                 .setMaxLineLength(100)
                 .build());
         final InetSocketAddress serverEndpoint = server.start();
+
+        final HttpHost target = target(serverEndpoint);
+
         client.configure(
                 new DefaultHttpProcessor(RequestContent.INSTANCE, RequestTargetHost.INSTANCE, RequestConnControl.INSTANCE));
         client.start();
 
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
-        final HttpRequest request1 = new BasicHttpRequest(Method.POST, createRequestURI(serverEndpoint, "/hello"));
-        request1.setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
-                "1234567890123456789012345678901234567890");
+        final BasicHttpRequest request1 = BasicRequestBuilder.post()
+                .setHttpHost(target)
+                .setPath("/hello")
+                .setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" +
+                        "1234567890123456789012345678901234567890")
+                .build();
 
         final byte[] b = new byte[2048];
         for (int i = 0; i < b.length; i++) {
diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/JSSEProviderIntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/JSSEProviderIntegrationTest.java
index e82dd0960..36a3d9f5c 100644
--- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/JSSEProviderIntegrationTest.java
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/JSSEProviderIntegrationTest.java
@@ -28,8 +28,6 @@
 package org.apache.hc.core5.testing.nio;
 
 import java.net.InetSocketAddress;
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.net.URL;
 import java.security.Provider;
 import java.security.SecureRandom;
@@ -40,15 +38,17 @@ import java.util.Set;
 import java.util.concurrent.Future;
 
 import org.apache.hc.core5.http.HttpHeaders;
+import org.apache.hc.core5.http.HttpHost;
 import org.apache.hc.core5.http.HttpResponse;
 import org.apache.hc.core5.http.Message;
-import org.apache.hc.core5.http.Method;
+import org.apache.hc.core5.http.message.BasicHttpRequest;
 import org.apache.hc.core5.http.nio.entity.StringAsyncEntityConsumer;
 import org.apache.hc.core5.http.nio.support.AsyncRequestBuilder;
 import org.apache.hc.core5.http.nio.support.BasicRequestProducer;
 import org.apache.hc.core5.http.nio.support.BasicResponseConsumer;
 import org.apache.hc.core5.http.protocol.DefaultHttpProcessor;
 import org.apache.hc.core5.http.protocol.RequestValidateHost;
+import org.apache.hc.core5.http.support.BasicRequestBuilder;
 import org.apache.hc.core5.reactor.IOReactorConfig;
 import org.apache.hc.core5.ssl.SSLContextBuilder;
 import org.apache.hc.core5.util.TimeValue;
@@ -195,12 +195,8 @@ abstract class JSSEProviderIntegrationTest {
     @Order(3)
     private final ClientResource clientResource = new ClientResource();
 
-    private URI createRequestURI(final InetSocketAddress serverEndpoint, final String path) {
-        try {
-            return new URI("https", null, "localhost", serverEndpoint.getPort(), path, null, null);
-        } catch (final URISyntaxException e) {
-            throw new IllegalStateException();
-        }
+    private HttpHost target(final InetSocketAddress serverEndpoint) {
+        return new HttpHost("https", null, "localhost", serverEndpoint.getPort());
     }
 
     @Test
@@ -208,14 +204,19 @@ abstract class JSSEProviderIntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final Future<ClientSessionEndpoint> connectFuture = client.connect(
-                "localhost", serverEndpoint.getPort(), TIMEOUT);
+        final Future<ClientSessionEndpoint> connectFuture = client.connect(target, TIMEOUT);
         final ClientSessionEndpoint streamEndpoint = connectFuture.get();
 
         for (int i = 0; i < REQ_NUM; i++) {
+            final BasicHttpRequest request = BasicRequestBuilder.get()
+                    .setHttpHost(target)
+                    .setPath("/hello")
+                    .build();
             final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                    new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                    new BasicRequestProducer(request, null),
                     new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
             final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
             Assertions.assertNotNull(result);
@@ -232,14 +233,17 @@ abstract class JSSEProviderIntegrationTest {
         server.register("/hello", () -> new SingleLineResponseHandler("Hi there"));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
-        final URI requestURI = createRequestURI(serverEndpoint, "/hello");
         for (int i = 0; i < REQ_NUM; i++) {
             final Future<ClientSessionEndpoint> connectFuture = client.connect(
                     "localhost", serverEndpoint.getPort(), TIMEOUT);
             try (final ClientSessionEndpoint streamEndpoint = connectFuture.get()) {
                 final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                        AsyncRequestBuilder.get(requestURI)
+                        AsyncRequestBuilder.get()
+                                .setHttpHost(target)
+                                .setPath("/hello")
                                 .addHeader(HttpHeaders.CONNECTION, "close")
                                 .build(),
                         new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
@@ -260,14 +264,20 @@ abstract class JSSEProviderIntegrationTest {
         server.configure(new DefaultHttpProcessor(new RequestValidateHost()));
         final InetSocketAddress serverEndpoint = server.start();
 
+        final HttpHost target = target(serverEndpoint);
+
         client.start();
 
         for (int i = 0; i < REQ_NUM; i++) {
             final Future<ClientSessionEndpoint> connectFuture = client.connect(
                     "localhost", serverEndpoint.getPort(), TIMEOUT);
             try (final ClientSessionEndpoint streamEndpoint = connectFuture.get()) {
+                final BasicHttpRequest request = BasicRequestBuilder.get()
+                        .setHttpHost(target)
+                        .setPath("/hello")
+                        .build();
                 final Future<Message<HttpResponse, String>> future = streamEndpoint.execute(
-                        new BasicRequestProducer(Method.GET, createRequestURI(serverEndpoint, "/hello")),
+                        new BasicRequestProducer(request, null),
                         new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null);
                 final Message<HttpResponse, String> result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit());
                 Assertions.assertNotNull(result);