normalize the scheme case in the Uri constructor

client/src/main/java/org/asynchttpclient/uri/Uri.java

@@ -20,6 +20,7 @@
 
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.util.Locale;
 
 import static org.asynchttpclient.util.Assertions.assertNotEmpty;
 import static org.asynchttpclient.util.MiscUtils.isEmpty;
@@ -43,15 +44,18 @@
     private final boolean webSocket;
 
     public Uri(String scheme, @Nullable String userInfo, String host, int port, String path, @Nullable String query, @Nullable String fragment) {
-        this.scheme = assertNotEmpty(scheme, "scheme");
+        // rfc3986#section-3.1: schemes are case-insensitive, and validateSupportedScheme accepts any
+        // case. UriParser lowercases the schemes it parses; normalizing here keeps the constructor and
+        // withNewScheme consistent with it, so secured can't come out false for an "HTTPS" Uri.
+        this.scheme = assertNotEmpty(scheme, "scheme").toLowerCase(Locale.ROOT);
         this.userInfo = userInfo;
         this.host = assertNotEmpty(host, "host");
         this.port = port;
         this.path = path;
         this.query = query;
         this.fragment = fragment;
-        secured = HTTPS.equals(scheme) || WSS.equals(scheme);
-        webSocket = WS.equals(scheme) || WSS.equalsIgnoreCase(scheme);
+        secured = HTTPS.equals(this.scheme) || WSS.equals(this.scheme);
+        webSocket = WS.equals(this.scheme) || WSS.equals(this.scheme);
     }
 
     public static Uri create(String originalUrl) {
@@ -142,7 +146,7 @@
     }
 
     /**
      * @return [scheme]://[hostname](:[port])/path. Port is omitted if it matches the scheme's default one.
      */
     public String toBaseUrl() {
         StringBuilder sb = StringBuilderPool.DEFAULT.stringBuilder();
@@ -221,7 +225,7 @@
     }
 
     @Override
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }

client/src/test/java/org/asynchttpclient/uri/UriTest.java

@@ -181,6 +181,28 @@ public void testWithNewScheme() {
         assertEquals("https://user@example.com:44/path/path2?query=4", newUri.toUrl(), "toUrl returned incorrect url");
     }
 
+    @RepeatedIfExceptionsTest(repeats = 5)
+    public void testUpperCaseSchemeIsSecured() {
+        Uri uri = new Uri("HTTPS", null, "example.com", -1, "/", null, null);
+        Uri.validateSupportedScheme(uri);
+        assertTrue(uri.isSecured(), "HTTPS must be secured");
+        assertEquals(443, uri.getSchemeDefaultPort());
+        assertEquals(443, uri.getExplicitPort());
+
+        Uri wss = new Uri("WSS", null, "example.com", -1, "/", null, null);
+        assertTrue(wss.isSecured(), "WSS must be secured");
+        assertTrue(wss.isWebSocket());
+    }
+
+    @RepeatedIfExceptionsTest(repeats = 5)
+    public void testMixedCaseSchemeIsNormalized() {
+        Uri uri = new Uri("HtTp", "user", "example.com", 44, "/path", "query=4", null);
+        assertEquals("http", uri.getScheme());
+        assertEquals("http://user@example.com:44/path?query=4", uri.toUrl());
+        assertEquals(uri, new Uri("http", "user", "example.com", 44, "/path", "query=4", null));
+        assertTrue(uri.withNewScheme("HTTPS").isSecured());
+    }
+
     @RepeatedIfExceptionsTest(repeats = 5)
     public void testWithNewQuery() {
         Uri uri = new Uri("http", "user", "example.com", 44, "/path/path2", "query=4", null);