From f941d24a8de6614f742138cead420fd046ea69b2 Mon Sep 17 00:00:00 2001
From: Maxim Nesen <maxim.nesen@oracle.com>
Date: Tue, 22 Sep 2020 09:40:35 +0200
Subject: [PATCH 1/3] Expect:100-Continue header handling

Signed-off-by: Maxim Nesen <maxim.nesen@oracle.com>
---
 .../jersey/client/ClientProperties.java       |  27 +++-
 .../client/http/Expect100ContinueFeature.java |  50 +++++++
 .../client/internal/HttpUrlConnector.java     |  25 +++-
 tests/e2e-client/pom.xml                      |   5 +-
 .../Expect100ContinueTest.java                | 134 ++++++++++++++++++
 5 files changed, 238 insertions(+), 3 deletions(-)
 create mode 100644 core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
 create mode 100644 tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java

diff --git a/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java b/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
index e4f20be6a4..dab9c8cc5a 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -405,6 +405,31 @@ public final class ClientProperties {
      */
     public static final String REQUEST_ENTITY_PROCESSING = "jersey.config.client.request.entity.processing";
 
+    /**
+     * Registers 100-Continue value for Expect header processing to be set in HttpUrlConnector (default Jersey
+     * connector)
+     *
+     * @since 2.32
+     */
+    public static final String EXPECT_100_CONTINUE = "jersey.config.client.request.expect.100.continue.processing";
+
+    /**
+     * Property for threshold size for content length after which Expect:100-Continue header would be applied
+     * before the main request
+     *
+     * @since 2.32
+     */
+    public static final String
+            EXPECT_100_CONTINUE_THRESHOLD_SIZE = "jersey.config.client.request.expect.100.continue.threshold.size";
+
+    /**
+     * Default threshold size (64kb) after which which Expect:100-Continue header would be applied before
+     * the main request
+     *
+     * @since 2.32
+     */
+    public static final Long DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE = 64000L;
+
     private ClientProperties() {
         // prevents instantiation
     }
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java b/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
new file mode 100644
index 0000000000..ecdd2220b2
--- /dev/null
+++ b/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.client.http;
+
+import org.glassfish.jersey.client.ClientProperties;
+
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+
+public class Expect100ContinueFeature implements Feature {
+
+    private long thresholdSize;
+
+    public Expect100ContinueFeature() {
+        this(ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE);
+    }
+    public Expect100ContinueFeature(long thresholdSize) {
+        this.thresholdSize = thresholdSize;
+    }
+
+    @Override
+    public boolean configure(FeatureContext configurableContext) {
+        if (configurableContext.getConfiguration().getProperty(
+                ClientProperties.EXPECT_100_CONTINUE) == null) {
+            configurableContext.property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE);
+        } else {
+            return false; //Expect:100-Continue handling is already done via property config
+        }
+        if (configurableContext.getConfiguration().getProperty(
+                ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE) == null) {
+            configurableContext.property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, thresholdSize);
+        }
+        return true;
+    }
+
+}
\ No newline at end of file
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
index a4255a7f7c..692f352a43 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
@@ -333,9 +333,16 @@ private ClientResponse _apply(final ClientRequest request) throws IOException {
             if (entity != null) {
                 RequestEntityProcessing entityProcessing = request.resolveProperty(
                         ClientProperties.REQUEST_ENTITY_PROCESSING, RequestEntityProcessing.class);
+                final Long expectContinueSizeThreshold = ClientProperties.getValue(
+                        request.getConfiguration().getProperties(),
+                        ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE,
+                        ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE, Long.class);
+
+                final long length = request.getLengthLong();
+                final boolean allowStreaming = length > expectContinueSizeThreshold
+                        || entityProcessing == RequestEntityProcessing.CHUNKED;
 
                 if (entityProcessing == null || entityProcessing != RequestEntityProcessing.BUFFERED) {
-                    final long length = request.getLengthLong();
                     if (fixLengthStreaming && length > 0) {
                         uc.setFixedLengthStreamingMode(length);
                     } else if (entityProcessing == RequestEntityProcessing.CHUNKED) {
@@ -351,6 +358,8 @@ private ClientResponse _apply(final ClientRequest request) throws IOException {
                     }
                 }
 
+                processExpect100Continue(request, uc, allowStreaming);
+
                 request.setStreamProvider(contentLength -> {
                     setOutboundHeaders(request.getStringHeaders(), uc);
                     return uc.getOutputStream();
@@ -527,6 +536,20 @@ public Object run() throws NoSuchFieldException,
         }
     }
 
+    private void processExpect100Continue(ClientRequest request, HttpURLConnection uc, boolean allowStreaming) {
+
+        final Boolean expectContinueActivated = ClientProperties.getValue(request.getConfiguration().getProperties(),
+                ClientProperties.EXPECT_100_CONTINUE, Boolean.class);
+
+        if (!Boolean.TRUE.equals(expectContinueActivated)
+                || !("POST".equals(uc.getRequestMethod()) || "PUT".equals(uc.getRequestMethod()))
+                || !allowStreaming
+        ) {
+            return;
+        }
+        uc.setRequestProperty("Expect", "100-Continue");
+    }
+
     @Override
     public String getName() {
         return "HttpUrlConnection " + AccessController.doPrivileged(PropertiesHelper.getSystemProperty("java.version"));
diff --git a/tests/e2e-client/pom.xml b/tests/e2e-client/pom.xml
index 78517271fc..6a58e5256a 100644
--- a/tests/e2e-client/pom.xml
+++ b/tests/e2e-client/pom.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -42,6 +42,9 @@
                     <reuseForks>false</reuseForks>
                     <enableAssertions>false</enableAssertions>
                     <skipTests>${skip.e2e}</skipTests>
+                    <systemPropertyVariables>
+                        <sun.net.http.allowRestrictedHeaders>true</sun.net.http.allowRestrictedHeaders>
+                    </systemPropertyVariables>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
new file mode 100644
index 0000000000..f298deddeb
--- /dev/null
+++ b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.tests.e2e.client.httpurlconnector;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.client.ClientProperties;
+import org.glassfish.jersey.client.HttpUrlConnectorProvider;
+import org.glassfish.jersey.client.RequestEntityProcessing;
+import org.glassfish.jersey.client.http.Expect100ContinueFeature;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+import org.junit.Test;
+
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+
+import static org.junit.Assert.assertEquals;
+
+public class Expect100ContinueTest extends JerseyTest {
+
+    private static final String RESOURCE_PATH = "expect";
+
+    @Path(RESOURCE_PATH)
+    public static class Expect100ContinueResource {
+
+        /**
+         * Disclamer - in tests we do not process 100-Continue response properly, so we operate 204 (no content)
+         * and 200 (ok) response codes in order to distinguish between proper and not proper Expect:100-Continue
+         * request handling.
+         *
+         * @param expect - Header value for Expect
+         *
+         * @return 200 (no expectations), 204 (Expect:100-Continue header processed)
+         */
+        @POST
+        public Response publishResource(@HeaderParam("Expect") String expect) {
+            if ("100-Continue".equalsIgnoreCase(expect)) {
+                return Response.noContent().build();
+            }
+            return Response.ok().build();
+        }
+
+    }
+
+    @Override
+    protected Application configure() {
+        return new ResourceConfig(Expect100ContinueTest.Expect100ContinueResource.class);
+    }
+
+    @Override
+    protected void configureClient(ClientConfig config) {
+        config.connectorProvider(new HttpUrlConnectorProvider());
+    }
+
+    @Test
+    public void testExpect100Continue() {
+       final Response response =  target(RESOURCE_PATH).request().post(Entity.text("123456789012345678901234"
+               + "56789012345678901234567890123456789012345678901234567890"));
+       assertEquals("Expected 200", 200, response.getStatus()); //no Expect header sent - responce OK
+    }
+
+    @Test
+    public void testExpect100ContinueChunked() {
+       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature())
+               .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
+               RequestEntityProcessing.CHUNKED).request().post(Entity.text("123456789012345678901234"
+               + "56789012345678901234567890123456789012345678901234567890"));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueBuffered() {
+       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature())
+               .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
+               RequestEntityProcessing.BUFFERED).request().header(HttpHeaders.CONTENT_LENGTH, 65000L)
+               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueCustomLength() {
+       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature(100L))
+               .request().header(HttpHeaders.CONTENT_LENGTH, 101L)
+               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueCustomLengthWrong() {
+       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature(100L))
+               .request().header(HttpHeaders.CONTENT_LENGTH, 99L)
+               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+       assertEquals("Expected 200", 200, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueCustomLengthProperty() {
+       final Response response =  target(RESOURCE_PATH)
+               .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 555L)
+               .register(new Expect100ContinueFeature())
+               .request().header(HttpHeaders.CONTENT_LENGTH, 666L)
+               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueRegisterViaCustomProperty() {
+       final Response response =  target(RESOURCE_PATH)
+               .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 43L)
+               .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
+               .request().header(HttpHeaders.CONTENT_LENGTH, 44L)
+               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+}

From 0b664599ac4877686ec2a15945a9b2208a63cbf0 Mon Sep 17 00:00:00 2001
From: Maxim Nesen <maxim.nesen@oracle.com>
Date: Wed, 23 Sep 2020 06:41:02 +0200
Subject: [PATCH 2/3] HTTP 100-Continue handling arranged

Signed-off-by: Maxim Nesen <maxim.nesen@oracle.com>
---
 .../jersey/client/ClientProperties.java       | 10 +++---
 .../client/http/Expect100ContinueFeature.java | 22 ++++++++++++-
 .../client/internal/HttpUrlConnector.java     | 18 +++++-----
 .../Expect100ContinueTest.java                | 33 ++++++++++---------
 4 files changed, 53 insertions(+), 30 deletions(-)

diff --git a/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java b/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
index dab9c8cc5a..b01857adcc 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
@@ -406,8 +406,8 @@ public final class ClientProperties {
     public static final String REQUEST_ENTITY_PROCESSING = "jersey.config.client.request.entity.processing";
 
     /**
-     * Registers 100-Continue value for Expect header processing to be set in HttpUrlConnector (default Jersey
-     * connector)
+     * Allows for HTTP Expect:100-Continue being handled by the HttpUrlConnector (default Jersey
+     * connector).
      *
      * @since 2.32
      */
@@ -415,7 +415,7 @@ public final class ClientProperties {
 
     /**
      * Property for threshold size for content length after which Expect:100-Continue header would be applied
-     * before the main request
+     * before the main request.
      *
      * @since 2.32
      */
@@ -424,11 +424,11 @@ public final class ClientProperties {
 
     /**
      * Default threshold size (64kb) after which which Expect:100-Continue header would be applied before
-     * the main request
+     * the main request.
      *
      * @since 2.32
      */
-    public static final Long DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE = 64000L;
+    public static final Long DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE = 65536L;
 
     private ClientProperties() {
         // prevents instantiation
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java b/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
index ecdd2220b2..3af806c994 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
@@ -28,10 +28,30 @@ public class Expect100ContinueFeature implements Feature {
     public Expect100ContinueFeature() {
         this(ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE);
     }
-    public Expect100ContinueFeature(long thresholdSize) {
+
+    private Expect100ContinueFeature(long thresholdSize) {
         this.thresholdSize = thresholdSize;
     }
 
+    /**
+     * Creates Expect100ContinueFeature with custom (not default) threshold size for content length.
+     *
+     * @param thresholdSize size of threshold
+     * @return Expect100Continue Feature
+     */
+    public static Expect100ContinueFeature withCustomThreshold(long thresholdSize) {
+        return new Expect100ContinueFeature(thresholdSize);
+    }
+
+    /**
+     * Creates Expect100Continue Feature with default threshold size
+     *
+     * @return Expect100Continue Feature
+     */
+    public static Expect100ContinueFeature basic() {
+        return new Expect100ContinueFeature();
+    }
+
     @Override
     public boolean configure(FeatureContext configurableContext) {
         if (configurableContext.getConfiguration().getProperty(
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
index 692f352a43..cd017053fb 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
@@ -333,14 +333,8 @@ private ClientResponse _apply(final ClientRequest request) throws IOException {
             if (entity != null) {
                 RequestEntityProcessing entityProcessing = request.resolveProperty(
                         ClientProperties.REQUEST_ENTITY_PROCESSING, RequestEntityProcessing.class);
-                final Long expectContinueSizeThreshold = ClientProperties.getValue(
-                        request.getConfiguration().getProperties(),
-                        ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE,
-                        ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE, Long.class);
 
                 final long length = request.getLengthLong();
-                final boolean allowStreaming = length > expectContinueSizeThreshold
-                        || entityProcessing == RequestEntityProcessing.CHUNKED;
 
                 if (entityProcessing == null || entityProcessing != RequestEntityProcessing.BUFFERED) {
                     if (fixLengthStreaming && length > 0) {
@@ -358,7 +352,7 @@ private ClientResponse _apply(final ClientRequest request) throws IOException {
                     }
                 }
 
-                processExpect100Continue(request, uc, allowStreaming);
+                processExpect100Continue(request, uc, length, entityProcessing);
 
                 request.setStreamProvider(contentLength -> {
                     setOutboundHeaders(request.getStringHeaders(), uc);
@@ -536,10 +530,18 @@ public Object run() throws NoSuchFieldException,
         }
     }
 
-    private void processExpect100Continue(ClientRequest request, HttpURLConnection uc, boolean allowStreaming) {
+    private void processExpect100Continue(ClientRequest request, HttpURLConnection uc,
+                                          long length, RequestEntityProcessing entityProcessing) {
 
         final Boolean expectContinueActivated = ClientProperties.getValue(request.getConfiguration().getProperties(),
                 ClientProperties.EXPECT_100_CONTINUE, Boolean.class);
+        final Long expectContinueSizeThreshold = ClientProperties.getValue(
+                request.getConfiguration().getProperties(),
+                ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE,
+                ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE, Long.class);
+
+        final boolean allowStreaming = length > expectContinueSizeThreshold
+                || entityProcessing == RequestEntityProcessing.CHUNKED;
 
         if (!Boolean.TRUE.equals(expectContinueActivated)
                 || !("POST".equals(uc.getRequestMethod()) || "PUT".equals(uc.getRequestMethod()))
diff --git a/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
index f298deddeb..82b7e7abf6 100644
--- a/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
+++ b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
@@ -38,6 +38,9 @@
 public class Expect100ContinueTest extends JerseyTest {
 
     private static final String RESOURCE_PATH = "expect";
+    private static final String ENTITY_STRING = "1234567890123456789012345678901234567890123456789012"
+           + "3456789012345678901234567890";
+
 
     @Path(RESOURCE_PATH)
     public static class Expect100ContinueResource {
@@ -73,52 +76,50 @@ protected void configureClient(ClientConfig config) {
 
     @Test
     public void testExpect100Continue() {
-       final Response response =  target(RESOURCE_PATH).request().post(Entity.text("123456789012345678901234"
-               + "56789012345678901234567890123456789012345678901234567890"));
+       final Response response =  target(RESOURCE_PATH).request().post(Entity.text(ENTITY_STRING));
        assertEquals("Expected 200", 200, response.getStatus()); //no Expect header sent - responce OK
     }
 
     @Test
     public void testExpect100ContinueChunked() {
-       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature())
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.basic())
                .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
-               RequestEntityProcessing.CHUNKED).request().post(Entity.text("123456789012345678901234"
-               + "56789012345678901234567890123456789012345678901234567890"));
+               RequestEntityProcessing.CHUNKED).request().post(Entity.text(ENTITY_STRING));
        assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
     }
 
     @Test
     public void testExpect100ContinueBuffered() {
-       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature())
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.basic())
                .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
-               RequestEntityProcessing.BUFFERED).request().header(HttpHeaders.CONTENT_LENGTH, 65000L)
-               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+               RequestEntityProcessing.BUFFERED).request().header(HttpHeaders.CONTENT_LENGTH, 67000L)
+               .post(Entity.text(ENTITY_STRING));
        assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
     }
 
     @Test
     public void testExpect100ContinueCustomLength() {
-       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature(100L))
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.withCustomThreshold(100L))
                .request().header(HttpHeaders.CONTENT_LENGTH, 101L)
-               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+               .post(Entity.text(ENTITY_STRING));
        assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
     }
 
     @Test
     public void testExpect100ContinueCustomLengthWrong() {
-       final Response response =  target(RESOURCE_PATH).register(new Expect100ContinueFeature(100L))
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.withCustomThreshold(100L))
                .request().header(HttpHeaders.CONTENT_LENGTH, 99L)
-               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
-       assertEquals("Expected 200", 200, response.getStatus()); //Expect header sent - No Content response
+               .post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 200", 200, response.getStatus()); //Expect header NOT sent - low request size
     }
 
     @Test
     public void testExpect100ContinueCustomLengthProperty() {
        final Response response =  target(RESOURCE_PATH)
                .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 555L)
-               .register(new Expect100ContinueFeature())
+               .register(Expect100ContinueFeature.basic())
                .request().header(HttpHeaders.CONTENT_LENGTH, 666L)
-               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+               .post(Entity.text(ENTITY_STRING));
        assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
     }
 
@@ -128,7 +129,7 @@ public void testExpect100ContinueRegisterViaCustomProperty() {
                .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 43L)
                .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
                .request().header(HttpHeaders.CONTENT_LENGTH, 44L)
-               .post(Entity.text("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+               .post(Entity.text(ENTITY_STRING));
        assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
     }
 }

From 4f4f5f3ceb08c231cbdcbe05f573b9f63076579c Mon Sep 17 00:00:00 2001
From: Maxim Nesen <maxim.nesen@oracle.com>
Date: Wed, 23 Sep 2020 18:42:42 +0200
Subject: [PATCH 3/3] resolve properties fix

Signed-off-by: Maxim Nesen <maxim.nesen@oracle.com>
---
 .../org/glassfish/jersey/client/ClientRequest.java     |  4 ++--
 .../jersey/client/internal/HttpUrlConnector.java       | 10 ++++------
 .../client/httpurlconnector/Expect100ContinueTest.java |  5 -----
 3 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java b/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java
index 162dedaa96..012ef337da 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -167,7 +167,7 @@ public <T> T resolveProperty(final String name, final T defaultValue) {
 
     private <T> T resolveProperty(final String name, Object defaultValue, final Class<T> type) {
         // Check runtime configuration first
-        Object result = clientConfig.getProperty(name);
+        Object result = getConfiguration().getProperty(name);
         if (result != null) {
             defaultValue = result;
         }
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
index cd017053fb..0f0614c519 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
@@ -530,15 +530,13 @@ public Object run() throws NoSuchFieldException,
         }
     }
 
-    private void processExpect100Continue(ClientRequest request, HttpURLConnection uc,
+    private static void processExpect100Continue(ClientRequest request, HttpURLConnection uc,
                                           long length, RequestEntityProcessing entityProcessing) {
-
-        final Boolean expectContinueActivated = ClientProperties.getValue(request.getConfiguration().getProperties(),
+        final Boolean expectContinueActivated = request.resolveProperty(
                 ClientProperties.EXPECT_100_CONTINUE, Boolean.class);
-        final Long expectContinueSizeThreshold = ClientProperties.getValue(
-                request.getConfiguration().getProperties(),
+        final Long expectContinueSizeThreshold = request.resolveProperty(
                 ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE,
-                ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE, Long.class);
+                ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE);
 
         final boolean allowStreaming = length > expectContinueSizeThreshold
                 || entityProcessing == RequestEntityProcessing.CHUNKED;
diff --git a/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
index 82b7e7abf6..1616824478 100644
--- a/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
+++ b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
@@ -69,11 +69,6 @@ protected Application configure() {
         return new ResourceConfig(Expect100ContinueTest.Expect100ContinueResource.class);
     }
 
-    @Override
-    protected void configureClient(ClientConfig config) {
-        config.connectorProvider(new HttpUrlConnectorProvider());
-    }
-
     @Test
     public void testExpect100Continue() {
        final Response response =  target(RESOURCE_PATH).request().post(Entity.text(ENTITY_STRING));